@namzu/sdk 1.0.0 → 1.2.0

package/src/agents/SupervisorAgent.ts

@@ -4,21 +4,63 @@ import { ToolRegistry } from '../registry/tool/execute.js'
 import { drainQuery } from '../runtime/query/index.js'
 import type { LaunchedTaskMeta } from '../runtime/query/iteration/phases/context.js'
 import { buildCoordinatorTools } from '../tools/coordinator/index.js'
-import type { TaskGateway } from '../types/agent/gateway.js'
+import type { TaskGateway, TaskHandle } from '../types/agent/gateway.js'
 import type {
 	AgentInput,
 	AgentMetadata,
+	AgentTaskResult,
 	SupervisorAgentConfig,
 	SupervisorAgentResult,
 } from '../types/agent/index.js'
 import type { AgentTaskContext } from '../types/agent/task.js'
-import type { AgentId, TaskId } from '../types/ids/index.js'
+import type { AgentId, RunId, TaskId } from '../types/ids/index.js'
 import { deriveChildState } from '../types/invocation/index.js'
 import type { RunEventListener } from '../types/run/index.js'
 import type { ActorRef } from '../types/session/actor.js'
 import { ZERO_COST } from '../utils/cost.js'
 import { AbstractAgent } from './AbstractAgent.js'
 
+/**
+ * Build the authoritative per-task ledger from the gateway's task handles.
+ *
+ * A handle carries a `result` only when its worker actually produced one. A
+ * handle with NO result never produced a verifiable outcome, so it MUST NOT be
+ * synthesized as a success: the synthesized status is always the terminal
+ * `'failed'`, regardless of the handle's reported `state` (which may itself be
+ * `'completed'`).
+ *
+ * The earlier implementation cast `handle.state` onto the synthesized result's
+ * status, letting a worker that ended without a result count toward
+ * `completedTasks`. That produced fabricated "done" workers with empty outputs
+ * (cowork task 02c5cf2b): the supervisor reported "3 workers done, 40KB
+ * reports" when the workers never started. Real workers (those with a present
+ * `result`) are unaffected — their `result` is preserved verbatim.
+ */
+export function synthesizeTaskResults(
+	taskHandles: readonly TaskHandle[],
+	runId: RunId,
+	now: number = Date.now(),
+): AgentTaskResult[] {
+	return taskHandles.map((handle, index) => ({
+		agentId: handle.agentId,
+		result: handle.result ?? {
+			runId,
+			status: 'failed' as const,
+			usage: { ...EMPTY_TOKEN_USAGE },
+			cost: { ...ZERO_COST },
+			iterations: 0,
+			durationMs: now - handle.createdAt,
+			messages: [],
+		},
+		taskIndex: index,
+	}))
+}
+
+/** Count only the task results that genuinely completed. */
+export function countCompletedTasks(taskResults: readonly AgentTaskResult[]): number {
+	return taskResults.filter((t) => t.result.status === 'completed').length
+}
+
 export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, SupervisorAgentResult> {
 	readonly type = 'supervisor' as const
 
@@ -110,6 +152,10 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 			onTaskLaunched: (agentTaskId, meta) => {
 				launchedTasks.set(agentTaskId, meta)
 			},
+			// With a resume handler present the coordinator surface gains
+			// ask_user_question — the model can park the run on a question
+			// routed through the same HITL channel as plan approvals.
+			...(config.resumeHandler ? { resumeHandler: config.resumeHandler } : {}),
 		})
 
 		const tools = new ToolRegistry()
@@ -171,26 +217,20 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 				...(config.resumeHandler ? { resumeHandler: config.resumeHandler } : {}),
 				...(config.verificationGate ? { verificationGate: config.verificationGate } : {}),
 				...(config.sandboxProvider ? { sandboxProvider: config.sandboxProvider } : {}),
+				// Working-memory / compaction seam (optional; absent => unchanged
+				// run path, byte-identical for every existing consumer).
+				...(config.compactionConfig ? { compactionConfig: config.compactionConfig } : {}),
+				...(config.workingMemoryProvider
+					? { workingMemoryProvider: config.workingMemoryProvider }
+					: {}),
 			},
 			listener,
 		)
 
 		const taskHandles = gateway.listTasks()
-		const taskResults = taskHandles.map((handle, index) => ({
-			agentId: handle.agentId,
-			result: handle.result ?? {
-				runId,
-				status: handle.state as 'completed' | 'failed' | 'cancelled',
-				usage: { ...EMPTY_TOKEN_USAGE },
-				cost: { ...ZERO_COST },
-				iterations: 0,
-				durationMs: Date.now() - handle.createdAt,
-				messages: [],
-			},
-			taskIndex: index,
-		}))
+		const taskResults = synthesizeTaskResults(taskHandles, runId)
 
-		const completedTasks = taskResults.filter((t) => t.result.status === 'completed').length
+		const completedTasks = countCompletedTasks(taskResults)
 
 		return {
 			runId: run.id,

package/src/agents/__tests__/supervisor-ledger.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, it } from 'vitest'
+import type { TaskHandle } from '../../types/agent/gateway.js'
+import type { AgentTaskResult, BaseAgentResult } from '../../types/agent/index.js'
+import type { RunId, TaskId } from '../../types/ids/index.js'
+import { countCompletedTasks, synthesizeTaskResults } from '../SupervisorAgent.js'
+
+const RUN_ID = 'run-supervisor' as RunId
+const NOW = 1_000_000
+
+function at(results: AgentTaskResult[], index: number): AgentTaskResult {
+	const entry = results[index]
+	if (!entry) {
+		throw new Error(`expected a task result at index ${index}, got ${results.length} results`)
+	}
+	return entry
+}
+
+function handle(overrides: Partial<TaskHandle> & Pick<TaskHandle, 'state'>): TaskHandle {
+	return {
+		taskId: 'task-1' as TaskId,
+		agentId: 'worker-1',
+		createdAt: NOW - 5_000,
+		...overrides,
+	}
+}
+
+function completedResult(): BaseAgentResult {
+	return {
+		runId: 'run-worker' as RunId,
+		status: 'completed',
+		usage: {
+			promptTokens: 10,
+			completionTokens: 20,
+			totalTokens: 30,
+			cachedTokens: 0,
+			cacheWriteTokens: 0,
+		},
+		cost: {
+			inputCostPer1M: 0,
+			outputCostPer1M: 0,
+			totalCost: 0,
+			cacheDiscount: 0,
+		},
+		iterations: 3,
+		durationMs: 4_200,
+		messages: [],
+		result: 'real worker output',
+	}
+}
+
+describe('supervisor ledger truthfulness', () => {
+	describe('synthesizeTaskResults', () => {
+		it('synthesizes a FAILED result when a handle has no result, regardless of state', () => {
+			// A worker that ended with no result is NOT a success even when the
+			// handle reports a terminal 'completed' state — this is the exact
+			// fabrication that made the supervisor claim "3 workers done" with
+			// empty outputs (cowork task 02c5cf2b).
+			const results = synthesizeTaskResults(
+				[handle({ state: 'completed', result: undefined })],
+				RUN_ID,
+				NOW,
+			)
+
+			expect(results).toHaveLength(1)
+			expect(at(results, 0).result.status).toBe('failed')
+			expect(at(results, 0).result.status).not.toBe('completed')
+			expect(at(results, 0).result.runId).toBe(RUN_ID)
+			expect(at(results, 0).result.durationMs).toBe(NOW - (NOW - 5_000))
+		})
+
+		it('synthesizes a FAILED result for a genuinely failed handle', () => {
+			const results = synthesizeTaskResults(
+				[handle({ state: 'failed', result: undefined })],
+				RUN_ID,
+				NOW,
+			)
+
+			expect(at(results, 0).result.status).toBe('failed')
+		})
+
+		it('synthesizes a FAILED result for a canceled handle with no result', () => {
+			const results = synthesizeTaskResults(
+				[handle({ state: 'canceled', result: undefined })],
+				RUN_ID,
+				NOW,
+			)
+
+			expect(at(results, 0).result.status).toBe('failed')
+		})
+
+		it('preserves a present completed result verbatim (real workers unaffected)', () => {
+			const real = completedResult()
+			const results = synthesizeTaskResults(
+				[handle({ state: 'completed', result: real })],
+				RUN_ID,
+				NOW,
+			)
+
+			expect(at(results, 0).result).toBe(real)
+			expect(at(results, 0).result.status).toBe('completed')
+			expect(at(results, 0).result.result).toBe('real worker output')
+		})
+
+		it('preserves a present failed result verbatim', () => {
+			const failed: BaseAgentResult = { ...completedResult(), status: 'failed' }
+			const results = synthesizeTaskResults(
+				[handle({ state: 'failed', result: failed })],
+				RUN_ID,
+				NOW,
+			)
+
+			expect(at(results, 0).result).toBe(failed)
+			expect(at(results, 0).result.status).toBe('failed')
+		})
+	})
+
+	describe('countCompletedTasks', () => {
+		it('excludes an absent-result handle from completedTasks', () => {
+			const taskResults = synthesizeTaskResults(
+				[
+					handle({
+						taskId: 'task-a' as TaskId,
+						agentId: 'a',
+						state: 'completed',
+						result: undefined,
+					}),
+					handle({
+						taskId: 'task-b' as TaskId,
+						agentId: 'b',
+						state: 'completed',
+						result: completedResult(),
+					}),
+				],
+				RUN_ID,
+				NOW,
+			)
+
+			// Two handles, both with handle.state === 'completed', but only the
+			// one that actually produced a result counts.
+			expect(taskResults).toHaveLength(2)
+			expect(countCompletedTasks(taskResults)).toBe(1)
+		})
+
+		it('counts every present completed result', () => {
+			const taskResults = synthesizeTaskResults(
+				[
+					handle({
+						taskId: 'task-a' as TaskId,
+						agentId: 'a',
+						state: 'completed',
+						result: completedResult(),
+					}),
+					handle({
+						taskId: 'task-b' as TaskId,
+						agentId: 'b',
+						state: 'completed',
+						result: completedResult(),
+					}),
+				],
+				RUN_ID,
+				NOW,
+			)
+
+			expect(countCompletedTasks(taskResults)).toBe(2)
+		})
+
+		it('reports zero completed when no worker produced a result', () => {
+			const taskResults = synthesizeTaskResults(
+				[
+					handle({
+						taskId: 'task-a' as TaskId,
+						agentId: 'a',
+						state: 'completed',
+						result: undefined,
+					}),
+					handle({ taskId: 'task-b' as TaskId, agentId: 'b', state: 'running', result: undefined }),
+				],
+				RUN_ID,
+				NOW,
+			)
+
+			expect(countCompletedTasks(taskResults)).toBe(0)
+		})
+	})
+})

package/src/bridge/a2a/mapper.ts

@@ -60,6 +60,9 @@ const MAPPING: {
 			parts: [{ kind: 'text', text: e.error }],
 		}),
 
+	// Capability degradation is host-facing diagnostics, not A2A task state.
+	capability_warning: null,
+
 	iteration_started: (e, ctx) =>
 		statusEvent(e.runId, 'running', false, ctx, {
 			role: 'agent',

package/src/bridge/sse/mapper.ts

@@ -165,6 +165,11 @@ const MAPPING: {
 	run_completed: null,
 	run_failed: null,
 
+	// Not mapped to a wire event yet — hosts consume `capability_warning`
+	// from the RunEvent stream directly; promoting it to the SSE contract
+	// needs a StreamEventType addition first.
+	capability_warning: null,
+
 	agent_pending: {
 		wire: 'agent.pending',
 		transform: (e, runId) => ({

package/src/config/runtime.ts

@@ -18,6 +18,15 @@ export const TaskRouterConfigSchema = z
 
 export const CompactionConfigSchema = z.object({
 	strategy: z.enum(['structured', 'sliding-window', 'disabled']).default('structured'),
+	/**
+	 * Optional model context-window size (tokens) the compaction trigger
+	 * measures the CURRENT window against. NO default: when omitted the
+	 * trigger falls back to the run-level cumulative `tokenBudget` exactly as
+	 * before, so existing consumers are byte-identical. Hosts that keep
+	 * `tokenBudget` unlimited (0) set this so compaction fires on
+	 * window-pressure instead of being a silent no-op.
+	 */
+	contextWindowTokens: z.number().positive().optional(),
 	triggerThreshold: z.number().min(0).max(1).default(0.7),
 	resetThreshold: z.number().min(0).max(1).default(0.4),
 	keepRecentMessages: z.number().positive().default(4),

package/src/connector/builtins/webhook.test.ts

@@ -126,6 +126,27 @@ describe('WebhookConnector', () => {
 		expect((await c.execute('send', { payload: {} })).success).toBe(false)
 	})
 
+	it('healthCheck returns false when the HEAD fetch throws', async () => {
+		const c = new WebhookConnector()
+		await c.connect({ url: 'https://hook.example.com' })
+		fetchMock.mockRejectedValueOnce(new Error('network down'))
+		expect(await c.healthCheck()).toBe(false)
+	})
+
+	it('reads a text body when the response is not JSON', async () => {
+		const c = new WebhookConnector()
+		await c.connect({ url: 'https://hook.example.com' })
+		fetchMock.mockResolvedValueOnce(
+			makeResponse({
+				status: 200,
+				headers: { 'content-type': 'text/plain' },
+				body: 'plain-text-ack',
+			}),
+		)
+		const result = await c.execute('send', { payload: { k: 'v' } })
+		expect((result.output as { body: unknown }).body).toBe('plain-text-ack')
+	})
+
 	it('metadata.deliveredAt is a recent timestamp', async () => {
 		const before = Date.now()
 		const c = new WebhookConnector()

package/src/connector/index.ts

@@ -34,6 +34,7 @@ export type {
 
 export { StdioTransport } from './mcp/stdio.js'
 export { HttpSseTransport } from './mcp/http-sse.js'
+export { StreamableHttpTransport } from './mcp/streamable-http.js'
 
 export { MCPClient } from './mcp/client.js'
 

package/src/connector/mcp/client.ts

@@ -19,6 +19,7 @@ import { generateMCPClientId } from '../../utils/id.js'
 import { type Logger, getRootLogger } from '../../utils/logger.js'
 import { HttpSseTransport } from './http-sse.js'
 import { StdioTransport } from './stdio.js'
+import { StreamableHttpTransport } from './streamable-http.js'
 
 import { MCP_PROTOCOL_VERSION } from '../../constants/mcp/index.js'
 import { VERSION } from '../../version.js'
@@ -175,6 +176,9 @@ export class MCPClient {
 				return new StdioTransport(config)
 			case 'http-sse':
 				return new HttpSseTransport(config)
+			case 'streamable_http':
+			case 'streamable-http':
+				return new StreamableHttpTransport(config)
 			default:
 				throw new Error(`Unsupported MCP transport type: ${(config as MCPTransportUnion).type}`)
 		}

package/src/connector/mcp/index.ts

@@ -1,5 +1,6 @@
 export { StdioTransport } from './stdio.js'
 export { HttpSseTransport } from './http-sse.js'
+export { StreamableHttpTransport } from './streamable-http.js'
 
 export { MCPClient } from './client.js'
 

package/src/connector/mcp/streamable-http.test.ts

@@ -0,0 +1,169 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import type { MCPJsonRpcMessage } from '../../types/connector/index.js'
+import { MCPClient } from './client.js'
+
+afterEach(() => {
+	vi.unstubAllGlobals()
+})
+
+describe('Streamable HTTP MCP transport', () => {
+	it('connects through MCPClient, preserves session headers, and parses SSE responses', async () => {
+		const fetchMock = vi.fn<typeof fetch>()
+		fetchMock
+			.mockResolvedValueOnce(
+				jsonResponse(
+					{
+						jsonrpc: '2.0',
+						id: 1,
+						result: {
+							protocolVersion: '2024-11-05',
+							capabilities: { tools: { listChanged: true } },
+							serverInfo: { name: 'github' },
+						},
+					},
+					{ 'mcp-session-id': 'sid_123' },
+				),
+			)
+			.mockResolvedValueOnce(new Response('', { status: 202 }))
+			.mockResolvedValueOnce(
+				sseResponse([
+					{ jsonrpc: '2.0', method: 'notifications/progress', params: { pct: 50 } },
+					{
+						jsonrpc: '2.0',
+						id: 2,
+						result: {
+							tools: [
+								{
+									name: 'search_repositories',
+									description: 'Search repositories',
+									inputSchema: { type: 'object' },
+								},
+							],
+						},
+					},
+				]),
+			)
+		vi.stubGlobal('fetch', fetchMock)
+
+		const client = new MCPClient({
+			serverName: 'github',
+			transport: {
+				type: 'streamable_http',
+				url: 'https://mcp.example.test/mcp',
+				headers: { Authorization: 'Bearer token' },
+			},
+		})
+		const notifications: string[] = []
+		client.onNotification((method) => notifications.push(method))
+
+		await client.connect()
+		const tools = await client.listTools()
+
+		expect(tools.map((tool) => tool.name)).toEqual(['search_repositories'])
+		expect(notifications).toEqual(['notifications/progress'])
+		expect(fetchMock).toHaveBeenCalledTimes(3)
+
+		const initialize = requestAt(fetchMock, 0)
+		expect(initialize.input).toBe('https://mcp.example.test/mcp')
+		expect(initialize.body.method).toBe('initialize')
+		expect(initialize.headers.Authorization).toBe('Bearer token')
+		expect(initialize.headers.Accept).toBe('application/json, text/event-stream')
+
+		const initialized = requestAt(fetchMock, 1)
+		expect(initialized.body.method).toBe('notifications/initialized')
+		expect(initialized.headers['Mcp-Session-Id']).toBe('sid_123')
+
+		const listTools = requestAt(fetchMock, 2)
+		expect(listTools.body.method).toBe('tools/list')
+		expect(listTools.headers['Mcp-Session-Id']).toBe('sid_123')
+	})
+
+	it('supports the streamable-http alias without non-standard hint headers', async () => {
+		const fetchMock = vi.fn<typeof fetch>()
+		fetchMock
+			.mockResolvedValueOnce(
+				jsonResponse(
+					{
+						jsonrpc: '2.0',
+						id: 1,
+						result: {
+							protocolVersion: '2024-11-05',
+							capabilities: { tools: {} },
+							serverInfo: { name: 'linear' },
+						},
+					},
+					{ 'Mcp-Session-Id': 'sid_alias' },
+				),
+			)
+			.mockResolvedValueOnce(new Response(null, { status: 204 }))
+			.mockResolvedValueOnce(
+				jsonResponse({
+					jsonrpc: '2.0',
+					id: 2,
+					result: { content: [{ type: 'text', text: 'ok' }] },
+				}),
+			)
+		vi.stubGlobal('fetch', fetchMock)
+
+		const client = new MCPClient({
+			serverName: 'linear',
+			transport: {
+				type: 'streamable-http',
+				url: 'https://mcp.example.test/linear',
+			},
+		})
+
+		await client.connect()
+		const result = await client.callTool('create_issue', { title: 'Bug' })
+
+		expect(result.content).toEqual([{ type: 'text', text: 'ok' }])
+		const callTool = requestAt(fetchMock, 2)
+		expect(callTool.body.method).toBe('tools/call')
+		expect(callTool.headers).toEqual({
+			'Content-Type': 'application/json',
+			Accept: 'application/json, text/event-stream',
+			'Mcp-Session-Id': 'sid_alias',
+		})
+	})
+})
+
+function jsonResponse(body: MCPJsonRpcMessage, headers?: Record<string, string>): Response {
+	return new Response(JSON.stringify(body), {
+		status: 200,
+		headers: {
+			'content-type': 'application/json',
+			...headers,
+		},
+	})
+}
+
+function sseResponse(messages: MCPJsonRpcMessage[]): Response {
+	return new Response(messages.map((message) => `data: ${JSON.stringify(message)}\n\n`).join(''), {
+		status: 200,
+		headers: {
+			'content-type': 'text/event-stream',
+		},
+	})
+}
+
+function requestAt(
+	fetchMock: ReturnType<typeof vi.fn<typeof fetch>>,
+	index: number,
+): {
+	input: Parameters<typeof fetch>[0]
+	headers: Record<string, string>
+	body: MCPJsonRpcMessage
+} {
+	const call = fetchMock.mock.calls[index]
+	if (!call) {
+		throw new Error(`No fetch call at index ${index}`)
+	}
+	const [input, init] = call
+	if (!init) {
+		throw new Error(`Fetch call at index ${index} had no init`)
+	}
+	const headers = init.headers as Record<string, string>
+	const body = JSON.parse(String(init.body)) as MCPJsonRpcMessage
+	return { input, headers, body }
+}