@cognipeer/agent-sdk 0.7.2 → 0.7.3

package/dist/index.d.cts

@@ -2239,6 +2239,18 @@ declare class AnthropicProvider extends BaseProvider {
     completeStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
     private buildRequestBody;
     private splitSystemMessages;
+    /**
+     * Converts unified messages to Anthropic format, coalescing consecutive
+     * tool-result messages into a single `user` turn.
+     *
+     * The unified message list carries one `role: "tool"` entry per tool call
+     * (mirroring OpenAI's shape). Anthropic's Messages API expects every
+     * `tool_result` block answering a single assistant turn's `tool_use`
+     * block(s) to be batched into ONE `user` message rather than sent as
+     * separate consecutive `user` messages.
+     */
+    private toAnthropicMessages;
+    private toAnthropicToolResult;
     private toAnthropicMessage;
     private toAnthropicTool;
     private doFetch;
@@ -2276,6 +2288,19 @@ declare class BedrockProvider extends BaseProvider {
     completeStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
     private buildConverseBody;
     private splitSystemMessages;
+    /**
+     * Converts unified messages to Bedrock Converse format, coalescing
+     * consecutive tool-result messages into a single `user` turn.
+     *
+     * The unified message list carries one `role: "tool"` entry per tool call
+     * (mirroring OpenAI's shape). Bedrock's Converse API requires every
+     * `toolResult` block answering a single assistant turn's `toolUse`
+     * block(s) to be batched into ONE `user` message — sending them as
+     * separate consecutive `user` messages triggers: "Expected toolResult
+     * blocks at messages.N.content for the following Ids: ...".
+     */
+    private toBedrockMessages;
+    private toBedrockToolResult;
     private toBedrockMessage;
     private toBedrockTool;
     private doFetch;
@@ -2297,6 +2322,7 @@ declare class VertexProvider extends BaseProvider {
     private buildUrl;
     private buildGeminiBody;
     private buildContents;
+    private toGeminiFunctionResponsePart;
     private toGeminiContent;
     private toGeminiTool;
     private getAccessToken;

package/dist/index.d.ts

@@ -2239,6 +2239,18 @@ declare class AnthropicProvider extends BaseProvider {
     completeStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
     private buildRequestBody;
     private splitSystemMessages;
+    /**
+     * Converts unified messages to Anthropic format, coalescing consecutive
+     * tool-result messages into a single `user` turn.
+     *
+     * The unified message list carries one `role: "tool"` entry per tool call
+     * (mirroring OpenAI's shape). Anthropic's Messages API expects every
+     * `tool_result` block answering a single assistant turn's `tool_use`
+     * block(s) to be batched into ONE `user` message rather than sent as
+     * separate consecutive `user` messages.
+     */
+    private toAnthropicMessages;
+    private toAnthropicToolResult;
     private toAnthropicMessage;
     private toAnthropicTool;
     private doFetch;
@@ -2276,6 +2288,19 @@ declare class BedrockProvider extends BaseProvider {
     completeStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
     private buildConverseBody;
     private splitSystemMessages;
+    /**
+     * Converts unified messages to Bedrock Converse format, coalescing
+     * consecutive tool-result messages into a single `user` turn.
+     *
+     * The unified message list carries one `role: "tool"` entry per tool call
+     * (mirroring OpenAI's shape). Bedrock's Converse API requires every
+     * `toolResult` block answering a single assistant turn's `toolUse`
+     * block(s) to be batched into ONE `user` message — sending them as
+     * separate consecutive `user` messages triggers: "Expected toolResult
+     * blocks at messages.N.content for the following Ids: ...".
+     */
+    private toBedrockMessages;
+    private toBedrockToolResult;
     private toBedrockMessage;
     private toBedrockTool;
     private doFetch;
@@ -2297,6 +2322,7 @@ declare class VertexProvider extends BaseProvider {
     private buildUrl;
     private buildGeminiBody;
     private buildContents;
+    private toGeminiFunctionResponsePart;
     private toGeminiContent;
     private toGeminiTool;
     private getAccessToken;

package/dist/index.mjs

@@ -7818,7 +7818,7 @@ var AnthropicProvider = class extends BaseProvider {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
       model: request.model || this.defaultModel,
-      messages: messages.map((m) => this.toAnthropicMessage(m)),
+      messages: this.toAnthropicMessages(messages),
       max_tokens: request.maxTokens ?? 4096,
       stream
     };
@@ -7874,20 +7874,44 @@ var AnthropicProvider = class extends BaseProvider {
       messages: rest
     };
   }
-  toAnthropicMessage(m) {
-    if (m.role === "tool" && m.toolCallId) {
-      const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
-      return {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: m.toolCallId,
-            content
-          }
-        ]
-      };
+  /**
+   * Converts unified messages to Anthropic format, coalescing consecutive
+   * tool-result messages into a single `user` turn.
+   *
+   * The unified message list carries one `role: "tool"` entry per tool call
+   * (mirroring OpenAI's shape). Anthropic's Messages API expects every
+   * `tool_result` block answering a single assistant turn's `tool_use`
+   * block(s) to be batched into ONE `user` message rather than sent as
+   * separate consecutive `user` messages.
+   */
+  toAnthropicMessages(messages) {
+    const result = [];
+    let mergingToolResults = false;
+    for (const m of messages) {
+      if (m.role === "tool" && m.toolCallId) {
+        const toolResult = this.toAnthropicToolResult(m);
+        if (mergingToolResults) {
+          result[result.length - 1].content.push(toolResult);
+        } else {
+          result.push({ role: "user", content: [toolResult] });
+          mergingToolResults = true;
+        }
+        continue;
+      }
+      mergingToolResults = false;
+      result.push(this.toAnthropicMessage(m));
     }
+    return result;
+  }
+  toAnthropicToolResult(m) {
+    const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+    return {
+      type: "tool_result",
+      tool_use_id: m.toolCallId,
+      content
+    };
+  }
+  toAnthropicMessage(m) {
     if (m.role === "assistant" && m.toolCalls?.length) {
       const content = [];
       appendReasoningBlocks(content, m.reasoning?.blocks);
@@ -8272,7 +8296,7 @@ var BedrockProvider = class extends BaseProvider {
   buildConverseBody(request) {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
-      messages: messages.map((m) => this.toBedrockMessage(m))
+      messages: this.toBedrockMessages(messages)
     };
     if (system.length > 0) {
       const systemBlocks = system.map((s) => ({ text: s }));
@@ -8322,22 +8346,47 @@ var BedrockProvider = class extends BaseProvider {
     }
     return { system, messages: rest };
   }
-  toBedrockMessage(m) {
-    if (m.role === "tool" && m.toolCallId) {
-      const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
-      return {
-        role: "user",
-        content: [
-          {
-            toolResult: {
-              toolUseId: m.toolCallId,
-              content: [{ text }],
-              status: "success"
-            }
-          }
-        ]
-      };
+  /**
+   * Converts unified messages to Bedrock Converse format, coalescing
+   * consecutive tool-result messages into a single `user` turn.
+   *
+   * The unified message list carries one `role: "tool"` entry per tool call
+   * (mirroring OpenAI's shape). Bedrock's Converse API requires every
+   * `toolResult` block answering a single assistant turn's `toolUse`
+   * block(s) to be batched into ONE `user` message — sending them as
+   * separate consecutive `user` messages triggers: "Expected toolResult
+   * blocks at messages.N.content for the following Ids: ...".
+   */
+  toBedrockMessages(messages) {
+    const result = [];
+    let mergingToolResults = false;
+    for (const m of messages) {
+      if (m.role === "tool" && m.toolCallId) {
+        const toolResult = this.toBedrockToolResult(m);
+        if (mergingToolResults) {
+          result[result.length - 1].content.push(toolResult);
+        } else {
+          result.push({ role: "user", content: [toolResult] });
+          mergingToolResults = true;
+        }
+        continue;
+      }
+      mergingToolResults = false;
+      result.push(this.toBedrockMessage(m));
     }
+    return result;
+  }
+  toBedrockToolResult(m) {
+    const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+    return {
+      toolResult: {
+        toolUseId: m.toolCallId,
+        content: [{ text }],
+        status: "success"
+      }
+    };
+  }
+  toBedrockMessage(m) {
     if (m.role === "assistant" && m.toolCalls?.length) {
       const content2 = [];
       appendBedrockReasoning(content2, m.reasoning?.blocks);
@@ -8643,12 +8692,24 @@ var VertexProvider = class extends BaseProvider {
   buildContents(messages) {
     const systemParts = [];
     const contents = [];
+    let mergingToolResults = false;
     for (const m of messages) {
       if (m.role === "system") {
         const text = typeof m.content === "string" ? m.content : m.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
         if (text) systemParts.push(text);
         continue;
       }
+      if (m.role === "tool" && m.toolCallId) {
+        const part = this.toGeminiFunctionResponsePart(m);
+        if (mergingToolResults) {
+          contents[contents.length - 1].parts.push(part);
+        } else {
+          contents.push({ role: "user", parts: [part] });
+          mergingToolResults = true;
+        }
+        continue;
+      }
+      mergingToolResults = false;
       contents.push(this.toGeminiContent(m));
     }
     return {
@@ -8656,27 +8717,22 @@ var VertexProvider = class extends BaseProvider {
       contents
     };
   }
-  toGeminiContent(m) {
-    if (m.role === "tool" && m.toolCallId) {
-      const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
-      let response;
-      try {
-        response = JSON.parse(text);
-      } catch {
-        response = { result: text };
-      }
-      return {
-        role: "user",
-        parts: [
-          {
-            functionResponse: {
-              name: m.name ?? m.toolCallId,
-              response
-            }
-          }
-        ]
-      };
+  toGeminiFunctionResponsePart(m) {
+    const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+    let response;
+    try {
+      response = JSON.parse(text);
+    } catch {
+      response = { result: text };
     }
+    return {
+      functionResponse: {
+        name: m.name ?? m.toolCallId,
+        response
+      }
+    };
+  }
+  toGeminiContent(m) {
     if (m.role === "assistant" && m.toolCalls?.length) {
       const parts2 = [];
       if (typeof m.content === "string" && m.content) {