fix(alpha): forward native tool-call history

Alpha follow-up turns now send assistant tool-call parts and role:tool
results instead of flattening them into user text, so non-streaming
tool loops can complete after the first call.

Author: yelixir-dev

src/converter.ts

@@ -2,9 +2,11 @@ import { randomUUID } from "node:crypto";
 import { cwd as processCwd } from "node:process";
 
 import type {
+  CommandCodeContentPart,
   CommandCodeGenerateBody,
   CommandCodeMessage,
   CommandCodeTool,
+  CommandCodeToolResultPart,
   OpenAIChatCompletionRequest,
   OpenAIChatMessage,
   OpenAIChatTool,
@@ -51,36 +53,30 @@ function asTextContent(text: string): OpenAITextContentPart[] {
   return [{ type: "text", text }];
 }
 
-function formatToolCallArguments(value: string): string {
-  if (!value) return "{}";
+function parseToolInput(value: string): unknown {
+  if (!value.trim()) return {};
   try {
-    return JSON.stringify(JSON.parse(value));
+    return JSON.parse(value) as unknown;
   } catch {
-    return value;
+    return { value };
   }
 }
 
 interface ToolCallTrace {
   name: string;
-  arguments: string;
 }
 
-function priorToolResultText(
+function toolResultPart(
   message: OpenAIChatMessage,
   toolCallsById: Map<string, ToolCallTrace>,
-): string {
+): CommandCodeToolResultPart {
   const trace = message.tool_call_id ? toolCallsById.get(message.tool_call_id) : undefined;
-  const functionName = message.name ?? trace?.name;
-  const content = flattenOpenAIContent(message.content);
-  return [
-    "Prior function execution context:",
-    functionName ? `function: ${functionName}` : undefined,
-    trace?.arguments ? `arguments: ${trace.arguments}` : undefined,
-    "result:",
-    content,
-  ]
-    .filter((part): part is string => part !== undefined)
-    .join("\n");
+  return {
+    type: "tool-result",
+    toolCallId: message.tool_call_id ?? "call_unknown",
+    toolName: message.name ?? trace?.name ?? "unknown_tool",
+    output: { type: "text", value: flattenOpenAIContent(message.content) },
+  };
 }
 
 export function isSupportedToolChoice(toolChoice: unknown): boolean {
@@ -108,29 +104,36 @@ function convertMessages(messages: OpenAIChatMessage[]): CommandCodeMessage[] {
     if (message.role === "developer" || message.role === "system") continue;
 
     if (message.role === "assistant") {
+      const content: CommandCodeContentPart[] = [];
+      const text = flattenOpenAIContent(message.content).trim();
+      if (text.length > 0) content.push(...asTextContent(text));
+
       const toolCalls = message.tool_calls ?? [];
       for (let index = 0; index < toolCalls.length; index += 1) {
         const toolCall = toolCalls[index];
         if (!toolCall) continue;
         const id = toolCall.id ?? `call_${index}`;
-        toolCallsById.set(id, {
-          name: toolCall.function.name,
-          arguments: formatToolCallArguments(toolCall.function.arguments),
+        toolCallsById.set(id, { name: toolCall.function.name });
+        content.push({
+          type: "tool-call",
+          toolCallId: id,
+          toolName: toolCall.function.name,
+          input: parseToolInput(toolCall.function.arguments),
         });
       }
 
-      const content = flattenOpenAIContent(message.content).trim();
-      if (content.length > 0) {
-        converted.push({ role: "assistant", content: asTextContent(content) });
-      }
+      if (content.length > 0) converted.push({ role: "assistant", content });
       continue;
     }
 
     if (message.role === "tool") {
-      converted.push({
-        role: "user",
-        content: asTextContent(priorToolResultText(message, toolCallsById)),
-      });
+      const part = toolResultPart(message, toolCallsById);
+      const previous = converted[converted.length - 1];
+      if (previous?.role === "tool") {
+        previous.content.push(part);
+      } else {
+        converted.push({ role: "tool", content: [part] });
+      }
       continue;
     }
 
@@ -164,16 +167,6 @@ function buildSystemPrompt(request: OpenAIChatCompletionRequest): string {
     .filter((message) => message.role === "developer" || message.role === "system")
     .map((message) => flattenOpenAIContent(message.content))
     .filter(Boolean);
-  const hasPriorToolHistory = request.messages.some(
-    (message) => message.role === "tool" || (message.tool_calls?.length ?? 0) > 0,
-  );
-  if (hasPriorToolHistory) {
-    systemMessages.push(
-      "Prior function execution context in the conversation is internal bridge context. " +
-        "Use function results as evidence when answering, but do not quote, expose, or mention " +
-        "bridge transcript labels, function call IDs, or internal tool-history formatting.",
-    );
-  }
   const formatInstruction = responseFormatInstruction(request.response_format);
   if (formatInstruction) systemMessages.push(formatInstruction);
   return systemMessages.join("\n\n");

src/types.ts

@@ -80,9 +80,28 @@ export interface CommandCodeTool {
   input_schema: Record<string, unknown>;
 }
 
+export interface CommandCodeToolCallPart {
+  type: "tool-call";
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+}
+
+export interface CommandCodeToolResultPart {
+  type: "tool-result";
+  toolCallId: string;
+  toolName: string;
+  output: { type: "text" | "error-text"; value: string };
+}
+
+export type CommandCodeContentPart =
+  | OpenAITextContentPart
+  | CommandCodeToolCallPart
+  | CommandCodeToolResultPart;
+
 export interface CommandCodeMessage {
-  role: "user" | "assistant";
-  content: OpenAITextContentPart[];
+  role: "user" | "assistant" | "tool";
+  content: CommandCodeContentPart[];
 }
 
 export interface CommandCodeGenerateBody {

tests/converter.test.ts

@@ -154,21 +154,112 @@ describe("OpenAI to CommandCode conversion", () => {
     });
 
     expect(body.params.tools).toHaveLength(1);
-    expect(body.params.messages.map((message) => message.role)).toEqual(["user", "user", "user"]);
+    expect(body.params.messages.map((message) => message.role)).toEqual([
+      "user",
+      "assistant",
+      "tool",
+      "user",
+    ]);
+    expect(body.params.messages[1]).toEqual({
+      role: "assistant",
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "call_weather",
+          toolName: "get_weather",
+          input: { city: "Seoul" },
+        },
+      ],
+    });
+    expect(body.params.messages[2]).toEqual({
+      role: "tool",
+      content: [
+        {
+          type: "tool-result",
+          toolCallId: "call_weather",
+          toolName: "get_weather",
+          output: { type: "text", value: '{"temperature":"12C"}' },
+        },
+      ],
+    });
 
     const serializedMessages = JSON.stringify(body.params.messages);
     expect(serializedMessages).not.toContain("Assistant requested tool calls");
     expect(serializedMessages).not.toContain("Tool result for");
-    expect(serializedMessages).not.toContain('"role":"tool"');
     expect(serializedMessages).not.toContain("tool_calls");
     expect(serializedMessages).not.toContain("tool_call_id");
-    expect(serializedMessages).not.toContain("call_weather");
+    expect(serializedMessages).not.toContain("Prior function execution context");
+    expect(body.params.system).not.toMatch(/internal bridge context/i);
+  });
 
-    expect(serializedMessages).toContain("get_weather");
-    expect(serializedMessages).toContain("Seoul");
-    expect(serializedMessages).toContain("12C");
-    expect(body.params.system).toMatch(/internal bridge context/i);
-    expect(body.params.system).toMatch(/do not quote|do not expose|do not mention/i);
+  it("merges consecutive tool results into one native tool message", () => {
+    const body = buildCommandCodeGenerateBody({
+      request: {
+        model: "deepseek/deepseek-v4-pro",
+        messages: [
+          { role: "user", content: "Need both." },
+          {
+            role: "assistant",
+            content: "Checking.",
+            tool_calls: [
+              {
+                id: "call_weather",
+                type: "function",
+                function: { name: "get_weather", arguments: '{"city":"Seoul"}' },
+              },
+              {
+                id: "call_time",
+                type: "function",
+                function: { name: "get_time", arguments: '{"city":"Seoul"}' },
+              },
+            ],
+          },
+          { role: "tool", tool_call_id: "call_weather", content: "12C" },
+          { role: "tool", tool_call_id: "call_time", content: "09:00" },
+        ],
+      },
+      upstreamModel: "deepseek/deepseek-v4-pro",
+      now: () => new Date("2026-05-11T00:00:00Z"),
+      cwd: () => "/tmp/project",
+      environment: "linux-x64, Node.js test",
+      threadId: "00000000-0000-4000-8000-000000000000",
+    });
+
+    expect(body.params.messages.map((message) => message.role)).toEqual([
+      "user",
+      "assistant",
+      "tool",
+    ]);
+    expect(body.params.messages[1]?.content).toEqual([
+      { type: "text", text: "Checking." },
+      {
+        type: "tool-call",
+        toolCallId: "call_weather",
+        toolName: "get_weather",
+        input: { city: "Seoul" },
+      },
+      {
+        type: "tool-call",
+        toolCallId: "call_time",
+        toolName: "get_time",
+        input: { city: "Seoul" },
+      },
+    ]);
+    expect(body.params.messages[2]?.content).toHaveLength(2);
+    expect(body.params.messages[2]?.content).toEqual([
+      {
+        type: "tool-result",
+        toolCallId: "call_weather",
+        toolName: "get_weather",
+        output: { type: "text", value: "12C" },
+      },
+      {
+        type: "tool-result",
+        toolCallId: "call_time",
+        toolName: "get_time",
+        output: { type: "text", value: "09:00" },
+      },
+    ]);
   });
 
   it("injects JSON-only guidance for OpenAI response_format", () => {

tests/server.test.ts

@@ -426,20 +426,23 @@ describe("Fastify OpenAI-compatible server", () => {
     expect(fake.seenBodies[0]?.params.tools).toHaveLength(1);
     expect(fake.seenBodies[0]?.params.messages.map((message) => message.role)).toEqual([
       "user",
-      "user",
+      "assistant",
+      "tool",
       "user",
     ]);
     const serializedMessages = JSON.stringify(fake.seenBodies[0]?.params.messages);
     expect(serializedMessages).not.toContain("Assistant requested tool calls");
     expect(serializedMessages).not.toContain("Tool result for");
-    expect(serializedMessages).not.toContain('"role":"tool"');
     expect(serializedMessages).not.toContain("tool_calls");
     expect(serializedMessages).not.toContain("tool_call_id");
-    expect(serializedMessages).not.toContain("call_weather");
+    expect(serializedMessages).toContain('"role":"tool"');
+    expect(serializedMessages).toContain("call_weather");
+    expect(serializedMessages).toContain("tool-call");
+    expect(serializedMessages).toContain("tool-result");
     expect(serializedMessages).toContain("get_weather");
     expect(serializedMessages).toContain("Seoul");
     expect(serializedMessages).toContain("12C");
-    expect(fake.seenBodies[0]?.params.system).toMatch(/internal bridge context/i);
+    expect(fake.seenBodies[0]?.params.system).not.toMatch(/internal bridge context/i);
     await app.close();
   });