@namzu/bedrock 1.0.2 → 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

@@ -7,6 +7,7 @@ import type {
 	Message as BedrockMessage,
 	ContentBlock,
 	ConversationRole,
+	ConverseStreamCommandOutput,
 	ConverseStreamOutput,
 	SystemContentBlock,
 	Tool,
@@ -23,6 +24,14 @@ import type {
 	TokenUsage,
 	ToolChoice,
 } from '@namzu/sdk'
+import type { ToolResultContent } from '@namzu/sdk'
+import { toolResultToText } from '@namzu/sdk'
+import {
+	ProviderRequestError,
+	isCallerAbortError,
+	isProviderRequestError,
+	providerVendorError,
+} from '@namzu/sdk'
 import type { BedrockConfig } from './types.js'
 
 function extractSystemBlocks(messages: ChatCompletionParams['messages']): SystemContentBlock[] {
@@ -35,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[] = []
@@ -51,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: {
@@ -124,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) =>
@@ -163,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 } }
@@ -181,7 +199,7 @@ interface RawBedrockUsage {
 	cacheWriteInputTokenCount?: number
 }
 
-function parseUsage(raw?: RawBedrockUsage): TokenUsage {
+export function parseBedrockUsage(raw?: RawBedrockUsage): TokenUsage {
 	if (!raw) {
 		return {
 			promptTokens: 0,
@@ -231,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 {
@@ -280,14 +300,29 @@ export class BedrockProvider implements LLMProvider {
 			inferenceConfig,
 		})
 
-		const response = await this.client.send(command, {
-			requestTimeout: this.config.timeout ?? 120_000,
-			// Per-request abort: a Stop tears the in-flight Converse stream down.
-			abortSignal: params.signal,
-		})
+		// AWS models failures as distinct exception CLASSES rather than status
+		// codes (ThrottlingException, ValidationException, AccessDeniedException),
+		// and lets them escape verbatim. Classify from the class name, then drop
+		// the AWS error — no re-throw, no `cause`.
+		let response: ConverseStreamCommandOutput
+		try {
+			response = await this.client.send(command, {
+				requestTimeout: this.config.timeout ?? 120_000,
+				// Per-request abort: a Stop tears the in-flight Converse stream down.
+				abortSignal: params.signal,
+			})
+		} catch (err) {
+			if (isCallerAbortError(err, params.signal)) throw params.signal?.reason ?? err
+			if (isProviderRequestError(err)) throw err
+			throw providerVendorError({ providerId: 'bedrock', error: err })
+		}
 
 		if (!response.stream) {
-			throw new Error('Bedrock returned no stream body')
+			throw new ProviderRequestError({
+				kind: 'server',
+				providerId: 'bedrock',
+				detail: 'the response contained no stream body',
+			})
 		}
 
 		const requestId = response.$metadata.requestId ?? `bedrock-${Date.now()}`
@@ -295,94 +330,116 @@ export class BedrockProvider implements LLMProvider {
 		const activeToolCalls = new Map<number, { id: string; name: string; args: string }>()
 		let toolCallIndex = 0
 
-		for await (const event of response.stream as AsyncIterable<ConverseStreamOutput>) {
-			// Stop pulling promptly on abort; `for await` calls the stream's
-			// `.return()` on this throw, releasing the connection.
-			params.signal?.throwIfAborted()
-			try {
-				if ('contentBlockDelta' in event && event.contentBlockDelta?.delta) {
-					const delta = event.contentBlockDelta.delta
-					if ('text' in delta && delta.text) {
-						yield {
-							id: requestId,
-							delta: { content: delta.text },
+		try {
+			for await (const event of response.stream as AsyncIterable<ConverseStreamOutput>) {
+				// Stop pulling promptly on abort; `for await` calls the stream's
+				// `.return()` on this throw, releasing the connection.
+				params.signal?.throwIfAborted()
+
+				// Bedrock reports several post-handshake failures as UNION
+				// EVENTS, not thrown exceptions. Ignoring these members makes a
+				// throttled or failed stream look like a clean EOF.
+				const streamFailure =
+					('internalServerException' in event ? event.internalServerException : undefined) ??
+					('modelStreamErrorException' in event ? event.modelStreamErrorException : undefined) ??
+					('validationException' in event ? event.validationException : undefined) ??
+					('throttlingException' in event ? event.throttlingException : undefined) ??
+					('serviceUnavailableException' in event ? event.serviceUnavailableException : undefined)
+				if (streamFailure) {
+					throw providerVendorError({
+						providerId: 'bedrock',
+						error: streamFailure,
+					})
+				}
+
+				try {
+					if ('contentBlockDelta' in event && event.contentBlockDelta?.delta) {
+						const delta = event.contentBlockDelta.delta
+						if ('text' in delta && delta.text) {
+							yield {
+								id: requestId,
+								delta: { content: delta.text },
+							}
+						}
+
+						if ('toolUse' in delta && delta.toolUse) {
+							const idx = event.contentBlockDelta.contentBlockIndex ?? toolCallIndex
+							const active = activeToolCalls.get(idx)
+							if (active) {
+								active.args += delta.toolUse.input ?? ''
+								yield {
+									id: requestId,
+									delta: {
+										toolCalls: [
+											{
+												index: idx,
+												function: { arguments: delta.toolUse.input ?? '' },
+											},
+										],
+									},
+								}
+							}
 						}
 					}
 
-					if ('toolUse' in delta && delta.toolUse) {
-						const idx = event.contentBlockDelta.contentBlockIndex ?? toolCallIndex
-						const active = activeToolCalls.get(idx)
-						if (active) {
-							active.args += delta.toolUse.input ?? ''
+					if ('contentBlockStart' in event && event.contentBlockStart?.start) {
+						const start = event.contentBlockStart.start
+						if ('toolUse' in start && start.toolUse) {
+							const idx = event.contentBlockStart.contentBlockIndex ?? toolCallIndex
+							activeToolCalls.set(idx, {
+								id: start.toolUse.toolUseId ?? `tool-${Date.now()}`,
+								name: start.toolUse.name ?? '',
+								args: '',
+							})
 							yield {
 								id: requestId,
 								delta: {
 									toolCalls: [
 										{
 											index: idx,
-											function: { arguments: delta.toolUse.input ?? '' },
+											id: start.toolUse.toolUseId,
+											type: 'function',
+											function: { name: start.toolUse.name ?? '' },
 										},
 									],
 								},
 							}
+							toolCallIndex = idx + 1
 						}
 					}
-				}
 
-				if ('contentBlockStart' in event && event.contentBlockStart?.start) {
-					const start = event.contentBlockStart.start
-					if ('toolUse' in start && start.toolUse) {
-						const idx = event.contentBlockStart.contentBlockIndex ?? toolCallIndex
-						activeToolCalls.set(idx, {
-							id: start.toolUse.toolUseId ?? `tool-${Date.now()}`,
-							name: start.toolUse.name ?? '',
-							args: '',
-						})
+					if ('contentBlockStop' in event) {
+					}
+
+					if ('messageStop' in event && event.messageStop) {
 						yield {
 							id: requestId,
-							delta: {
-								toolCalls: [
-									{
-										index: idx,
-										id: start.toolUse.toolUseId,
-										type: 'function',
-										function: { name: start.toolUse.name ?? '' },
-									},
-								],
-							},
+							delta: {},
+							finishReason: mapStopReason(event.messageStop.stopReason),
 						}
-						toolCallIndex = idx + 1
 					}
-				}
 
-				if ('contentBlockStop' in event) {
-				}
-
-				if ('messageStop' in event && event.messageStop) {
-					yield {
-						id: requestId,
-						delta: {},
-						finishReason: mapStopReason(event.messageStop.stopReason),
-					}
-				}
-
-				if ('metadata' in event && event.metadata?.usage) {
-					const usage = parseUsage(event.metadata.usage as RawBedrockUsage)
-					yield {
-						id: requestId,
-						delta: {},
-						usage,
+					if ('metadata' in event && event.metadata?.usage) {
+						const usage = parseBedrockUsage(event.metadata.usage as RawBedrockUsage)
+						yield {
+							id: requestId,
+							delta: {},
+							usage,
+						}
 					}
-				}
-			} catch (parseErr) {
-				yield {
-					id: requestId,
-					delta: { content: undefined },
-					finishReason: undefined,
-					usage: undefined,
-					error: `Stream parse error: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`,
+				} catch (parseErr) {
+					if (isProviderRequestError(parseErr)) throw parseErr
+					throw new ProviderRequestError({
+						kind: 'server',
+						providerId: 'bedrock',
+						detail: 'the provider stream returned malformed data',
+					})
 				}
 			}
+		} catch (err) {
+			if (isCallerAbortError(err, params.signal)) throw params.signal?.reason ?? err
+			if (isProviderRequestError(err)) throw err
+			throw providerVendorError({ providerId: 'bedrock', error: err })
 		}
 	}