@namzu/bedrock 1.0.3 → 2.0.0

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 { 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 {
@@ -407,7 +420,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: {},