关于多轮调用deepseek-v4-pro出现的缺少reasoning_content字段问题，我这里有一个解决办法

[H-1234-S]

描述：
使用 anthropic() 适配器配置 DeepSeek 模型时（通过 baseUrl: 'https://api.deepseek.com/anthropic/v1'），AgenticModel.responseParser 在处理响应时崩溃：

TypeError: acc is not iterable
at AgenticModel.responseParser (chunk-XXX.js:392)
at Array.reduce ()

复现代码：
const agent = createAgent({
name: "test",
model: anthropic({
model: "deepseek-chat",
apiKey: process.env.DEEPSEEK_API_KEY,
baseUrl: 'https://api.deepseek.com/anthropic/v1',
defaultParameters: { temperature: 0.3, max_tokens: 16000 }
}),
tools: [...]
});

const network = createNetwork({
name: "test-network",
agents: [agent],
});
await network.run(message); // <- TypeError here

根因分析：
responseParser 第 392 行：
return ((_b = input == null ? void 0 : input.content) != null ? _b : []).reduce((acc, item) => {

代码假设 input.content 是数组，但 DeepSeek 的 Anthropic 兼容端点返回的 content 可能：

• 是字符串（而非 [{type:"text", text:"..."}]）
• 是其他非 iterable 类型

当 content 是字符串时，[...acc, ...item] 展开失败，导致 acc is not iterable。

环境：

• @inngest/agent-kit: latest
• @inngest/ai: latest
• Node.js: 20+
• DeepSeek API: api.deepseek.com/anthropic/v1

期望行为：
responseParser 应兼容不同模型返回的多种 content 格式，或在文档中明确说明支持的格式。

[linear-code]

EXE-1864

[H-1234-S]

你好，我是一名软件工程大三学生，我在使用agentkit制作一个项目中遇到了几个问题，上一个问题换了OpenAI API规范就解决了，但是又出现了一个新的问题

我在network的router中多轮调用deepseek-v4-pro时，需要把上一轮respones中的reasoning_content字段返回，这是deepseek官方明确要求的，https://api-docs.deepseek.com/zh-cn/guides/thinking_mode 这是官方文档。

但是我发现network.state.results数组中，output.message并没有维护reasoning_content字段，导致deepseek在多轮调用中不能正确工作，我尝试解析raw参数获取reasoning_content字段

router: ({ network }) => {
                const lastResult = network.state.results.at(-1);

                if (lastResult?.raw) {
                    const raw = typeof lastResult.raw === "string"
                        ? JSON.parse(lastResult.raw)
                        : lastResult.raw;

                    const message = raw?.choices?.[0]?.message;
                    const reasoning = message?.reasoning_content;

                    if (reasoning) {
                        // 找到当前这一轮产生的 assistant 消息
                        const assistantMsg = lastResult.output?.find((m) => m.role === "assistant") as any;

                        if (assistantMsg) {
                            const originalContent = assistantMsg.content || "";

                            assistantMsg.content = `<think>\n${reasoning}\n</think>\n${originalContent}`;

                            assistantMsg.reasoning_content = reasoning;
                        }

                        // 同步修改内部历史记录 (双重保险)
                        const messages = (network.state as any)._messages;
                        if (messages && Array.isArray(messages)) {
                            const lastMsg = messages[messages.length - 1];
                            if (lastMsg && lastMsg.role === "assistant") {
                                (lastMsg as any).content = `<think>\n${reasoning}\n</think>\n${lastMsg.content || ""}`;
                                (lastMsg as any).reasoning_content = reasoning;
                            }
                        }
                    }
                }

                // 路由逻辑：如果有工具调用则继续，否则结束
                const hasToolCalls = lastResult?.output?.some(m => m.type === "tool_call");
                const hasTextResponse = lastResult?.output?.some(m => m.type === "text" && m.role === "assistant");

                if (hasTextResponse && !hasToolCalls) {
                    return undefined;
                }

                return codingAgent;
            }

这样确实可以拿到reasoning ，但是注入是个问题，我曾尝试将reasoning 注入到context中，但是很抱歉，deepseek对reasoning_content字段要求很严格，只能传递该字段，但是我不能修改message，因为框架中有它自己的规范，我应该怎么做？

[H-1234-S]

关于多轮调用deepseek-v4-pro出现的缺少reasoning_content字段问题，我这里有一个解决办法

deepseek.ts

import { createDeepSeek } from '@ai-sdk/deepseek';
import { anthropic, openai } from '@inngest/agent-kit';

export const deepseek = createDeepSeek({
  apiKey: process.env.DEEPSEEK_API_KEY,
});

interface DeepseekModel {
  provider: 'OpenAI' | 'Anthropic';
  model: 'deepseek-v4-flash' | 'deepseek-v4-pro';
  feature?: {
    temperature: number;
    max_tokens: number;
  };
}

// DeepSeek reasoner: 将 reasoning_content 存入 thread-local 变量，onCall 时读取
let pendingReasoning: string | undefined;

export const deepseekModel = ({ provider, model, feature }: DeepseekModel) => {
  if (provider === 'Anthropic') {
    return anthropic({
      model,
      baseUrl: 'https://api.deepseek.com/anthropic/v1',
      apiKey: process.env.DEEPSEEK_API_KEY,
      defaultParameters: {
        temperature: feature?.temperature,
        max_tokens: feature!.max_tokens,
      },
    });
  }

  const adapter = openai({
    model,
    baseUrl: 'https://api.deepseek.com/v1',
    apiKey: process.env.DEEPSEEK_API_KEY,
  }) as ReturnType<typeof openai> & {
    onCall?: (modelInstance: object, body: Record<string, unknown>) => void;
  };

  adapter.onCall = (model, body) => {
    // 复制父类 @inngest/ai 的 onCall 行为，设置 body.model
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    body.model = (model as any).options.model;

    // DeepSeek reasoner: 从 thread-local 变量读取 reasoning_content 并注入
    const reasoning = pendingReasoning;
    console.log('[DeepSeek onCall] pendingReasoning:', reasoning ? `${reasoning.slice(0, 100)}...` : 'null');
    if (reasoning) {
      const messages = body.messages as Array<Record<string, unknown>> | undefined;
      console.log('[DeepSeek onCall] messages count:', messages?.length);
      if (messages) {
        for (let i = messages.length - 1; i >= 0; i--) {
          const msg = messages[i];
          const hasToolCalls = !!(msg.tool_calls && (msg.tool_calls as unknown[]).length > 0);
          const hasContent = !!(msg.content && (msg.content as string).trim() !== '');
          console.log(`[DeepSeek onCall] msg[${i}]: role=${msg.role}, hasToolCalls=${hasToolCalls}, hasContent=${hasContent}`);
          if (msg.role === 'assistant' && hasToolCalls) {
            msg.reasoning_content = reasoning;
            console.log('[DeepSeek onCall] injected reasoning_content to msg index:', i);
            break;
          }
          if (msg.role === 'assistant' && hasContent) {
            msg.reasoning_content = reasoning;
            console.log('[DeepSeek onCall] injected reasoning_content to text-msg index:', i);
            break;
          }
        }
      }
    }
    // 注入后清除，避免泄露到后续请求
    pendingReasoning = undefined;
  };

  return adapter;
};

// 导出给 router 调用：从 raw 响应提取 reasoning_content 并存入 thread-local 变量
export const setReasoning: (reasoning: string) => void = (reasoning) => {
  pendingReasoning = reasoning;
};

createNetwork

const network = createNetwork({
            name: "polaris-network",
            agents: [codingAgent],
            maxIter: 20,
            router: ({ network }) => {
                const lastResult = network.state.results.at(-1);
                if (!lastResult) return codingAgent;

                // onCall 钩子会在下一轮请求发送前把它注入到对应 assistant 消息中
                // 注意：raw 可能是 string（JSON 字符串）需要解析
                let raw: Record<string, unknown> | undefined;
                const rawData = lastResult.raw;
                if (typeof rawData === 'string') {
                    try {
                        raw = JSON.parse(rawData);
                    } catch (e) {
                        console.error('[Router] JSON.parse failed:', e);
                    }
                } else if (rawData && typeof rawData === 'object') {
                    raw = rawData as Record<string, unknown>;
                }

                if (raw) {
                    const reasoning = (raw as any)?.choices?.[0]?.message?.reasoning_content as string | undefined;
                    if (reasoning) {
                        console.log('[Router] extracted reasoning:', `${reasoning.slice(0, 100)}...`);
                        setReasoning(reasoning);
                    }
                }

                const hasToolCalls = lastResult?.output?.some(m => m.type === "tool_call");
                const hasTextResponse = lastResult?.output?.some(
                    (m) => m.type === "text" && m.role === "assistant"
                );

                // 如果只有文本且没有工具调用，说明 Agent 任务完成了，退出循环
                if (hasTextResponse && !hasToolCalls) {
                    return undefined;
                }

                // 只要有工具调用（或者刚拿到工具结果），就让 Agent 继续处理
                return codingAgent;
            }
        });