@namzu/bedrock 1.0.3 → 3.0.0

package/src/__tests__/tool-choice-none.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest'
+
+import { toBedrockToolConfig } from '../client.js'
+
+/**
+ * `toolChoice: 'none'` means the model must not call a tool. This driver
+ * mapped it to the wire's "auto", which means the model MAY — the exact
+ * opposite of what the caller asked for, and silent.
+ *
+ * The runtime relies on it: an advisory consultation passes `'none'` so the
+ * advisor answers in prose. Under this driver the advisor could emit a tool
+ * call instead, into a turn with no executor waiting for one.
+ *
+ * The fix is not a better mapping. Every version of every wire format
+ * agrees a model cannot call a tool it was never given, so `'none'` sends
+ * no tools at all — a guarantee rather than a request.
+ */
+
+const TOOLS = [
+	{
+		type: 'function' as const,
+		function: { name: 'read', description: 'read a file', parameters: { type: 'object' } },
+	},
+]
+
+describe("a caller that said 'none' gets no tools on the wire", () => {
+	it('omits the tool config entirely', () => {
+		expect(
+			toBedrockToolConfig({ model: 'm', messages: [], tools: TOOLS, toolChoice: 'none' }),
+		).toBe(undefined)
+	})
+
+	it('omits it even when the history contains tool blocks', () => {
+		const config = toBedrockToolConfig({
+			model: 'm',
+			messages: [
+				{
+					role: 'assistant',
+					content: null,
+					toolCalls: [{ id: 'c1', type: 'function', function: { name: 'read', arguments: '{}' } }],
+				},
+				{ role: 'tool', content: 'ok', toolCallId: 'c1' },
+			] as Parameters<typeof toBedrockToolConfig>[0]['messages'],
+			toolChoice: 'none',
+		})
+
+		expect(config).toBe(undefined)
+	})
+})
+
+describe('the other choices still reach the wire unchanged', () => {
+	it('maps auto', () => {
+		const config = toBedrockToolConfig({
+			model: 'm',
+			messages: [],
+			tools: TOOLS,
+			toolChoice: 'auto',
+		})
+		expect(config?.toolChoice).toEqual({ auto: {} })
+		expect(config?.tools).toHaveLength(1)
+	})
+
+	it('maps required', () => {
+		const config = toBedrockToolConfig({
+			model: 'm',
+			messages: [],
+			tools: TOOLS,
+			toolChoice: 'required',
+		})
+		expect(config?.toolChoice).toEqual({ any: {} })
+	})
+
+	it('maps a named tool', () => {
+		const config = toBedrockToolConfig({
+			model: 'm',
+			messages: [],
+			tools: TOOLS,
+			toolChoice: { type: 'function', function: { name: 'read' } },
+		})
+		expect(config?.toolChoice).toEqual({ tool: { name: 'read' } })
+	})
+
+	it('defaults to auto when the caller said nothing', () => {
+		const config = toBedrockToolConfig({ model: 'm', messages: [], tools: TOOLS })
+		expect(config?.toolChoice).toEqual({ auto: {} })
+	})
+})

package/src/__tests__/tool-content-blocks.test.ts

@@ -0,0 +1,119 @@
+import type { ChatCompletionParams } from '@namzu/sdk'
+import { describe, expect, it } from 'vitest'
+
+import { toBedrockMessages } from '../client.js'
+
+/**
+ * A tool result carrying content blocks was `JSON.stringify`d into the
+ * text field, so a screenshot reached the model as a wall of quoted base64:
+ * unreadable, and paid for by the character.
+ *
+ * This driver does not map image content — `supportsVision` is false and
+ * says so — which makes the honest form the SDK's named placeholder. It
+ * reports what was there and how big it was, so the model knows something
+ * was withheld rather than believing it saw a JSON object.
+ */
+
+const PNG = 'iVBORw0KGgo='
+
+function toolResultFor(content: unknown): Record<string, unknown> {
+	const messages = toBedrockMessages([
+		{ role: 'user', content: 'take a shot' },
+		{
+			role: 'assistant',
+			content: null,
+			toolCalls: [
+				{ id: 'call_1', type: 'function', function: { name: 'screenshot', arguments: '{}' } },
+			],
+		},
+		{ role: 'tool', toolCallId: 'call_1', content },
+	] as unknown as ChatCompletionParams['messages'])
+
+	const block = messages
+		.flatMap((m) => m.content ?? [])
+		.find((b) => (b as { toolResult?: unknown }).toolResult)
+	return (block as unknown as { toolResult: Record<string, unknown> }).toolResult
+}
+
+function textOf(result: Record<string, unknown>): string {
+	const content = result.content as Array<{ text?: string }>
+	return content.map((c) => c.text ?? '').join('\n')
+}
+
+describe('a tool result the wire cannot carry is described, not dumped', () => {
+	it('names the media type and size instead of the payload', () => {
+		const text = textOf(toolResultFor([{ type: 'image', mediaType: 'image/png', data: PNG }]))
+
+		expect(text).toContain('image/png')
+		expect(text).toMatch(/\d+(\.\d+)? (B|KB|MB)/)
+	})
+
+	it('does not put the base64 payload in the text', () => {
+		const text = textOf(
+			toolResultFor([{ type: 'image', mediaType: 'image/png', data: 'A'.repeat(2048) }]),
+		)
+
+		// The bug in one assertion: the payload used to be JSON-quoted into
+		// the text field, so the model paid for 2048 unreadable characters.
+		expect(text).not.toContain('A'.repeat(64))
+	})
+
+	it('keeps the text blocks that sit alongside', () => {
+		const text = textOf(
+			toolResultFor([
+				{ type: 'text', text: 'captured the window' },
+				{ type: 'image', mediaType: 'image/png', data: PNG },
+			]),
+		)
+
+		expect(text).toContain('captured the window')
+		expect(text).toContain('image/png')
+	})
+
+	it('names a document by its filename', () => {
+		const text = textOf(
+			toolResultFor([
+				{ type: 'document', mediaType: 'application/pdf', data: 'JVBER', name: 'lease.pdf' },
+			]),
+		)
+
+		expect(text).toContain('lease.pdf')
+		expect(text).toContain('application/pdf')
+	})
+})
+
+describe('the plain cases are unchanged', () => {
+	it('passes a string result straight through', () => {
+		expect(textOf(toolResultFor('just text'))).toBe('just text')
+	})
+
+	it('passes text-only blocks through as their text', () => {
+		expect(textOf(toolResultFor([{ type: 'text', text: 'only words' }]))).toBe('only words')
+	})
+
+	it('answers the tool call it was given', () => {
+		expect(toolResultFor('x').toolUseId).toBe('call_1')
+	})
+
+	it('groups results answering one turn into a single message', () => {
+		const messages = toBedrockMessages([
+			{ role: 'user', content: 'read both' },
+			{
+				role: 'assistant',
+				content: null,
+				toolCalls: [
+					{ id: 'call_1', type: 'function', function: { name: 'read', arguments: '{}' } },
+					{ id: 'call_2', type: 'function', function: { name: 'read', arguments: '{}' } },
+				],
+			},
+			{ role: 'tool', toolCallId: 'call_1', content: 'one' },
+			{ role: 'tool', toolCallId: 'call_2', content: 'two' },
+		] as unknown as ChatCompletionParams['messages'])
+
+		const resultTurns = messages.filter((m) =>
+			(m.content ?? []).every((b) => (b as { toolResult?: unknown }).toolResult),
+		)
+		expect(resultTurns).toHaveLength(1)
+		expect(resultTurns[0]?.content).toHaveLength(2)
+	})
+})

package/src/__tests__/vision.test.ts

@@ -0,0 +1,98 @@
+import type { ChatCompletionParams } from '@namzu/sdk'
+import { describe, expect, it } from 'vitest'
+
+import { BEDROCK_CAPABILITIES, toBedrockMessages } from '../client.js'
+
+/**
+ * This driver does not map image attachments, and says so.
+ *
+ * That is a legitimate state — a driver may ship without a wire shape —
+ * but only while the claim and the code agree. The failure this pins is
+ * drift in either direction: flipping the flag without writing the mapping
+ * makes the runtime stop warning about images that still vanish, and
+ * writing the mapping without flipping the flag makes it keep warning
+ * about images that now arrive.
+ *
+ * The runtime reads the flag and warns (or fails under `strictCapabilities`)
+ * before the request is built, so the flag is the contract.
+ */
+
+const PNG = 'iVBORw0KGgo='
+
+function contentFor(attachments: unknown[]): unknown {
+	const messages = toBedrockMessages([
+		{ role: 'user', content: 'what is this', attachments },
+	] as unknown as ChatCompletionParams['messages'])
+	return messages[0]?.content
+}
+
+describe('the capability claim and the mapper agree', () => {
+	it('declares that images are not mapped', () => {
+		expect(BEDROCK_CAPABILITIES.supportsVision).toBe(false)
+	})
+
+	it('declares that documents are not mapped', () => {
+		expect(BEDROCK_CAPABILITIES.supportsDocuments).toBe(false)
+	})
+
+	it('sends no image block, matching the claim', () => {
+		const content = contentFor([{ type: 'image', data: PNG, mediaType: 'image/png' }])
+		const blocks = content as Record<string, unknown>[]
+
+		expect(blocks.some((b) => 'image' in b)).toBe(false)
+	})
+
+	it('does not smuggle the payload into the text either', () => {
+		const content = contentFor([{ type: 'image', data: 'A'.repeat(2048), mediaType: 'image/png' }])
+
+		// Dropping is the declared behaviour. Stringifying it into the
+		// prompt would be worse than dropping: unreadable, and billed.
+		expect(JSON.stringify(content)).not.toContain('A'.repeat(64))
+	})
+
+	it('still sends the message text', () => {
+		const content = contentFor([{ type: 'image', data: PNG, mediaType: 'image/png' }])
+		const blocks = content as Array<{ text?: string }>
+
+		expect(blocks.some((b) => b.text === 'what is this')).toBe(true)
+	})
+
+	it('leaves a plain message untouched', () => {
+		const messages = toBedrockMessages([
+			{ role: 'user', content: 'no attachments' },
+		] as ChatCompletionParams['messages'])
+
+		expect(messages[0]?.content).toEqual([{ text: 'no attachments' }])
+	})
+})
+
+describe('what the driver does map is unaffected', () => {
+	it('maps tool calls, which is what this driver is for', () => {
+		const messages = toBedrockMessages([
+			{ role: 'user', content: 'read it' },
+			{
+				role: 'assistant',
+				content: null,
+				toolCalls: [
+					{ id: 'call_1', type: 'function', function: { name: 'read', arguments: '{"p":1}' } },
+				],
+			},
+		] as unknown as ChatCompletionParams['messages'])
+
+		const toolUse = (messages[1]?.content ?? []).find(
+			(b) => (b as { toolUse?: unknown }).toolUse,
+		) as { toolUse: { name: string; input: unknown } }
+
+		expect(toolUse.toolUse.name).toBe('read')
+		expect(toolUse.toolUse.input).toEqual({ p: 1 })
+	})
+
+	it('drops system messages from the turn list', () => {
+		const messages = toBedrockMessages([
+			{ role: 'system', content: 'be terse' },
+			{ role: 'user', content: 'hi' },
+		] as ChatCompletionParams['messages'])
+
+		expect(messages.map((m) => m.role)).toEqual(['user'])
+	})
+})

package/src/client.ts

@@ -24,6 +24,8 @@ import type {
 	TokenUsage,
 	ToolChoice,
 } from '@namzu/sdk'
+import type { ToolResultContent } from '@namzu/sdk'
+import { assertThinkingUnsupported, toolResultToText } from '@namzu/sdk'
 import {
 	ProviderRequestError,
 	isCallerAbortError,
@@ -42,7 +44,7 @@ function toBedrockRole(role: string): ConversationRole {
 	return role === 'assistant' ? 'assistant' : 'user'
 }
 
-function toBedrockMessages(messages: ChatCompletionParams['messages']): BedrockMessage[] {
+export function toBedrockMessages(messages: ChatCompletionParams['messages']): BedrockMessage[] {
 	const out: BedrockMessage[] = []
 
 	let pendingToolResults: ContentBlock[] = []
@@ -58,10 +60,14 @@ function toBedrockMessages(messages: ChatCompletionParams['messages']): BedrockM
 		if (msg.role === 'system') continue
 
 		if (msg.role === 'tool') {
-			const toolMsg = msg as { toolCallId?: string; content?: string }
+			const toolMsg = msg as { toolCallId?: string; content?: ToolResultContent }
+			// `JSON.stringify` used to run here, so a tool result carrying an
+			// image sent the model a wall of quoted base64: unreadable, and
+			// paid for by the character. This driver does not map image
+			// content, so the honest form is the SDK's named placeholder —
+			// which says what was there and how big it was.
 			const resultBlock: ToolResultContentBlock = {
-				text:
-					typeof toolMsg.content === 'string' ? toolMsg.content : JSON.stringify(toolMsg.content),
+				text: toolResultToText(toolMsg.content ?? ''),
 			}
 			pendingToolResults.push({
 				toolResult: {
@@ -131,7 +137,12 @@ function extractToolNamesFromHistory(messages: ChatCompletionParams['messages'])
 	return Array.from(names)
 }
 
-function toBedrockToolConfig(params: ChatCompletionParams): ToolConfiguration | undefined {
+export function toBedrockToolConfig(params: ChatCompletionParams): ToolConfiguration | undefined {
+	// 'none' means the model must not call a tool. This used to map to the
+	// wire's 'auto', which means it MAY — the opposite, and silent. No wire
+	// format lets a model call a tool it was never given, so send none.
+	if (params.toolChoice === 'none') return undefined
+
 	if (params.tools && params.tools.length > 0) {
 		const tools: Tool[] = params.tools.map(
 			(t) =>
@@ -170,9 +181,9 @@ function toBedrockToolConfig(params: ChatCompletionParams): ToolConfiguration |
 	return undefined
 }
 
+/** 'none' never reaches here — it is answered by omitting the tools. */
 function formatToolChoice(tc?: ToolChoice) {
 	if (!tc || tc === 'auto') return { auto: {} }
-	if (tc === 'none') return { auto: {} }
 	if (tc === 'required') return { any: {} }
 	if (typeof tc === 'object' && tc.type === 'function') {
 		return { tool: { name: tc.function.name } }
@@ -188,7 +199,7 @@ interface RawBedrockUsage {
 	cacheWriteInputTokenCount?: number
 }
 
-function parseUsage(raw?: RawBedrockUsage): TokenUsage {
+export function parseBedrockUsage(raw?: RawBedrockUsage): TokenUsage {
 	if (!raw) {
 		return {
 			promptTokens: 0,
@@ -238,6 +249,8 @@ export const BEDROCK_CAPABILITIES: ProviderCapabilities = {
 	supportsStreaming: true,
 	supportsFunctionCalling: true,
 	supportsVision: false,
+	// Images only. A document degrades to a named placeholder.
+	supportsDocuments: false,
 }
 
 export class BedrockProvider implements LLMProvider {
@@ -269,6 +282,7 @@ export class BedrockProvider implements LLMProvider {
 	}
 
 	async *chatStream(params: ChatCompletionParams): AsyncIterable<StreamChunk> {
+		assertThinkingUnsupported('BedrockProvider', params)
 		const system = extractSystemBlocks(params.messages)
 		const messages = toBedrockMessages(params.messages)
 		const toolConfig = toBedrockToolConfig(params)
@@ -407,7 +421,7 @@ export class BedrockProvider implements LLMProvider {
 					}
 
 					if ('metadata' in event && event.metadata?.usage) {
-						const usage = parseUsage(event.metadata.usage as RawBedrockUsage)
+						const usage = parseBedrockUsage(event.metadata.usage as RawBedrockUsage)
 						yield {
 							id: requestId,
 							delta: {},