fix: emit native Bedrock invoke stream chunks

InvokeModelWithResponseStream wraps Anthropic native stream
events in Bedrock chunk frames, while ConverseStream keeps
the Converse event schema.

Author: sf-jin-ku

src/__tests__/bedrock-stream.test.ts

@@ -261,38 +261,49 @@ describe("POST /model/{modelId}/invoke-with-response-stream", () => {
     const frames = parseFrames(res.body);
     expect(frames.length).toBeGreaterThanOrEqual(5);
 
-    // messageStart
-    expect(frames[0].eventType).toBe("messageStart");
-    expect(frames[0].payload).toEqual({ messageStart: { role: "assistant" } });
+    // InvokeModelWithResponseStream wraps Anthropic-native stream events in Bedrock
+    // EventStream chunk frames.
+    expect(frames[0].eventType).toBe("chunk");
+    expect(frames[0].payload).toMatchObject({
+      type: "message_start",
+      message: { role: "assistant", model: MODEL_ID },
+    });
 
-    // contentBlockStart
-    expect(frames[1].eventType).toBe("contentBlockStart");
+    expect(frames[1].eventType).toBe("chunk");
     expect(frames[1].payload).toEqual({
-      contentBlockIndex: 0,
-      contentBlockStart: { contentBlockIndex: 0, start: { type: "text" } },
+      type: "content_block_start",
+      index: 0,
+      content_block: { type: "text", text: "" },
     });
 
     // Content delta(s) — collect text
-    const deltas = frames.filter((f) => f.eventType === "contentBlockDelta");
+    const deltas = frames.filter(
+      (f) => (f.payload as { type?: string }).type === "content_block_delta",
+    );
     expect(deltas.length).toBeGreaterThanOrEqual(1);
     const fullText = deltas
-      .map(
-        (f) =>
-          (f.payload as { contentBlockDelta: { delta: { text: string } } }).contentBlockDelta.delta
-            .text,
-      )
+      .map((f) => (f.payload as { delta: { text: string } }).delta.text)
       .join("");
     expect(fullText).toBe("Hi there!");
 
-    // contentBlockStop
-    const stopBlock = frames.find((f) => f.eventType === "contentBlockStop");
+    // content_block_stop
+    const stopBlock = frames.find(
+      (f) => (f.payload as { type?: string }).type === "content_block_stop",
+    );
     expect(stopBlock).toBeDefined();
-    expect(stopBlock!.payload).toEqual({ contentBlockIndex: 0 });
+    expect(stopBlock!.payload).toEqual({ type: "content_block_stop", index: 0 });
 
-    // messageStop
-    const msgStop = frames.find((f) => f.eventType === "messageStop");
+    // message_delta/message_stop
+    const msgDelta = frames.find(
+      (f) => (f.payload as { type?: string }).type === "message_delta",
+    );
+    expect(msgDelta).toBeDefined();
+    expect(msgDelta!.payload).toMatchObject({
+      type: "message_delta",
+      delta: { stop_reason: "end_turn" },
+    });
+    const msgStop = frames.find((f) => (f.payload as { type?: string }).type === "message_stop");
     expect(msgStop).toBeDefined();
-    expect(msgStop!.payload).toEqual({ stopReason: "end_turn" });
   });
 
   it("returns tool call response as binary Event Stream frames", async () => {
@@ -306,38 +317,40 @@ describe("POST /model/{modelId}/invoke-with-response-stream", () => {
     expect(res.status).toBe(200);
     const frames = parseFrames(res.body);
 
-    // messageStart
-    expect(frames[0].eventType).toBe("messageStart");
-    expect(frames[0].payload).toEqual({ messageStart: { role: "assistant" } });
+    expect(frames[0].eventType).toBe("chunk");
+    expect(frames[0].payload).toMatchObject({ type: "message_start" });
 
-    // contentBlockStart with toolUse
-    expect(frames[1].eventType).toBe("contentBlockStart");
+    // content_block_start with tool_use
+    expect(frames[1].eventType).toBe("chunk");
     const startPayload = frames[1].payload as {
-      contentBlockIndex: number;
-      contentBlockStart: {
-        contentBlockIndex: number;
-        start: { toolUse: { toolUseId: string; name: string } };
-      };
+      type: string;
+      index: number;
+      content_block: { type: string; id: string; name: string; input: object };
     };
-    expect(startPayload.contentBlockIndex).toBe(0);
-    expect(startPayload.contentBlockStart.start.toolUse.name).toBe("get_weather");
-    expect(startPayload.contentBlockStart.start.toolUse.toolUseId).toBeDefined();
+    expect(startPayload).toMatchObject({
+      type: "content_block_start",
+      index: 0,
+      content_block: { type: "tool_use", name: "get_weather", input: {} },
+    });
+    expect(startPayload.content_block.id).toBeDefined();
 
-    // contentBlockDelta(s) with toolUse input
-    const deltas = frames.filter((f) => f.eventType === "contentBlockDelta");
+    // content_block_delta(s) with input_json_delta
+    const deltas = frames.filter(
+      (f) => (f.payload as { type?: string }).type === "content_block_delta",
+    );
     expect(deltas.length).toBeGreaterThanOrEqual(1);
     const fullJson = deltas
-      .map(
-        (f) =>
-          (f.payload as { contentBlockDelta: { delta: { toolUse: { input: string } } } })
-            .contentBlockDelta.delta.toolUse.input,
-      )
+      .map((f) => (f.payload as { delta: { partial_json: string } }).delta.partial_json)
       .join("");
     expect(JSON.parse(fullJson)).toEqual({ city: "SF" });
 
-    // messageStop
-    const msgStop = frames.find((f) => f.eventType === "messageStop");
-    expect(msgStop!.payload).toEqual({ stopReason: "tool_use" });
+    const msgDelta = frames.find(
+      (f) => (f.payload as { type?: string }).type === "message_delta",
+    );
+    expect(msgDelta!.payload).toMatchObject({
+      type: "message_delta",
+      delta: { stop_reason: "tool_use" },
+    });
   });
 
   it("Content-Type is application/vnd.amazon.eventstream", async () => {
@@ -467,41 +480,41 @@ describe("POST /model/{modelId}/invoke-with-response-stream (multiple tool calls
     expect(res.status).toBe(200);
     const frames = parseFrames(res.body);
 
-    // Find contentBlockStart frames
-    const blockStarts = frames.filter((f) => f.eventType === "contentBlockStart");
+    // Find content_block_start frames
+    const blockStarts = frames.filter(
+      (f) => (f.payload as { type?: string }).type === "content_block_start",
+    );
     expect(blockStarts.length).toBeGreaterThanOrEqual(2);
 
-    // First tool at contentBlockIndex 0
+    // First tool at index 0
     const start0 = blockStarts[0].payload as {
-      contentBlockIndex: number;
-      contentBlockStart: {
-        contentBlockIndex: number;
-        start: { toolUse: { name: string } };
-      };
+      index: number;
+      content_block: { name: string };
     };
-    expect(start0.contentBlockIndex).toBe(0);
-    expect(start0.contentBlockStart.start.toolUse.name).toBe("get_weather");
+    expect(start0.index).toBe(0);
+    expect(start0.content_block.name).toBe("get_weather");
 
-    // Second tool at contentBlockIndex 1
+    // Second tool at index 1
     const start1 = blockStarts[1].payload as {
-      contentBlockIndex: number;
-      contentBlockStart: {
-        contentBlockIndex: number;
-        start: { toolUse: { name: string } };
-      };
+      index: number;
+      content_block: { name: string };
     };
-    expect(start1.contentBlockIndex).toBe(1);
-    expect(start1.contentBlockStart.start.toolUse.name).toBe("get_time");
+    expect(start1.index).toBe(1);
+    expect(start1.content_block.name).toBe("get_time");
 
-    // contentBlockStop should also have correct indices
-    const blockStops = frames.filter((f) => f.eventType === "contentBlockStop");
+    // content_block_stop should also have correct indices
+    const blockStops = frames.filter(
+      (f) => (f.payload as { type?: string }).type === "content_block_stop",
+    );
     expect(blockStops.length).toBeGreaterThanOrEqual(2);
-    expect((blockStops[0].payload as { contentBlockIndex: number }).contentBlockIndex).toBe(0);
-    expect((blockStops[1].payload as { contentBlockIndex: number }).contentBlockIndex).toBe(1);
+    expect((blockStops[0].payload as { index: number }).index).toBe(0);
+    expect((blockStops[1].payload as { index: number }).index).toBe(1);
 
-    // messageStop should indicate tool_use
-    const msgStop = frames.find((f) => f.eventType === "messageStop");
-    expect(msgStop!.payload).toEqual({ stopReason: "tool_use" });
+    // message_delta should indicate tool_use
+    const msgDelta = frames.find(
+      (f) => (f.payload as { type?: string }).type === "message_delta",
+    );
+    expect(msgDelta!.payload).toMatchObject({ delta: { stop_reason: "tool_use" } });
   });
 });
 
@@ -1025,15 +1038,12 @@ describe("POST /model/{modelId}/invoke-with-response-stream (malformed tool args
     expect(res.status).toBe(200);
     const frames = parseFrames(res.body);
 
-    // Find contentBlockDelta frames with toolUse input
-    const deltas = frames.filter((f) => f.eventType === "contentBlockDelta");
+    // Find Anthropic-native content_block_delta frames with input_json_delta
+    const deltas = frames.filter(
+      (f) => (f.payload as { type?: string }).type === "content_block_delta",
+    );
     const fullJson = deltas
-      .map((f) => {
-        const payload = f.payload as {
-          contentBlockDelta: { delta: { toolUse?: { input: string } } };
-        };
-        return payload.contentBlockDelta.delta.toolUse?.input ?? "";
-      })
+      .map((f) => (f.payload as { delta: { partial_json?: string } }).delta.partial_json ?? "")
       .join("");
     // Malformed arguments should fall back to "{}"
     expect(fullJson).toBe("{}");
@@ -1060,14 +1070,22 @@ describe("POST /model/{modelId}/invoke-with-response-stream (empty content)", ()
     expect(res.status).toBe(200);
     const frames = parseFrames(res.body);
 
-    // Should still have messageStart, contentBlockStart, contentBlockStop, messageStop
-    expect(frames[0].eventType).toBe("messageStart");
-    expect(frames.find((f) => f.eventType === "contentBlockStart")).toBeDefined();
-    expect(frames.find((f) => f.eventType === "contentBlockStop")).toBeDefined();
-    expect(frames.find((f) => f.eventType === "messageStop")).toBeDefined();
+    // Should still have message_start, content_block_start, content_block_stop, message_stop
+    // payloads inside Bedrock EventStream chunk frames.
+    expect(frames[0].eventType).toBe("chunk");
+    expect(frames[0].payload).toMatchObject({ type: "message_start" });
+    expect(
+      frames.find((f) => (f.payload as { type?: string }).type === "content_block_start"),
+    ).toBeDefined();
+    expect(
+      frames.find((f) => (f.payload as { type?: string }).type === "content_block_stop"),
+    ).toBeDefined();
+    expect(frames.find((f) => (f.payload as { type?: string }).type === "message_stop")).toBeDefined();
 
     // Content deltas should be zero (empty string → no chunks)
-    const deltas = frames.filter((f) => f.eventType === "contentBlockDelta");
+    const deltas = frames.filter(
+      (f) => (f.payload as { type?: string }).type === "content_block_delta",
+    );
     expect(deltas).toHaveLength(0);
   });
 });

src/__tests__/bedrock.test.ts

@@ -1448,31 +1448,29 @@ import { buildBedrockStreamTextEvents, buildBedrockStreamToolCallEvents } from "
 
 describe("buildBedrockStreamTextEvents", () => {
   it("creates correct event sequence for empty content", () => {
-    const events = buildBedrockStreamTextEvents("", 10);
-    // Should have: messageStart, contentBlockStart, contentBlockStop, messageStop (no deltas)
-    expect(events).toHaveLength(4);
-    expect(events[0].eventType).toBe("messageStart");
-    expect(events[1].eventType).toBe("contentBlockStart");
-    expect(events[2].eventType).toBe("contentBlockStop");
-    expect(events[3].eventType).toBe("messageStop");
+    const events = buildBedrockStreamTextEvents("", "model-id", 10);
+    // Should have: message_start, content_block_start, content_block_stop,
+    // message_delta, message_stop (no deltas), all wrapped in chunk events.
+    expect(events).toHaveLength(5);
+    expect(events.every((event) => event.eventType === "chunk")).toBe(true);
+    expect(events.map((event) => (event.payload as { type: string }).type)).toEqual([
+      "message_start",
+      "content_block_start",
+      "content_block_stop",
+      "message_delta",
+      "message_stop",
+    ]);
   });
 
   it("chunks content according to chunkSize", () => {
-    const events = buildBedrockStreamTextEvents("ABCDEF", 2);
-    const deltas = events.filter((e) => e.eventType === "contentBlockDelta");
+    const events = buildBedrockStreamTextEvents("ABCDEF", "model-id", 2);
+    const deltas = events.filter(
+      (e) => (e.payload as { type?: string }).type === "content_block_delta",
+    );
     expect(deltas).toHaveLength(3);
-    expect(
-      (deltas[0].payload as { contentBlockDelta: { delta: { text: string } } }).contentBlockDelta
-        .delta.text,
-    ).toBe("AB");
-    expect(
-      (deltas[1].payload as { contentBlockDelta: { delta: { text: string } } }).contentBlockDelta
-        .delta.text,
-    ).toBe("CD");
-    expect(
-      (deltas[2].payload as { contentBlockDelta: { delta: { text: string } } }).contentBlockDelta
-        .delta.text,
-    ).toBe("EF");
+    expect((deltas[0].payload as { delta: { text: string } }).delta.text).toBe("AB");
+    expect((deltas[1].payload as { delta: { text: string } }).delta.text).toBe("CD");
+    expect((deltas[2].payload as { delta: { text: string } }).delta.text).toBe("EF");
   });
 });
 
@@ -1482,55 +1480,63 @@ describe("buildBedrockStreamToolCallEvents", () => {
   it("falls back to '{}' for malformed JSON arguments", () => {
     const events = buildBedrockStreamToolCallEvents(
       [{ name: "fn", arguments: "NOT VALID" }],
+      "model-id",
       100,
       logger,
     );
-    const deltas = events.filter((e) => e.eventType === "contentBlockDelta");
+    const deltas = events.filter(
+      (e) => (e.payload as { type?: string }).type === "content_block_delta",
+    );
     const fullJson = deltas
-      .map(
-        (e) =>
-          (e.payload as { contentBlockDelta: { delta: { toolUse: { input: string } } } })
-            .contentBlockDelta.delta.toolUse.input,
-      )
+      .map((e) => (e.payload as { delta: { partial_json: string } }).delta.partial_json)
       .join("");
     expect(fullJson).toBe("{}");
   });
 
   it("generates tool use id when not provided", () => {
     const events = buildBedrockStreamToolCallEvents(
       [{ name: "fn", arguments: '{"x":1}' }],
+      "model-id",
       100,
       logger,
     );
-    const startEvent = events.find((e) => e.eventType === "contentBlockStart");
+    const startEvent = events.find(
+      (e) => (e.payload as { type?: string }).type === "content_block_start",
+    );
     const payload = startEvent!.payload as {
-      contentBlockStart: { start: { toolUse: { toolUseId: string } } };
+      content_block: { id: string };
     };
-    expect(payload.contentBlockStart.start.toolUse.toolUseId).toMatch(/^toolu_/);
+    expect(payload.content_block.id).toMatch(/^toolu_/);
   });
 
   it("uses provided tool id", () => {
     const events = buildBedrockStreamToolCallEvents(
       [{ name: "fn", arguments: '{"x":1}', id: "custom_id" }],
+      "model-id",
       100,
       logger,
     );
-    const startEvent = events.find((e) => e.eventType === "contentBlockStart");
+    const startEvent = events.find(
+      (e) => (e.payload as { type?: string }).type === "content_block_start",
+    );
     const payload = startEvent!.payload as {
-      contentBlockStart: { start: { toolUse: { toolUseId: string } } };
+      content_block: { id: string };
     };
-    expect(payload.contentBlockStart.start.toolUse.toolUseId).toBe("custom_id");
+    expect(payload.content_block.id).toBe("custom_id");
   });
 
   it("uses '{}' when arguments is empty string", () => {
-    const events = buildBedrockStreamToolCallEvents([{ name: "fn", arguments: "" }], 100, logger);
-    const deltas = events.filter((e) => e.eventType === "contentBlockDelta");
+    const events = buildBedrockStreamToolCallEvents(
+      [{ name: "fn", arguments: "" }],
+      "model-id",
+      100,
+      logger,
+    );
+    const deltas = events.filter(
+      (e) => (e.payload as { type?: string }).type === "content_block_delta",
+    );
     const fullJson = deltas
-      .map(
-        (e) =>
-          (e.payload as { contentBlockDelta: { delta: { toolUse: { input: string } } } })
-            .contentBlockDelta.delta.toolUse.input,
-      )
+      .map((e) => (e.payload as { delta: { partial_json: string } }).delta.partial_json)
       .join("");
     expect(fullJson).toBe("{}");
   });