fix: preserve literal strings when coercing tool parameter text

The review of the coercion found that fields can legitimately carry a
bare string (a text-producing step output, a string workflow input), and
the strict parse rejected those literals and broke both the extension
and RPC submission paths.

A transport-encoded structured value always serializes as JSON text
starting with { or [, so only such text is parsed; every other string is
a genuine literal and passes through untouched, and scalars stay
literal because they are indistinguishable from the literal text. The
runner's own validation still rejects shapes a workflow cannot accept.

Co-Authored-By: GLM-5.3-Flash · Fireworks (price not published) <noreply@pi.dev>
Generated-By: pi 0.87.1 (https://pi.dev)

Author: osolmaz

src/workflows/tool-input.ts

@@ -209,10 +209,14 @@ function providerObjectSchema(variants: readonly TObject[]): TObject {
 }
 
 /**
- * Structured (untyped) tool parameters. Some tool transports deliver these as raw
- * JSON text instead of a parsed value, and one workflow runner crash per start is
- * too late to learn about it. Coerce the text into a value before schema validation
- * so malformed text fails in the tool result with a clear message.
+ * Structured (untyped) tool parameters. Some tool transports deliver these as
+ * raw JSON text instead of a parsed value, and one workflow runner crash per
+ * start is too late to learn about it. A transport-encoded structured value
+ * always serializes as JSON text that starts with `{` or `[`, so only such
+ * text is parsed; every other string is a genuine literal and passes through
+ * untouched. Scalars stay literal because a transport-encoded scalar such as
+ * `123` is indistinguishable from the literal text, and the runner's own
+ * validation still rejects a value whose shape the workflow cannot accept.
  */
 const structuredFieldsByAction: Readonly<Record<string, readonly string[]>> = {
   start: ["input"],
@@ -225,44 +229,33 @@ const structuredFieldsByAction: Readonly<Record<string, readonly string[]>> = {
 function coerceStructuredFields(
   action: string,
   value: Record<string, unknown>,
-  label: string,
+  _label: string,
 ): Record<string, unknown> {
   const fields = structuredFieldsByAction[action];
   if (fields === undefined) return value;
   const coerced = { ...value };
   for (const field of fields) {
     const raw = coerced[field];
     if (typeof raw !== "string") continue;
-    if (action === "answer" && field === "input") {
-      // Free-text answers are legitimate: the command path wraps text that is not
-      // JSON in { answer: text }, and the tool path must behave the same.
-      const parsed = tryParseJsonText(raw);
-      coerced[field] = parsed === undefined ? { answer: raw } : parsed;
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      if (action === "answer" && field === "input") {
+        // Free-text answers are legitimate: the command path wraps text that
+        // is not JSON in { answer: text }, and the tool path behaves the same.
+        coerced[field] = { answer: raw };
+      }
       continue;
     }
-    coerced[field] = parseJsonText(raw, `${label} ${field}`);
+    try {
+      coerced[field] = parseJson(raw);
+    } catch {
+      // Text that merely looks like JSON is a literal string; the runner's
+      // input validation reports it if the shape cannot be accepted.
+    }
   }
   return coerced;
 }
 
-function tryParseJsonText(text: string): unknown {
-  try {
-    return parseJson(text);
-  } catch {
-    return undefined;
-  }
-}
-
-function parseJsonText(text: string, label: string): unknown {
-  try {
-    return parseJson(text);
-  } catch (error) {
-    throw new Error(`Invalid ${label}: the parameter arrived as text and is not valid JSON.`, {
-      cause: error,
-    });
-  }
-}
-
 function parseSelectedAction<Output>(
   parsers: Readonly<Record<string, ToolInputParser<Output>>>,
   value: unknown,

test/workflow-tool-input.test.ts

@@ -103,29 +103,34 @@ describe("workflow tool input", () => {
     });
   });
 
-  it("wraps unparseable answer text like the command path", () => {
+  it("wraps free-text answer text like the command path", () => {
     expect(
       parseWorkflowToolInput({ action: "answer", requestId: "request-1", input: "approve now" }),
     ).toEqual({ action: "answer", requestId: "request-1", input: { answer: "approve now" } });
-    expect(
-      parseWorkflowToolInput({ action: "answer", requestId: "request-1", input: '"plain"' }),
-    ).toEqual({ action: "answer", requestId: "request-1", input: "plain" });
     expect(
       parseWorkflowToolInput({ action: "answer", requestId: "request-1", input: "null" }),
-    ).toEqual({ action: "answer", requestId: "request-1", input: null });
+    ).toEqual({ action: "answer", requestId: "request-1", input: { answer: "null" } });
   });
 
-  it("rejects unparseable structured text in the tool result instead of the runner", () => {
-    expect(() =>
+  it("keeps literal strings for fields the workflow may receive as text", () => {
+    expect(
+      parseWorkflowToolInput({ action: "submit", requestId: "request-1", output: "just text" }),
+    ).toEqual({ action: "submit", requestId: "request-1", output: "just text" });
+    expect(
       parseWorkflowToolInput({ action: "start", workflow: "monitor", input: "{task: check}" }),
-    ).toThrow("Invalid workflow input: the parameter arrived as text and is not valid JSON.");
-    expect(() =>
+    ).toEqual({ action: "start", workflow: "monitor", input: "{task: check}" });
+    expect(
       parseWorkflowSubmissionInput({
         action: "submit",
         requestId: "request-1",
         output: "{result:",
       }),
-    ).toThrow("Invalid workflow submission output: the parameter arrived as text");
+    ).toEqual({ action: "submit", requestId: "request-1", output: "{result:" });
+    expect(parseWorkflowToolInput({ action: "start", workflow: "monitor", input: "123" })).toEqual({
+      action: "start",
+      workflow: "monitor",
+      input: "123",
+    });
   });
 
   it("keeps object parameters unchanged", () => {