@namzu/sdk 14.0.6 → 15.0.0

package/src/store/task/__tests__/lookup-across-runs.test.ts

@@ -1,77 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import type { RunId } from '../../../types/ids/index.js'
-import { DiskTaskStore } from '../disk.js'
-
-/**
- * A task is WRITTEN under the run that created it and was READ under the
- * store's default run, so every lookup missed as soon as the two differed
- * — which is the normal case, not an edge one: the tools are built with
- * the live run id (`buildTaskTools(store, ctx.runId)`) while a long-lived
- * host constructs the store once with a fixed default.
- *
- * The symptom is that `create` succeeds, `list` succeeds — it takes the
- * run id as a filter and falls back to the same default — and then
- * `update`, `delete`, `claim` and every dependency link answer "not
- * found" for a task the caller can see.
- *
- * The in-memory store keys by task id alone, so nothing caught it.
- */
-
-const DEFAULT = 'run_default' as RunId
-const OTHER = 'run_actual' as RunId
-
-describe('a task created under a different run than the store default', () => {
-	let dir: string
-	let store: DiskTaskStore
-
-	beforeEach(async () => {
-		dir = await mkdtemp(join(tmpdir(), 'namzu-tasks-'))
-		store = new DiskTaskStore({ baseDir: dir, defaultRunId: DEFAULT })
-	})
-
-	afterEach(async () => {
-		await rm(dir, { recursive: true, force: true })
-	})
-
-	it('can be fetched by id', async () => {
-		const task = await store.create({ subject: 'ship it', runId: OTHER })
-
-		expect(await store.get(task.id)).toMatchObject({ id: task.id, runId: OTHER })
-	})
-
-	it('can be updated', async () => {
-		const task = await store.create({ subject: 'ship it', runId: OTHER })
-
-		const updated = await store.update(task.id, { status: 'in_progress' })
-		expect(updated).toMatchObject({ id: task.id, status: 'in_progress' })
-	})
-
-	it('can be claimed', async () => {
-		const task = await store.create({ subject: 'ship it', runId: OTHER })
-
-		expect(await store.claim(task.id, 'worker-1')).toMatchObject({ owner: 'worker-1' })
-	})
-
-	it('can be deleted', async () => {
-		const task = await store.create({ subject: 'ship it', runId: OTHER })
-
-		expect(await store.delete(task.id)).toBe(true)
-		expect(await store.get(task.id)).toBeUndefined()
-	})
-
-	it('is still not found when it genuinely does not exist', async () => {
-		// The lookup widened to every run; it must not start inventing
-		// tasks, or "not found" stops meaning anything.
-		expect(await store.get('task_nope' as never)).toBeUndefined()
-	})
-
-	it('is found under the default run too', async () => {
-		const task = await store.create({ subject: 'ship it', runId: DEFAULT })
-
-		expect(await store.get(task.id)).toMatchObject({ id: task.id, runId: DEFAULT })
-	})
-})

package/src/streaming/coalesce.test.ts

@@ -1,132 +0,0 @@
-/**
- * Behavioural contract for `coalesce()` (ses_001-tool-stream-events phase 1A):
- *
- * - `text_delta` events for the same `messageId` within the configured
- *   `windowMs` are merged into a single event whose `text` is the
- *   concatenation in arrival order.
- * - `tool_input_delta` events for the same `toolUseId` within the window
- *   are merged the same way on `partialJson`.
- * - Any other event flushes pending buffers first, preserving overall
- *   stream ordering.
- * - End-of-stream flushes any remaining buffers.
- * - Different `messageId`s and `toolUseId`s never merge with each other.
- *
- * The coalescer is opt-in for slow downstream consumers (SSE adapters);
- * the orchestrator emits raw deltas. A 16ms default roughly aligns with
- * one 60fps animation frame.
- */
-
-import { describe, expect, it } from 'vitest'
-
-import type { MessageId, RunId, ToolUseId } from '../types/ids/index.js'
-import type { RunEvent } from '../types/run/events.js'
-
-import { coalesce } from './coalesce.js'
-
-const RID = 'run_1' as RunId
-const MID = 'msg_1' as MessageId
-const MID2 = 'msg_2' as MessageId
-const TUID: ToolUseId = 'toolu_a'
-const TUID2: ToolUseId = 'toolu_b'
-
-async function* fromArray(events: RunEvent[]): AsyncIterable<RunEvent> {
-	for (const e of events) yield e
-}
-
-async function drain(stream: AsyncIterable<RunEvent>): Promise<RunEvent[]> {
-	const out: RunEvent[] = []
-	for await (const e of stream) out.push(e)
-	return out
-}
-
-describe('coalesce()', () => {
-	it('merges consecutive text_delta events with same messageId within window', async () => {
-		const events: RunEvent[] = [
-			{ type: 'text_delta', runId: RID, iteration: 0, messageId: MID, text: 'hel' },
-			{ type: 'text_delta', runId: RID, iteration: 0, messageId: MID, text: 'lo' },
-			{ type: 'text_delta', runId: RID, iteration: 0, messageId: MID, text: ' world' },
-		]
-		const result = await drain(coalesce(fromArray(events), { windowMs: 1000 }))
-		expect(result).toHaveLength(1)
-		expect(result[0]).toMatchObject({
-			type: 'text_delta',
-			text: 'hello world',
-			messageId: MID,
-		})
-	})
-
-	it('merges consecutive tool_input_delta events with same toolUseId', async () => {
-		const events: RunEvent[] = [
-			{ type: 'tool_input_delta', runId: RID, toolUseId: TUID, partialJson: '{"file":' },
-			{ type: 'tool_input_delta', runId: RID, toolUseId: TUID, partialJson: '"/a"' },
-			{ type: 'tool_input_delta', runId: RID, toolUseId: TUID, partialJson: '}' },
-		]
-		const result = await drain(coalesce(fromArray(events), { windowMs: 1000 }))
-		expect(result).toHaveLength(1)
-		expect(result[0]).toMatchObject({
-			type: 'tool_input_delta',
-			toolUseId: TUID,
-			partialJson: '{"file":"/a"}',
-		})
-	})
-
-	it('does not merge across different messageIds', async () => {
-		const events: RunEvent[] = [
-			{ type: 'text_delta', runId: RID, iteration: 0, messageId: MID, text: 'a' },
-			{ type: 'text_delta', runId: RID, iteration: 0, messageId: MID2, text: 'b' },
-		]
-		const result = await drain(coalesce(fromArray(events), { windowMs: 1000 }))
-		expect(result).toHaveLength(2)
-	})
-
-	it('does not merge across different toolUseIds', async () => {
-		const events: RunEvent[] = [
-			{ type: 'tool_input_delta', runId: RID, toolUseId: TUID, partialJson: 'x' },
-			{ type: 'tool_input_delta', runId: RID, toolUseId: TUID2, partialJson: 'y' },
-		]
-		const result = await drain(coalesce(fromArray(events), { windowMs: 1000 }))
-		expect(result).toHaveLength(2)
-	})
-
-	it('flushes pending buffers when a non-coalescable event arrives', async () => {
-		const events: RunEvent[] = [
-			{ type: 'text_delta', runId: RID, iteration: 0, messageId: MID, text: 'a' },
-			{ type: 'text_delta', runId: RID, iteration: 0, messageId: MID, text: 'b' },
-			{
-				type: 'tool_input_started',
-				runId: RID,
-				iteration: 0,
-				messageId: MID,
-				toolUseId: TUID,
-				toolName: 'read',
-			},
-			{ type: 'text_delta', runId: RID, iteration: 0, messageId: MID, text: 'c' },
-		]
-		const result = await drain(coalesce(fromArray(events), { windowMs: 1000 }))
-		expect(result.map((e) => e.type)).toEqual(['text_delta', 'tool_input_started', 'text_delta'])
-		expect((result[0] as { text: string }).text).toBe('ab')
-		expect((result[2] as { text: string }).text).toBe('c')
-	})
-
-	it('flushes residual buffers at end of stream', async () => {
-		const events: RunEvent[] = [
-			{ type: 'text_delta', runId: RID, iteration: 0, messageId: MID, text: 'tail' },
-		]
-		const result = await drain(coalesce(fromArray(events), { windowMs: 1000 }))
-		expect(result).toHaveLength(1)
-	})
-
-	it('emits new event after window expires', async () => {
-		const events: [RunEvent, RunEvent] = [
-			{ type: 'text_delta', runId: RID, iteration: 0, messageId: MID, text: 'a' },
-			{ type: 'text_delta', runId: RID, iteration: 0, messageId: MID, text: 'b' },
-		]
-		const stream: AsyncIterable<RunEvent> = (async function* () {
-			yield events[0]
-			await new Promise((r) => setTimeout(r, 30))
-			yield events[1]
-		})()
-		const result = await drain(coalesce(stream, { windowMs: 16 }))
-		expect(result).toHaveLength(2)
-	})
-})

package/src/telemetry/__tests__/latency-instruments.test.ts

@@ -1,120 +0,0 @@
-import { type Attributes, type Meter, metrics } from '@opentelemetry/api'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import { recordTimeToFirstToken, recordToolCall, resetRuntimeMetrics } from '../metrics.js'
-
-/**
- * namzu streams, so perceived latency is dominated by time to first token
- * — and the only latency histogram measured the whole request, which
- * cannot distinguish a fast-first-token long generation from a stalled
- * one. No host could recover the difference from namzu's data in any form.
- *
- * The tool half is milder: the wall clock WAS measured and emitted per
- * call on `tool_completed`, so a p95 was computable from events. What was
- * missing was the instrument — with the value already in scope one frame
- * above the call site.
- */
-
-interface Written {
-	instrument: string
-	value: number
-	attributes: Attributes
-}
-
-function fakeMeterProvider(written: Written[]) {
-	const instrument = (name: string) => ({
-		add: (value: number, attributes: Attributes = {}) =>
-			written.push({ instrument: name, value, attributes }),
-		record: (value: number, attributes: Attributes = {}) =>
-			written.push({ instrument: name, value, attributes }),
-	})
-	const meter = {
-		createCounter: (name: string) => instrument(name),
-		createHistogram: (name: string) => instrument(name),
-		createUpDownCounter: (name: string) => instrument(name),
-		createObservableGauge: (name: string) => instrument(name),
-		createObservableCounter: (name: string) => instrument(name),
-		createObservableUpDownCounter: (name: string) => instrument(name),
-		addBatchObservableCallback: () => {},
-		removeBatchObservableCallback: () => {},
-	} as unknown as Meter
-	return { getMeter: () => meter }
-}
-
-let written: Written[]
-
-beforeEach(() => {
-	written = []
-	resetRuntimeMetrics()
-	metrics.setGlobalMeterProvider(fakeMeterProvider(written))
-})
-
-afterEach(() => {
-	metrics.disable()
-	resetRuntimeMetrics()
-})
-
-const writesTo = (name: string) => written.filter((w) => w.instrument === name)
-
-const TTFT = 'gen_ai.client.time_to_first_token'
-const TOOL_DURATION = 'gen_ai.tool.call.duration'
-
-describe('time to first token', () => {
-	it('is recorded in seconds, like every other duration here', async () => {
-		recordTimeToFirstToken('m-1', 250)
-
-		// A histogram that silently used milliseconds would look right and
-		// aggregate wrong next to the request-duration one.
-		expect(writesTo(TTFT)[0]?.value).toBeCloseTo(0.25)
-	})
-
-	it('is keyed by model, so a slow model is attributable', () => {
-		recordTimeToFirstToken('fast', 100)
-		recordTimeToFirstToken('slow', 4_000)
-
-		expect(writesTo(TTFT).map((w) => w.attributes['gen_ai.request.model'])).toEqual([
-			'fast',
-			'slow',
-		])
-	})
-
-	it('is a separate instrument from the whole-request duration', () => {
-		// The point of the gap: one number cannot answer both questions.
-		recordTimeToFirstToken('m-1', 250)
-		expect(writesTo('gen_ai.client.operation.duration')).toHaveLength(0)
-		expect(writesTo(TTFT)).toHaveLength(1)
-	})
-})
-
-describe('tool duration', () => {
-	it('is recorded when the caller supplies it', () => {
-		recordToolCall('read', true, undefined, 1_500)
-		expect(writesTo(TOOL_DURATION)[0]?.value).toBeCloseTo(1.5)
-	})
-
-	it('shares the attributes of the count, so slow and failing join up', () => {
-		recordToolCall('fetch', false, 'ETIMEDOUT', 2_000)
-
-		expect(writesTo(TOOL_DURATION)[0]?.attributes).toMatchObject({
-			'gen_ai.tool.name': 'fetch',
-			'namzu.tool.success': false,
-			'namzu.tool.error': 'ETIMEDOUT',
-		})
-	})
-
-	it('still counts the call when no duration is supplied', () => {
-		recordToolCall('read', true)
-
-		expect(writesTo('gen_ai.tool.call.count')).toHaveLength(1)
-		// No duration write rather than a fabricated zero, which would drag
-		// every percentile down.
-		expect(writesTo(TOOL_DURATION)).toHaveLength(0)
-	})
-
-	it('counts and times in one call, not two that could diverge', () => {
-		recordToolCall('read', true, undefined, 900)
-
-		expect(writesTo('gen_ai.tool.call.count')).toHaveLength(1)
-		expect(writesTo(TOOL_DURATION)).toHaveLength(1)
-	})
-})

package/src/telemetry/__tests__/metrics.test.ts

@@ -1,160 +0,0 @@
-import { type Attributes, type Meter, metrics } from '@opentelemetry/api'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import {
-	recordModelDuration,
-	recordRunDuration,
-	recordTokenUsage,
-	recordToolCall,
-	resetRuntimeMetrics,
-} from '../metrics.js'
-
-/**
- * Metrics lived in a bag a host was expected to construct, and nothing in
- * the workspace ever constructed one — so the runtime emitted spans and not
- * a single measurement. Worse, the bag bound its instruments eagerly: one
- * built before the provider was installed captured the no-op meter and
- * discarded every write for the rest of its life, silently, from one line
- * of call order.
- */
-
-interface Written {
-	instrument: string
-	value: number
-	attributes: Attributes
-}
-
-function fakeMeterProvider(written: Written[]) {
-	const instrument = (name: string) => ({
-		add: (value: number, attributes: Attributes = {}) =>
-			written.push({ instrument: name, value, attributes }),
-		record: (value: number, attributes: Attributes = {}) =>
-			written.push({ instrument: name, value, attributes }),
-	})
-	const meter = {
-		createCounter: (name: string) => instrument(name),
-		createHistogram: (name: string) => instrument(name),
-		createUpDownCounter: (name: string) => instrument(name),
-		createObservableGauge: (name: string) => instrument(name),
-		createObservableCounter: (name: string) => instrument(name),
-		createObservableUpDownCounter: (name: string) => instrument(name),
-		addBatchObservableCallback: () => {},
-		removeBatchObservableCallback: () => {},
-	} as unknown as Meter
-	return { getMeter: () => meter }
-}
-
-let written: Written[]
-
-beforeEach(() => {
-	written = []
-	resetRuntimeMetrics()
-	metrics.setGlobalMeterProvider(fakeMeterProvider(written))
-})
-
-afterEach(() => {
-	metrics.disable()
-	resetRuntimeMetrics()
-})
-
-const attributesOf = (name: string) => written.filter((w) => w.instrument === name)
-
-describe('token usage', () => {
-	it('records every kind under ONE metric, split by type', () => {
-		recordTokenUsage('m', {
-			promptTokens: 100,
-			completionTokens: 20,
-			cachedTokens: 500,
-			cacheWriteTokens: 40,
-		})
-
-		const writes = attributesOf('gen_ai.client.token.usage')
-		// It was two metrics under two names, the second invented — so a
-		// dashboard aggregating the conventional name saw input only.
-		expect(writes).toHaveLength(4)
-		expect(new Set(writes.map((w) => w.attributes['gen_ai.token.type']))).toEqual(
-			new Set(['input', 'output', 'cache_read', 'cache_write']),
-		)
-		expect(writes.reduce((sum, w) => sum + w.value, 0)).toBe(660)
-	})
-
-	it('records cache traffic as its own types rather than folding it into input', () => {
-		recordTokenUsage('m', { promptTokens: 10, completionTokens: 0, cachedTokens: 900 })
-
-		const input = attributesOf('gen_ai.client.token.usage').find(
-			(w) => w.attributes['gen_ai.token.type'] === 'input',
-		)
-		// A read bills at a fraction of the input rate; summing them would
-		// make the total unable to explain a bill.
-		expect(input?.value).toBe(10)
-	})
-
-	it('writes nothing for a kind that was zero', () => {
-		recordTokenUsage('m', { promptTokens: 5, completionTokens: 0 })
-		expect(attributesOf('gen_ai.client.token.usage')).toHaveLength(1)
-	})
-
-	it('carries the model on every write', () => {
-		recordTokenUsage('some-model', { promptTokens: 1, completionTokens: 1 })
-		for (const write of attributesOf('gen_ai.client.token.usage')) {
-			expect(write.attributes['gen_ai.request.model']).toBe('some-model')
-		}
-	})
-})
-
-describe('tool calls', () => {
-	it('records the outcome and why it failed', () => {
-		recordToolCall('read', false, 'ENOENT')
-		const write = attributesOf('gen_ai.tool.call.count')[0]
-		expect(write?.attributes['gen_ai.tool.name']).toBe('read')
-		expect(write?.attributes['namzu.tool.success']).toBe(false)
-		// A flat success rate cannot separate a broken tool from one whose
-		// input the model keeps getting wrong.
-		expect(write?.attributes['namzu.tool.error']).toBe('ENOENT')
-	})
-
-	it('leaves the error attribute off a success', () => {
-		recordToolCall('read', true)
-		expect(attributesOf('gen_ai.tool.call.count')[0]?.attributes).not.toHaveProperty(
-			'namzu.tool.error',
-		)
-	})
-})
-
-describe('durations', () => {
-	it('records a run in seconds, keyed by how it settled', () => {
-		recordRunDuration('completed', 2500)
-		const write = attributesOf('namzu.run.duration')[0]
-		expect(write?.value).toBe(2.5)
-		expect(write?.attributes['namzu.run.status']).toBe('completed')
-	})
-
-	it('records a model call in seconds', () => {
-		recordModelDuration('m', 1500)
-		expect(attributesOf('gen_ai.client.operation.duration')[0]?.value).toBe(1.5)
-	})
-})
-
-describe('binding', () => {
-	it('records through a provider installed AFTER the first write', () => {
-		// The bug this replaces: an instrument bound before registration
-		// captured the no-op meter and threw every write away forever.
-		metrics.disable()
-		resetRuntimeMetrics()
-		recordToolCall('early', true)
-
-		const late: Written[] = []
-		metrics.setGlobalMeterProvider(fakeMeterProvider(late))
-		recordToolCall('late', true)
-
-		expect(late.map((w) => w.attributes['gen_ai.tool.name'])).toEqual(['late'])
-	})
-
-	it('reuses instruments while the meter is unchanged', () => {
-		recordToolCall('a', true)
-		recordToolCall('b', true)
-		// Rebuilding per call would allocate on a hot path; both writes must
-		// still land.
-		expect(attributesOf('gen_ai.tool.call.count')).toHaveLength(2)
-	})
-})