How to Fix 'output parsing error during development' in AutoGen (TypeScript)

If you’re seeing output parsing error during development in AutoGen TypeScript, it usually means the agent produced text that did not match the structured format AutoGen expected. In practice, this shows up when a tool call, JSON response, or assistant message is slightly malformed during local development and the parser rejects it.

This is usually not an LLM “failure” so much as a contract mismatch between what your code expects and what the model actually returned.

The Most Common Cause

The #1 cause is asking AutoGen to return structured output without enforcing a strict schema or parser-friendly format. In TypeScript, this often happens when you use AssistantAgent with tool calling or JSON output, but the model returns extra prose, markdown fences, or invalid JSON.

Here’s the broken pattern versus the fixed one:

// BROKEN
import { AssistantAgent } from "@autogen/core";

const agent = new AssistantAgent({
  name: "support_agent",
  systemMessage: `
Return JSON with fields: status, reason.
`,
});

// Model may still answer:
// "Sure — here is the JSON:\n```json\n{...}\n```"

// FIXED
import { AssistantAgent } from "@autogen/core";

const agent = new AssistantAgent({
  name: "support_agent",
  systemMessage: `
You must respond with ONLY valid JSON.
No markdown.
No explanation.
No code fences.
Schema:
{
  "status": "string",
  "reason": "string"
}
`,
});

If you’re using a response formatter or structured output helper, use it instead of relying on prompt-only instructions. Prompting alone is not enough when the parser is strict.

Other Possible Causes

1. Tool return value is not serializable

If your function returns undefined, a class instance, or circular data, AutoGen can fail while parsing tool output.

// BAD
const getUser = async () => {
  return new Date(); // not ideal for strict parsers
};

// GOOD
const getUser = async () => {
  return { createdAt: new Date().toISOString() };
};

2. You are mixing markdown with JSON

A lot of models will wrap JSON in fences unless explicitly blocked. That breaks parsers expecting raw JSON.

// BAD assistant output
```json
{ "approved": true }

// GOOD assistant output { "approved": true }

If your downstream code does `JSON.parse(message.content)`, fenced output will blow up immediately.

### 3. Tool schema does not match implementation

If your declared tool arguments say `amount: number` but your function expects a string, the model may generate something that looks valid but fails validation.

```ts
// BAD schema/function mismatch
const transferFunds = {
  name: "transferFunds",
  parameters: {
    type: "object",
    properties: {
      amount: { type: "number" },
    },
    required: ["amount"],
  },
};

async function transferFundsImpl(args: { amount: string }) {
  return `Transferred ${args.amount}`;
}

Make sure your TypeScript types and JSON schema agree exactly.

4. The model is being asked to do too much in one turn

Long prompts with multiple tasks often produce mixed-format answers. One sentence of explanation before the JSON is enough to trigger an output parsing error.

// BAD prompt shape
"Explain the issue and then provide JSON with resolution steps."

// BETTER prompt shape
"Return only JSON matching this schema."

How to Debug It

1. •

   Log the raw model output before parsing
   Don’t inspect only parsed objects. Print the exact assistant message content and tool payloads.

   console.log("RAW OUTPUT:", message.content);
   

2. •

   Check whether fences or extra prose are present
   Look for:

   • •

   • •leading text like “Sure”
   • •trailing explanations
   • •partially closed braces
3. •

   Validate against your schema manually
   If you expect JSON, run JSON.parse() on the raw content in isolation. If that fails, AutoGen’s parser will fail too.

   try {
     const parsed = JSON.parse(rawContent);
     console.log(parsed);
   } catch (err) {
     console.error("Invalid JSON:", rawContent);
   }
   

4. •

   Disable one feature at a time
   Remove tools, then remove structured output requirements, then simplify the system prompt. This isolates whether the problem is:

   • •tool schema mismatch
   • •malformed assistant content
   • •invalid runtime serialization

Prevention

• •Use strict schemas for any structured response path.
• •Keep tool arguments small and typed exactly the same in TypeScript and JSON Schema.
• •Tell the model to return only raw JSON when your parser expects raw JSON.
• •Add logging around every assistant turn during development so you can see the exact payload before parsing.

If you want a stable setup in AutoGen TypeScript, treat parsing as an API contract. Once that contract is loose, output parsing error during development becomes inevitable.

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.