@namzu/sdk 14.0.7 → 15.1.0

package/src/provider/__tests__/thinking-support.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { assertThinkingUnsupported } from '../thinking-support.js'
-
-/**
- * `thinking` sits on `ChatCompletionParams`, so every driver accepts it. Six
- * of the seven in this repo did not implement it, and five of those six simply
- * dropped the field: the caller got an ordinary completion with an empty
- * `reasoning` array, indistinguishable from a model that chose not to reason.
- *
- * One driver already refused instead, with the reasoning written out. The rule
- * was decided once and applied once — so it moved here, where a new driver
- * inherits it rather than re-deciding it.
- */
-describe('a driver that cannot think says so', () => {
-	it('refuses a manual thinking request', () => {
-		expect(() =>
-			assertThinkingUnsupported('TestProvider', { thinking: { type: 'enabled' } }),
-		).toThrow(/TestProvider does not implement thinking/)
-	})
-
-	it('refuses an adaptive one too', () => {
-		// Both are a request to think. Refusing one and dropping the other
-		// would leave exactly the silence this exists to remove.
-		expect(() =>
-			assertThinkingUnsupported('TestProvider', { thinking: { type: 'adaptive' } }),
-		).toThrow(/does not implement thinking/)
-	})
-
-	it('names the driver, not just the problem', () => {
-		// In a multi-provider setup this is the difference between a bug
-		// report about the model and a one-line config fix.
-		expect(() =>
-			assertThinkingUnsupported('BedrockProvider', { thinking: { type: 'adaptive' } }),
-		).toThrow(/BedrockProvider/)
-	})
-
-	it('says what silence would have looked like', () => {
-		let message = ''
-		try {
-			assertThinkingUnsupported('TestProvider', { thinking: { type: 'enabled' } })
-		} catch (err) {
-			message = (err as Error).message
-		}
-		expect(message).toContain('empty reasoning list')
-		expect(message).toContain('Drop `thinking`')
-	})
-
-	it('honours an explicit disable as a no-op', () => {
-		// A config shared across providers that says "do not think" should not
-		// fail on the ones that were never going to.
-		expect(() =>
-			assertThinkingUnsupported('TestProvider', { thinking: { type: 'disabled' } }),
-		).not.toThrow()
-	})
-
-	it('does nothing when the caller said nothing', () => {
-		expect(() => assertThinkingUnsupported('TestProvider', {})).not.toThrow()
-	})
-})

package/src/provider/__tests__/typed-error-classification.test.ts

@@ -1,143 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { classifyProviderError } from '../../types/provider/errors.js'
-import type { LLMProvider, StreamChunk } from '../../types/provider/index.js'
-import { ProviderRequestError } from '../errors.js'
-import { withProviderRetry } from '../retry.js'
-
-/**
- * A driver that classified its own failure was coming out WORSE than one that
- * did not, in two independent places, and both shipped.
- *
- * `classifyProviderError` never read `kind`. A `ProviderRequestError` fell
- * through to the status heuristics, where a carefully-diagnosed
- * `context_overflow` carrying a 400 became `invalid_request` — so the run
- * loop's overflow branch, which tests for `context_length_exceeded`, could
- * never fire for a first-party driver, and compaction relief was unreachable
- * for exactly the drivers that had diagnosed the problem correctly.
- *
- * And `withProviderRetry` rethrew any such error before the retry loop. Its
- * comment justified preserving the classification, which is right; the code
- * also skipped retrying, which is a different decision that nobody made.
- */
-
-function providerThatFails(err: unknown): { provider: LLMProvider; calls: () => number } {
-	let calls = 0
-	const provider = {
-		id: 'test',
-		name: 'Test',
-		async *chatStream(): AsyncIterable<StreamChunk> {
-			calls++
-			throw err
-			// biome-ignore lint/correctness/useYield: it fails before producing anything
-		},
-	} as unknown as LLMProvider
-	return { provider, calls: () => calls }
-}
-
-const typed = (kind: string, status: number) =>
-	new ProviderRequestError({ kind, providerId: 'test', status, message: `a ${kind}` } as never)
-
-describe('a driver that classified its own failure is believed', () => {
-	const cases: readonly [string, number, string, boolean][] = [
-		['throttle', 429, 'rate_limit', true],
-		['server', 500, 'server_error', true],
-		['network', 0, 'network', true],
-		['auth', 401, 'auth', false],
-		['bad_request', 400, 'invalid_request', false],
-		// The one that mattered most: a 400 whose kind says the prompt was too
-		// long is not a bad request, and the difference decides whether the
-		// kernel reaches for compaction.
-		['context_overflow', 400, 'context_length_exceeded', false],
-	]
-
-	for (const [kind, status, code, retryable] of cases) {
-		it(`maps kind "${kind}" to ${code}`, () => {
-			const classified = classifyProviderError(typed(kind, status), 'test')
-			expect(classified.code).toBe(code)
-			expect(classified.retryable).toBe(retryable)
-		})
-	}
-
-	it('keeps the driver-supplied status and provider id', () => {
-		const classified = classifyProviderError(typed('throttle', 429), 'other')
-		expect(classified.status).toBe(429)
-		expect(classified.providerId).toBe('test')
-	})
-})
-
-describe('a classified failure still goes through the retry loop', () => {
-	it('retries a typed throttle', async () => {
-		// This is the regression: a first-party driver reporting a 429 as
-		// `kind: 'throttle'` used to get exactly one attempt, while the same
-		// failure from a driver that classified nothing got the full backoff.
-		const { provider, calls } = providerThatFails(typed('throttle', 429))
-		const wrapped = withProviderRetry(provider, {
-			config: { maxRetries: 2 },
-			sleepFn: async () => {},
-			random: () => 0,
-		})
-
-		await expect(async () => {
-			for await (const _ of wrapped.chatStream({} as never)) {
-				// drain
-			}
-		}).rejects.toThrow()
-
-		expect(calls()).toBe(3)
-	})
-
-	it('does not retry a typed auth failure', async () => {
-		const { provider, calls } = providerThatFails(typed('auth', 401))
-		const wrapped = withProviderRetry(provider, {
-			config: { maxRetries: 2 },
-			sleepFn: async () => {},
-		})
-
-		await expect(async () => {
-			for await (const _ of wrapped.chatStream({} as never)) {
-				// drain
-			}
-		}).rejects.toThrow()
-
-		expect(calls()).toBe(1)
-	})
-
-	it('does not retry a typed context overflow', async () => {
-		// Correctly non-retryable — an identical prompt overflows identically.
-		// The remedy is compaction, which the run loop reaches for once the
-		// code is `context_length_exceeded`.
-		const { provider, calls } = providerThatFails(typed('context_overflow', 400))
-		const wrapped = withProviderRetry(provider, {
-			config: { maxRetries: 2 },
-			sleepFn: async () => {},
-		})
-
-		await expect(async () => {
-			for await (const _ of wrapped.chatStream({} as never)) {
-				// drain
-			}
-			// The ORIGINAL escapes, so the boundary still sees the driver's
-			// own kind rather than a wrapper's code.
-		}).rejects.toMatchObject({ kind: 'context_overflow', status: 400 })
-
-		expect(calls()).toBe(1)
-	})
-
-	it('leaves an abort alone', async () => {
-		const abort = Object.assign(new Error('aborted'), { name: 'AbortError' })
-		const { provider, calls } = providerThatFails(abort)
-		const wrapped = withProviderRetry(provider, {
-			config: { maxRetries: 2 },
-			sleepFn: async () => {},
-		})
-
-		await expect(async () => {
-			for await (const _ of wrapped.chatStream({} as never)) {
-				// drain
-			}
-		}).rejects.toThrow(/aborted/)
-
-		expect(calls()).toBe(1)
-	})
-})

package/src/provider/__tests__/vendor-detail.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { providerHttpError, redactSecrets, vendorDetail } from '../errors.js'
-
-/**
- * The provider's own account of what was wrong, kept — and scrubbed.
- *
- * `ProviderRequestErrorInit` declared `detail` from the beginning and the
- * constructor never read it, so the field existed and carried nothing. The
- * body was read to classify and then dropped, deliberately, because an error
- * body can echo a request and a request can carry a key.
- *
- * The cost of that trade showed up in production: the wire had been saying
- * `tools.0.custom.input_schema: … must match JSON Schema draft 2020-12` and
- * the SDK deleted the sentence, so diagnosing it took seven eliminated
- * hypotheses and a day of downtime. Keeping the sentence and scrubbing the
- * credential shapes is the trade that was actually available.
- */
-
-describe('the sentence that names the broken field survives', () => {
-	it('lifts the structured message out of a vendor body', () => {
-		const body = JSON.stringify({
-			type: 'error',
-			error: {
-				type: 'invalid_request_error',
-				message:
-					'tools.0.custom.input_schema: JSON schema is invalid. It must match JSON Schema draft 2020-12',
-			},
-		})
-
-		expect(vendorDetail(body)).toBe(
-			'tools.0.custom.input_schema: JSON schema is invalid. It must match JSON Schema draft 2020-12',
-		)
-	})
-
-	it('reaches the error a caller actually catches', () => {
-		const err = providerHttpError({
-			providerId: 'anthropic',
-			status: 400,
-			body: JSON.stringify({ error: { message: "Schema type 'oneOf' is not supported" } }),
-		})
-
-		expect(err.detail).toContain('oneOf')
-		// …and the message too, so a log line that prints only the message is
-		// still enough to act on.
-		expect(err.message).toContain('oneOf')
-	})
-
-	it('falls back to the raw text when the body is not JSON', () => {
-		expect(vendorDetail('upstream connect error, transport failure')).toBe(
-			'upstream connect error, transport failure',
-		)
-	})
-
-	it('says nothing rather than something empty', () => {
-		expect(vendorDetail(undefined)).toBeUndefined()
-		expect(vendorDetail(null)).toBeUndefined()
-		expect(vendorDetail('   ')).toBeUndefined()
-		expect(vendorDetail({})).toBeUndefined()
-	})
-
-	it('truncates a body that is not a sentence', () => {
-		const detail = vendorDetail('x'.repeat(5_000))
-		expect(detail?.length).toBeLessThanOrEqual(401)
-		expect(detail?.endsWith('…')).toBe(true)
-	})
-})
-
-describe('a credential never rides along', () => {
-	it.each([
-		['sk-ant-api03-AbCdEfGhIjKlMnOpQrStUv', 'anthropic-style key'],
-		['npm_aBcDeFgHiJkLmNoPqRsTuVwXyZ012345', 'npm token'],
-		['ghp_aBcDeFgHiJkLmNoPqRsTuVwXyZ012345', 'github token'],
-		['AKIAIOSFODNN7EXAMPLE', 'aws access key id'],
-	])('scrubs %s (%s)', (secret) => {
-		const scrubbed = redactSecrets(`upstream rejected token ${secret} for this request`)
-		expect(scrubbed).not.toContain(secret)
-		expect(scrubbed).toContain('[redacted]')
-	})
-
-	it('scrubs a bearer header the vendor echoed back', () => {
-		const scrubbed = redactSecrets('bad header: Authorization: Bearer abcdef0123456789ABCDEF')
-		expect(scrubbed).not.toContain('abcdef0123456789ABCDEF')
-	})
-
-	it('scrubs a credential-named JSON field without eating the rest', () => {
-		const scrubbed = redactSecrets('{"api_key":"sk-live-9999","model":"the-model-that-failed"}')
-		expect(scrubbed).not.toContain('sk-live-9999')
-		// The surrounding sentence is the whole point — scrubbing must not
-		// degrade into deleting the message.
-		expect(scrubbed).toContain('the-model-that-failed')
-	})
-
-	it('scrubs on the real path, not only in the helper', () => {
-		const err = providerHttpError({
-			providerId: 'anthropic',
-			status: 401,
-			body: JSON.stringify({
-				error: { message: 'invalid key sk-ant-api03-AbCdEfGhIjKlMnOpQrStUv supplied' },
-			}),
-		})
-
-		expect(err.detail).not.toContain('AbCdEfGhIjKlMnOpQrStUv')
-		expect(err.detail).toContain('[redacted]')
-		expect(err.message).not.toContain('AbCdEfGhIjKlMnOpQrStUv')
-	})
-})

package/src/provider/collect.test.ts

@@ -1,142 +0,0 @@
-/**
- * Behavioural contract for `collect()` (ses_001-tool-stream-events phase 1A):
- *
- * - Drains a `StreamChunk` async iterable into a single
- *   `ChatCompletionResponse` matching the legacy `provider.chat()` shape.
- * - Concatenates `delta.content` in arrival order; null when no text
- *   chunks ever arrive.
- * - Buckets tool-call argument fragments by `index`; emits `toolCalls`
- *   sorted by index. `id` and `function.name` come from the first chunk
- *   that supplies them; `function.arguments` is the concatenation of all
- *   `arguments` fragments for that index.
- * - Latest-wins for `finishReason` and `usage`; defaults
- *   `finishReason: 'stop'` and zero usage if the provider omits them
- *   (defensive — a vendor SDK has shipped this shape before).
- * - Throws if any chunk surfaces a `chunk.error`.
- *
- * Phase 2 swaps every internal `provider.chat()` call site for
- * `collect(provider.chatStream())`; the response shape parity guarded
- * here is what makes that swap safe.
- */
-
-import { describe, expect, it } from 'vitest'
-
-import type { StreamChunk } from '../types/provider/stream.js'
-
-import { collect } from './collect.js'
-
-async function* fromArray(chunks: StreamChunk[]): AsyncIterable<StreamChunk> {
-	for (const chunk of chunks) yield chunk
-}
-
-describe('collect()', () => {
-	it('aggregates text-only stream into single content string', async () => {
-		const result = await collect(
-			fromArray([
-				{ id: 'm1', delta: { content: 'hel' } },
-				{ id: 'm1', delta: { content: 'lo' } },
-				{ id: 'm1', delta: { content: ' world' } },
-				{ id: 'm1', delta: {}, finishReason: 'stop' },
-			]),
-		)
-		expect(result.message.content).toBe('hello world')
-		expect(result.message.toolCalls).toBeUndefined()
-		expect(result.finishReason).toBe('stop')
-		expect(result.id).toBe('m1')
-	})
-
-	it('returns content: null when no text chunks arrive', async () => {
-		const result = await collect(fromArray([{ id: 'm', delta: {}, finishReason: 'stop' }]))
-		expect(result.message.content).toBeNull()
-	})
-
-	it('buckets parallel tool calls by index, preserves order', async () => {
-		const result = await collect(
-			fromArray([
-				{
-					id: 'm',
-					delta: {
-						toolCalls: [
-							{ index: 0, id: 'toolu_a', function: { name: 'read' } },
-							{ index: 1, id: 'toolu_b', function: { name: 'WebSearch' } },
-						],
-					},
-				},
-				{
-					id: 'm',
-					delta: {
-						toolCalls: [{ index: 1, function: { arguments: '{"query":"x"}' } }],
-					},
-				},
-				{
-					id: 'm',
-					delta: {
-						toolCalls: [
-							{ index: 0, function: { arguments: '{"file_path":' } },
-							{ index: 0, function: { arguments: '"/a"}' } },
-						],
-					},
-				},
-				{ id: 'm', delta: {}, finishReason: 'tool_calls' },
-			]),
-		)
-		expect(result.message.toolCalls).toEqual([
-			{
-				id: 'toolu_a',
-				type: 'function',
-				function: { name: 'read', arguments: '{"file_path":"/a"}' },
-			},
-			{
-				id: 'toolu_b',
-				type: 'function',
-				function: { name: 'WebSearch', arguments: '{"query":"x"}' },
-			},
-		])
-		expect(result.finishReason).toBe('tool_calls')
-	})
-
-	it('latest finishReason and usage win', async () => {
-		const result = await collect(
-			fromArray([
-				{ id: 'm', delta: {}, finishReason: 'stop' },
-				{
-					id: 'm',
-					delta: {},
-					finishReason: 'length',
-					usage: {
-						promptTokens: 100,
-						completionTokens: 50,
-						totalTokens: 150,
-						cachedTokens: 0,
-						cacheWriteTokens: 0,
-					},
-				},
-			]),
-		)
-		expect(result.finishReason).toBe('length')
-		expect(result.usage.totalTokens).toBe(150)
-	})
-
-	it('defaults finishReason to stop and usage to zero when provider omits them', async () => {
-		const result = await collect(fromArray([{ id: 'm', delta: { content: 'hi' } }]))
-		expect(result.finishReason).toBe('stop')
-		expect(result.usage).toEqual({
-			promptTokens: 0,
-			completionTokens: 0,
-			totalTokens: 0,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		})
-	})
-
-	it('throws on chunk.error', async () => {
-		await expect(
-			collect(
-				fromArray([
-					{ id: 'm', delta: { content: 'hi' } },
-					{ id: 'm', delta: {}, error: 'rate limited' },
-				]),
-			),
-		).rejects.toThrow('rate limited')
-	})
-})

package/src/provider/instrumentation.test.ts

@@ -1,173 +0,0 @@
-/**
- * Phase 2 of ses_001-tool-stream-events removed `chat()` from
- * `LLMProvider`; this suite now exercises the streaming-only wrapper.
- *
- * Invariants under test:
- *   - `wrapProviderWithProbes(provider)` returns an object that
- *     forwards `chatStream` to the inner provider while emitting
- *     `provider_call_start` before iteration and either
- *     `provider_call_completed` (after the iterator drains cleanly,
- *     carrying any aggregated `usage` from the last chunk that
- *     supplied one) or `provider_call_failed` (on a thrown error).
- *   - `callId` is unique per call and correlates start/completed/failed.
- *   - Optional methods (`listModels`, `healthCheck`, `doctorCheck`)
- *     are forwarded when present on the inner provider.
- */
-
-import { describe, expect, it, vi } from 'vitest'
-
-import { buildProbeContext } from '../probe/context.js'
-import { createProbeRegistry } from '../probe/registry.js'
-import type { AgentBusEvent } from '../types/bus/index.js'
-import type { TokenUsage } from '../types/common/index.js'
-import type { ChatCompletionParams } from '../types/provider/chat.js'
-import type { LLMProvider } from '../types/provider/interface.js'
-import type { StreamChunk } from '../types/provider/stream.js'
-
-import { wrapProviderWithProbes } from './instrumentation.js'
-
-const STREAM_USAGE: TokenUsage = {
-	promptTokens: 10,
-	completionTokens: 5,
-	totalTokens: 15,
-	cachedTokens: 0,
-	cacheWriteTokens: 0,
-}
-
-function makeFakeProvider(
-	overrides: Partial<{
-		chatStream: LLMProvider['chatStream']
-	}> = {},
-): LLMProvider {
-	const defaultStream: LLMProvider['chatStream'] = async function* (
-		_params: ChatCompletionParams,
-	): AsyncIterable<StreamChunk> {
-		yield { id: 'm', delta: { content: 'hi' } }
-		yield {
-			id: 'm',
-			delta: {},
-			finishReason: 'stop',
-			usage: STREAM_USAGE,
-		}
-	}
-	return {
-		id: 'p1',
-		name: 'Provider 1',
-		chatStream: overrides.chatStream ?? defaultStream,
-	}
-}
-
-const params: ChatCompletionParams = { model: 'm1', messages: [] } as ChatCompletionParams
-
-async function drain(iter: AsyncIterable<StreamChunk>): Promise<StreamChunk[]> {
-	const out: StreamChunk[] = []
-	for await (const c of iter) out.push(c)
-	return out
-}
-
-describe('wrapProviderWithProbes — chatStream', () => {
-	it('emits provider_call_start before iteration and provider_call_completed after drain', async () => {
-		const reg = createProbeRegistry()
-		const seen: AgentBusEvent[] = []
-		reg.onAny((event) => seen.push(event as AgentBusEvent))
-
-		const wrapped = wrapProviderWithProbes(makeFakeProvider(), { probes: reg })
-		await drain(wrapped.chatStream(params))
-
-		expect(seen.map((e) => e.type)).toEqual(['provider_call_start', 'provider_call_completed'])
-		const start = seen[0] as AgentBusEvent & { type: 'provider_call_start' }
-		const completed = seen[1] as AgentBusEvent & { type: 'provider_call_completed' }
-		expect(start.providerId).toBe('p1')
-		expect(start.model).toBe('m1')
-		expect(completed.callId).toBe(start.callId)
-		expect(completed.durationMs).toBeGreaterThanOrEqual(0)
-	})
-
-	it('captures usage from the last chunk that carries it', async () => {
-		const reg = createProbeRegistry()
-		const seen: AgentBusEvent[] = []
-		reg.onAny((event) => seen.push(event as AgentBusEvent))
-
-		const wrapped = wrapProviderWithProbes(makeFakeProvider(), { probes: reg })
-		await drain(wrapped.chatStream(params))
-
-		const completed = seen[1] as AgentBusEvent & { type: 'provider_call_completed' }
-		expect(completed.usage).toMatchObject({
-			inputTokens: STREAM_USAGE.promptTokens,
-			outputTokens: STREAM_USAGE.completionTokens,
-			totalTokens: STREAM_USAGE.totalTokens,
-		})
-	})
-
-	it('emits provider_call_failed and re-throws when chatStream throws mid-iteration', async () => {
-		const reg = createProbeRegistry()
-		const seen: AgentBusEvent[] = []
-		reg.onAny((event) => seen.push(event as AgentBusEvent))
-
-		const failing = makeFakeProvider({
-			chatStream: async function* () {
-				yield { id: 'm', delta: { content: 'partial' } }
-				throw new Error('boom')
-			},
-		})
-		const wrapped = wrapProviderWithProbes(failing, { probes: reg })
-
-		await expect(drain(wrapped.chatStream(params))).rejects.toThrow('boom')
-		expect(seen.map((e) => e.type)).toEqual(['provider_call_start', 'provider_call_failed'])
-		const failed = seen[1] as AgentBusEvent & { type: 'provider_call_failed' }
-		expect(failed.error).toBe('boom')
-	})
-
-	it('correlates start and completed by callId across multiple calls', async () => {
-		const reg = createProbeRegistry()
-		const ids: string[] = []
-		reg.on('provider_call_start', (event) => ids.push(`s:${event.callId}`))
-		reg.on('provider_call_completed', (event) => ids.push(`c:${event.callId}`))
-
-		const wrapped = wrapProviderWithProbes(makeFakeProvider(), { probes: reg })
-		await drain(wrapped.chatStream(params))
-		await drain(wrapped.chatStream(params))
-
-		expect(ids).toHaveLength(4)
-		expect(ids[0]?.split(':')[1]).toBe(ids[1]?.split(':')[1])
-		expect(ids[2]?.split(':')[1]).toBe(ids[3]?.split(':')[1])
-		expect(ids[0]).not.toBe(ids[2])
-	})
-
-	it('forwards optional methods (listModels, healthCheck) to the inner provider', () => {
-		const listModels = vi.fn()
-		const healthCheck = vi.fn()
-		const inner = { ...makeFakeProvider(), listModels, healthCheck }
-		const wrapped = wrapProviderWithProbes(inner)
-
-		wrapped.listModels?.()
-		wrapped.healthCheck?.()
-
-		expect(listModels).toHaveBeenCalled()
-		expect(healthCheck).toHaveBeenCalled()
-	})
-
-	it('omits optional methods when inner provider does not declare them', () => {
-		const wrapped = wrapProviderWithProbes(makeFakeProvider())
-		expect(wrapped.listModels).toBeUndefined()
-		expect(wrapped.healthCheck).toBeUndefined()
-	})
-
-	it('uses the configured probe context (runId)', async () => {
-		const reg = createProbeRegistry()
-		const ctx = buildProbeContext({ runId: 'run_42' as `run_${string}` })
-		const seen: AgentBusEvent[] = []
-		reg.onAny((event, c) => {
-			seen.push(event as AgentBusEvent)
-			expect(c.runId).toBe(ctx.runId)
-		})
-
-		const wrapped = wrapProviderWithProbes(makeFakeProvider(), {
-			probes: reg,
-			runId: ctx.runId,
-		})
-		await drain(wrapped.chatStream(params))
-
-		expect(seen.map((e) => e.type)).toEqual(['provider_call_start', 'provider_call_completed'])
-	})
-})