@namzu/bedrock 4.0.0 → 4.0.1

package/src/__tests__/error-taxonomy.test.ts

@@ -1,248 +0,0 @@
-/**
- * Provider error taxonomy — Bedrock driver.
- *
- * `chatStream` awaits `this.client.send(command)` with no catch, so an AWS
- * `BedrockRuntimeServiceException` (`ThrottlingException`,
- * `ValidationException`, `ServiceUnavailableException`, …) escapes verbatim.
- * A caller cannot classify it without importing `@aws-sdk/client-bedrock-runtime`.
- *
- * Transport seam: `BedrockConfig` exposes no `requestHandler`/`endpoint`, so
- * unlike the fetch-based drivers there is nothing to inject at the HTTP
- * layer. The tests substitute the `BedrockRuntimeClient`'s `send` and reject
- * with the REAL AWS exception classes — which is exactly what the driver
- * sees from a live call, and the only surface the driver's (currently
- * absent) error mapping would act on.
- */
-
-import {
-	AccessDeniedException,
-	ModelErrorException,
-	ServiceQuotaExceededException,
-	ServiceUnavailableException,
-	ThrottlingException,
-	ValidationException,
-} from '@aws-sdk/client-bedrock-runtime'
-import type { ConverseStreamOutput } from '@aws-sdk/client-bedrock-runtime'
-import { describe, expect, it } from 'vitest'
-import { BedrockProvider } from '../client.js'
-
-/** Replace the AWS client's `send` so it rejects with `err`. */
-function providerRejectingWith(err: unknown): BedrockProvider {
-	const provider = new BedrockProvider({ region: 'eu-west-1' })
-	;(provider as unknown as { client: { send: () => Promise<never> } }).client = {
-		send: () => Promise.reject(err),
-	}
-	return provider
-}
-
-function providerStreaming(...events: ConverseStreamOutput[]): BedrockProvider {
-	const provider = new BedrockProvider({ region: 'eu-west-1' })
-	;(provider as unknown as { client: { send: () => Promise<unknown> } }).client = {
-		send: async () => ({
-			$metadata: { requestId: 'bedrock-test' },
-			stream: (async function* () {
-				yield* events
-			})(),
-		}),
-	}
-	return provider
-}
-
-async function captureChatStreamError(
-	provider: BedrockProvider,
-	signal?: AbortSignal,
-): Promise<unknown> {
-	try {
-		for await (const _chunk of provider.chatStream({
-			model: 'anthropic.claude-sonnet-4-5-20250929-v1:0',
-			messages: [{ role: 'user', content: 'hi' }],
-			signal,
-		})) {
-			// drain
-		}
-	} catch (err) {
-		return err
-	}
-	throw new Error('expected chatStream to throw')
-}
-
-describe('@namzu/bedrock — provider error taxonomy', () => {
-	it('(a) ThrottlingException with `retry-after: 2` becomes a throttle-classified error carrying retryAfterMs', async () => {
-		const aws = new ThrottlingException({
-			message: 'Too many requests, please wait before trying again.',
-			$metadata: { httpStatusCode: 429 },
-		})
-		;(aws as unknown as { $response: unknown }).$response = {
-			statusCode: 429,
-			headers: { 'retry-after': '2' },
-		}
-
-		const err = await captureChatStreamError(providerRejectingWith(aws))
-
-		expect(err).toMatchObject({
-			name: 'ProviderRequestError',
-			kind: 'throttle',
-			status: 429,
-			retryAfterMs: 2000,
-			providerId: 'bedrock',
-		})
-	})
-
-	it("(c) a ValidationException reporting too many input tokens classifies as 'context_overflow'", async () => {
-		const aws = new ValidationException({
-			message:
-				'Input is too long for requested model. The input token count exceeds the maximum for this model.',
-			$metadata: { httpStatusCode: 400 },
-		})
-
-		const err = await captureChatStreamError(providerRejectingWith(aws))
-
-		expect(err).toMatchObject({
-			name: 'ProviderRequestError',
-			kind: 'context_overflow',
-			status: 400,
-			providerId: 'bedrock',
-		})
-	})
-
-	it("(c) a ValidationException that is not an overflow classifies as 'bad_request'", async () => {
-		const aws = new ValidationException({
-			message: 'The value at toolConfig.tools failed to satisfy constraint.',
-			$metadata: { httpStatusCode: 400 },
-		})
-
-		const err = await captureChatStreamError(providerRejectingWith(aws))
-
-		expect(err).toMatchObject({
-			name: 'ProviderRequestError',
-			kind: 'bad_request',
-			status: 400,
-			providerId: 'bedrock',
-		})
-	})
-
-	it("an AccessDeniedException classifies as 'auth'", async () => {
-		const aws = new AccessDeniedException({
-			message: 'You do not have access to the model with the specified model ID.',
-			$metadata: { httpStatusCode: 403 },
-		})
-
-		const err = await captureChatStreamError(providerRejectingWith(aws))
-
-		expect(err).toMatchObject({
-			name: 'ProviderRequestError',
-			kind: 'auth',
-			status: 403,
-			providerId: 'bedrock',
-		})
-	})
-
-	it("a ServiceUnavailableException classifies as 'server'", async () => {
-		const aws = new ServiceUnavailableException({
-			message: 'The service is unavailable, try again later.',
-			$metadata: { httpStatusCode: 503 },
-		})
-
-		const err = await captureChatStreamError(providerRejectingWith(aws))
-
-		expect(err).toMatchObject({
-			name: 'ProviderRequestError',
-			kind: 'server',
-			status: 503,
-			providerId: 'bedrock',
-		})
-	})
-
-	it("a ModelErrorException with HTTP 424 still classifies as 'server'", async () => {
-		const aws = new ModelErrorException({
-			message: 'The model failed while processing the request.',
-			originalStatusCode: 500,
-			$metadata: { httpStatusCode: 424 },
-		})
-
-		const err = await captureChatStreamError(providerRejectingWith(aws))
-
-		expect(err).toMatchObject({
-			name: 'ProviderRequestError',
-			kind: 'server',
-			status: 424,
-			providerId: 'bedrock',
-		})
-	})
-
-	it("a ServiceQuotaExceededException classifies as 'throttle'", async () => {
-		const aws = new ServiceQuotaExceededException({
-			message: 'Account inference quota exceeded.',
-			$metadata: { httpStatusCode: 400 },
-		})
-
-		const err = await captureChatStreamError(providerRejectingWith(aws))
-
-		expect(err).toMatchObject({
-			name: 'ProviderRequestError',
-			kind: 'throttle',
-			status: 400,
-			providerId: 'bedrock',
-		})
-	})
-
-	it('classifies a throttling exception delivered as a stream union event', async () => {
-		const aws = new ThrottlingException({
-			message: 'stream quota exceeded',
-			$metadata: { httpStatusCode: 429 },
-		})
-
-		const err = await captureChatStreamError(providerStreaming({ throttlingException: aws }))
-
-		expect(err).toMatchObject({
-			name: 'ProviderRequestError',
-			kind: 'throttle',
-			status: 429,
-			providerId: 'bedrock',
-		})
-	})
-
-	it('keeps a validation stream event’s complaint, scrubbed, and still retains no cause', async () => {
-		// This test used to assert the opposite half: that the vendor's sentence
-		// was dropped whole. That was the safe-looking reading of "an error body
-		// can echo a credential", and it cost a day of production downtime —
-		// the wire had been naming the exact offending field the entire time and
-		// the SDK deleted the sentence before anyone could read it.
-		//
-		// So the guarantee changed shape rather than weakening: what is scrubbed
-		// is anything CREDENTIAL-SHAPED, and what survives is the complaint. The
-		// `cause` half is unchanged and still matters — a `cause` survives every
-		// logger that serializes an error chain, which is how the raw body would
-		// get out regardless of what the message says.
-		const key = 'AKIAIOSFODNN7EXAMPLE'
-		const aws = new ValidationException({
-			message: `inputSchema is invalid, echoed from key ${key}`,
-			$metadata: { httpStatusCode: 400 },
-		})
-
-		const err = await captureChatStreamError(providerStreaming({ validationException: aws }))
-
-		expect(err).toMatchObject({
-			name: 'ProviderRequestError',
-			kind: 'bad_request',
-			providerId: 'bedrock',
-		})
-		expect((err as Error).message).toContain('inputSchema is invalid')
-		expect((err as Error).message).not.toContain(key)
-		expect('cause' in (err as object)).toBe(false)
-	})
-
-	it('preserves the caller abort reason when the SDK replaces the error object', async () => {
-		const controller = new AbortController()
-		const reason = new Error('user stopped')
-		const sdkAbort = Object.assign(new Error('request aborted'), {
-			name: 'AbortError',
-		})
-		controller.abort(reason)
-
-		const err = await captureChatStreamError(providerRejectingWith(sdkAbort), controller.signal)
-
-		expect(sdkAbort).not.toBe(reason)
-		expect(err).toBe(reason)
-	})
-})

package/src/__tests__/model-reachability.test.ts

@@ -1,74 +0,0 @@
-import type { ChatCompletionParams } from '@namzu/sdk'
-import { describe, expect, it } from 'vitest'
-
-import { BedrockProvider } from '../client.js'
-import { assertModelReachable } from '../model-reachability.js'
-
-/**
- * This driver speaks Converse with ARN-versioned model ids. The current Claude
- * generation is served by a different Bedrock integration whose ids carry no
- * version suffix, and pointing this wire at one produced an opaque AWS
- * validation error naming neither the cause nor the remedy.
- */
-
-describe('model ids this wire can serve', () => {
-	const reachable = [
-		'anthropic.claude-sonnet-4-5-20250929-v1:0',
-		'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
-		'eu.anthropic.claude-opus-4-5-20251101-v1:0',
-		'global.anthropic.claude-opus-4-6-v1',
-		'apac.anthropic.claude-sonnet-4-20250514-v1:0',
-		'anthropic.claude-haiku-4-5-20251001-v1:0',
-	]
-
-	for (const model of reachable) {
-		it(`accepts ${model}`, () => {
-			expect(() => assertModelReachable(model)).not.toThrow()
-		})
-	}
-
-	const unreachable = [
-		'anthropic.claude-opus-5',
-		'anthropic.claude-sonnet-5',
-		'anthropic.claude-fable-5',
-		'anthropic.claude-opus-4-8',
-		'anthropic.claude-opus-4-7',
-		'us.anthropic.claude-opus-5',
-	]
-
-	for (const model of unreachable) {
-		it(`refuses ${model} and says why`, () => {
-			expect(() => assertModelReachable(model)).toThrow(/cannot reach/)
-			expect(() => assertModelReachable(model)).toThrow(/Converse API/)
-		})
-	}
-
-	it('leaves a non-Claude model alone', () => {
-		// This driver serves whatever Bedrock serves. The check is about one
-		// vendor's id scheme, not about policing the catalogue.
-		expect(() => assertModelReachable('amazon.nova-pro-v1:0')).not.toThrow()
-		expect(() => assertModelReachable('meta.llama3-70b-instruct-v1:0')).not.toThrow()
-	})
-
-	it('accepts an unknown versioned Claude id', () => {
-		// A model this file has never heard of passes as long as its id has
-		// the shape this wire carries. A list that must be edited for every
-		// new model is a list that is wrong before anyone reads it.
-		expect(() => assertModelReachable('anthropic.claude-sonnet-9-20991231-v1:0')).not.toThrow()
-	})
-})
-
-describe('the driver refuses before it calls AWS', () => {
-	it('throws on an unreachable model with no credentials in play', async () => {
-		const provider = new BedrockProvider({ region: 'us-east-1' } as never)
-
-		await expect(async () => {
-			for await (const _ of provider.chatStream({
-				model: 'anthropic.claude-opus-5',
-				messages: [{ role: 'user', content: 'hi' }],
-			} as ChatCompletionParams)) {
-				// drain
-			}
-		}).rejects.toThrow(/cannot reach "anthropic\.claude-opus-5"/)
-	})
-})

package/src/__tests__/prompt-cache.test.ts

@@ -1,81 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { parseBedrockUsage } from '../client.js'
-
-/**
- * Cache reads and cache writes are priced differently from ordinary input,
- * so folding either into the prompt count misreports what a run cost — and
- * misreports it silently, because the total still looks plausible.
- *
- * The counters are also the only evidence that the breakpoints are working
- * at all: a run whose cached count stays at zero is paying full price for
- * a prefix it believes is cached, and nothing else says so.
- */
-
-describe('cache counters are reported on their own axis', () => {
-	it('keeps reads out of the prompt count', () => {
-		const usage = parseBedrockUsage({
-			inputTokens: 10,
-			outputTokens: 2,
-			cacheReadInputTokenCount: 900,
-		})
-
-		expect(usage.promptTokens).toBe(10)
-		expect(usage.cachedTokens).toBe(900)
-	})
-
-	it('keeps writes on their own axis too', () => {
-		const usage = parseBedrockUsage({
-			inputTokens: 10,
-			outputTokens: 2,
-			cacheWriteInputTokenCount: 40,
-		})
-
-		expect(usage.cacheWriteTokens).toBe(40)
-		expect(usage.promptTokens).toBe(10)
-	})
-
-	it('reports both when both happen in one turn', () => {
-		const usage = parseBedrockUsage({
-			inputTokens: 10,
-			outputTokens: 2,
-			cacheReadInputTokenCount: 900,
-			cacheWriteInputTokenCount: 40,
-		})
-
-		expect(usage).toMatchObject({ cachedTokens: 900, cacheWriteTokens: 40 })
-	})
-
-	it('reads an absent counter as zero, not undefined', () => {
-		const usage = parseBedrockUsage({ inputTokens: 5, outputTokens: 1 })
-
-		// A consumer summing these must not have to guard every field; an
-		// undefined here becomes NaN one addition later.
-		expect(usage.cachedTokens).toBe(0)
-		expect(usage.cacheWriteTokens).toBe(0)
-	})
-
-	it('totals input and output, and nothing else', () => {
-		const usage = parseBedrockUsage({
-			inputTokens: 10,
-			outputTokens: 2,
-			cacheReadInputTokenCount: 900,
-		})
-
-		// Cached reads are already counted upstream; adding them here would
-		// double-count the same tokens in the run's own ledger.
-		expect(usage.totalTokens).toBe(12)
-	})
-
-	it('reads a missing usage payload as all zeros', () => {
-		const usage = parseBedrockUsage(undefined)
-
-		expect(usage).toEqual({
-			promptTokens: 0,
-			completionTokens: 0,
-			totalTokens: 0,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		})
-	})
-})

package/src/__tests__/thinking-refused.test.ts

@@ -1,44 +0,0 @@
-import type { ChatCompletionParams } from '@namzu/sdk'
-import { describe, expect, it } from 'vitest'
-
-import { BedrockProvider } from '../client.js'
-
-/**
- * The shared guard's own tests pass whether or not this driver calls it, so
- * this drives the real `chatStream`. The defect being fixed was exactly a
- * declared parameter that no code path consumed — asserting the helper works
- * would have reproduced that shape one level up.
- *
- * The guard runs before any client work, so no credentials and no network are
- * involved: the request never gets that far.
- */
-
-const provider = new BedrockProvider({ region: 'us-east-1' } as never)
-
-async function run(thinking?: ChatCompletionParams['thinking']): Promise<void> {
-	for await (const _chunk of provider.chatStream({
-		model: 'anthropic.claude-sonnet-4-5-20250929-v1:0',
-		messages: [{ role: 'user', content: 'hi' }],
-		...(thinking ? { thinking } : {}),
-	} as ChatCompletionParams)) {
-		// drain
-	}
-}
-
-describe('BedrockProvider refuses a thinking request rather than dropping it', () => {
-	it('throws on a manual thinking request', async () => {
-		await expect(run({ type: 'enabled', budgetTokens: 10_000 })).rejects.toThrow(
-			/BedrockProvider does not implement thinking/,
-		)
-	})
-
-	it('throws on an adaptive one', async () => {
-		await expect(run({ type: 'adaptive' })).rejects.toThrow(/does not implement thinking/)
-	})
-
-	it('does not throw for an explicit disable', async () => {
-		// Reaches the client and fails on credentials or network instead,
-		// which is the point: the guard let it past.
-		await expect(run({ type: 'disabled' })).rejects.not.toThrow(/does not implement thinking/)
-	})
-})

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

@@ -1,87 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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)
-	})
-})