@namzu/sdk 0.6.0 → 1.1.0

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 }
+}

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

@@ -0,0 +1,152 @@
+import type {
+	MCPJsonRpcMessage,
+	MCPStreamableHttpTransportConfig,
+	MCPTransport,
+} from '../../types/connector/index.js'
+import { type Logger, getRootLogger } from '../../utils/logger.js'
+
+const DEFAULT_TIMEOUT_MS = 30_000
+
+export class StreamableHttpTransport implements MCPTransport {
+	private messageHandlers: Array<(message: MCPJsonRpcMessage) => void> = []
+	private closeHandlers: Array<() => void> = []
+	private errorHandlers: Array<(error: Error) => void> = []
+	private connected = false
+	private sessionId: string | null = null
+	private log: Logger
+
+	constructor(private readonly config: MCPStreamableHttpTransportConfig) {
+		this.log = getRootLogger().child({ component: 'StreamableHttpTransport' })
+	}
+
+	async connect(): Promise<void> {
+		if (this.connected) return
+		this.connected = true
+		this.log.info(`StreamableHttpTransport connected to ${this.config.url}`)
+	}
+
+	async close(): Promise<void> {
+		if (!this.connected) return
+		this.connected = false
+		for (const handler of this.closeHandlers) handler()
+	}
+
+	async send(message: MCPJsonRpcMessage): Promise<void> {
+		if (!this.connected) {
+			throw new Error('StreamableHttpTransport: not connected')
+		}
+
+		const controller = new AbortController()
+		const timeout = setTimeout(
+			() => controller.abort(),
+			this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+		)
+
+		try {
+			const response = await fetch(this.config.url, {
+				method: 'POST',
+				headers: this.buildHeaders(),
+				body: JSON.stringify(message),
+				signal: controller.signal,
+			})
+
+			this.captureSessionId(response)
+
+			if (!response.ok) {
+				throw new Error(`StreamableHttpTransport: HTTP ${response.status}: ${response.statusText}`)
+			}
+
+			await this.dispatchResponseMessages(response)
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err))
+			for (const handler of this.errorHandlers) handler(error)
+			throw error
+		} finally {
+			clearTimeout(timeout)
+		}
+	}
+
+	onMessage(handler: (message: MCPJsonRpcMessage) => void): void {
+		this.messageHandlers.push(handler)
+	}
+
+	onClose(handler: () => void): void {
+		this.closeHandlers.push(handler)
+	}
+
+	onError(handler: (error: Error) => void): void {
+		this.errorHandlers.push(handler)
+	}
+
+	isConnected(): boolean {
+		return this.connected
+	}
+
+	private buildHeaders(): Record<string, string> {
+		const headers: Record<string, string> = {
+			'Content-Type': 'application/json',
+			Accept: 'application/json, text/event-stream',
+			...this.config.headers,
+		}
+
+		if (this.sessionId) {
+			headers['Mcp-Session-Id'] = this.sessionId
+		}
+
+		return headers
+	}
+
+	private captureSessionId(response: Response): void {
+		const sessionId =
+			response.headers.get('mcp-session-id') ?? response.headers.get('Mcp-Session-Id')
+		if (sessionId && sessionId.length > 0) {
+			this.sessionId = sessionId
+		}
+	}
+
+	private async dispatchResponseMessages(response: Response): Promise<void> {
+		const text = await response.text()
+		if (text.trim().length === 0) return
+
+		const contentType = response.headers.get('content-type') ?? ''
+		const messages = contentType.includes('text/event-stream')
+			? parseSseMessages(text)
+			: parseJsonMessages(text)
+
+		for (const message of messages) {
+			for (const handler of this.messageHandlers) handler(message)
+		}
+	}
+}
+
+function parseJsonMessages(raw: string): MCPJsonRpcMessage[] {
+	const parsed = JSON.parse(raw) as MCPJsonRpcMessage | MCPJsonRpcMessage[]
+	return Array.isArray(parsed) ? parsed : [parsed]
+}
+
+function parseSseMessages(raw: string): MCPJsonRpcMessage[] {
+	const normalized = raw.replace(/\r\n/g, '\n')
+	const events = normalized.split(/\n\n+/)
+	const messages: MCPJsonRpcMessage[] = []
+
+	for (const event of events) {
+		const dataLines = event
+			.split('\n')
+			.filter((line) => line.startsWith('data:'))
+			.map((line) => line.slice('data:'.length).trimStart())
+
+		if (dataLines.length === 0) continue
+
+		const data = dataLines.join('\n').trim()
+		if (data.length === 0 || data === '[DONE]') continue
+
+		const parsed = JSON.parse(data) as MCPJsonRpcMessage | MCPJsonRpcMessage[]
+		if (Array.isArray(parsed)) {
+			messages.push(...parsed)
+		} else {
+			messages.push(parsed)
+		}
+	}
+
+	return messages
+}

package/src/constants/compaction/index.ts

@@ -1,10 +1,15 @@
-export const READ_TOOLS = new Set(['read_file'])
+// Tool-name buckets used by the compaction extractor to classify
+// captured tool results. Lowercase to match the canonical builtin
+// tool names (Anthropic Claude emits `tool_use.name` lowercase, see
+// ses_008-tool-name-case-fix). `edit` is grouped with `write`
+// because both mutate file content.
+export const READ_TOOLS = new Set(['read'])
 
-export const EDIT_TOOLS = new Set(['write_file'])
+export const EDIT_TOOLS = new Set(['write', 'edit'])
 
 export const SHELL_TOOLS = new Set(['bash'])
 
-export const SEARCH_TOOLS = new Set(['glob', 'search_tools'])
+export const SEARCH_TOOLS = new Set(['glob', 'grep'])
 
 export const SECTION_HEADERS = {
 	task: '## Task',

package/src/constants/sandbox/index.ts

@@ -29,3 +29,40 @@ export const SANDBOX_SAFE_ENV_KEYS = new Set([
 	'LC_ALL',
 	'LC_CTYPE',
 ])
+
+// ---------------------------------------------------------------------------
+// ContainerSandboxLayout default container paths
+// ---------------------------------------------------------------------------
+//
+// Mirrors the taxonomy Anthropic's container architecture exposes to
+// the model (Claude container blueprint, Code Interpreter, "skills").
+// Exported so prompt-template consumers can write
+// `Outputs go to ${SANDBOX_DEFAULT_OUTPUTS_PATH}` instead of
+// hard-coding the string in two places that drift.
+
+/** Default container path for the user-visible outputs (RW) bind. */
+export const SANDBOX_DEFAULT_OUTPUTS_PATH = '/mnt/user-data/outputs'
+
+/** Default container path for user-uploaded files (RO). */
+export const SANDBOX_DEFAULT_UPLOADS_PATH = '/mnt/user-data/uploads'
+
+/**
+ * Default container path for the agent's working/scratch space (RW).
+ * Sibling mount to {@link SANDBOX_DEFAULT_OUTPUTS_PATH} — anything
+ * written here is invisible to the output collector by design,
+ * mirroring the Anthropic Cowork pattern (`/home/claude` scratch vs.
+ * `/mnt/user-data/outputs` user-visible).
+ */
+export const SANDBOX_DEFAULT_SCRATCH_PATH = '/mnt/user-data/scratch'
+
+/** Default container path for cached tool fetches (RO). */
+export const SANDBOX_DEFAULT_TOOL_RESULTS_PATH = '/mnt/user-data/tool_results'
+
+/** Default container path for prior-conversation transcripts (RO). */
+export const SANDBOX_DEFAULT_TRANSCRIPTS_PATH = '/mnt/transcripts'
+
+/**
+ * Default parent path under which each skill bundle binds.
+ * Per-skill default is `${SANDBOX_DEFAULT_SKILLS_PARENT}/<skill-id>`.
+ */
+export const SANDBOX_DEFAULT_SKILLS_PARENT = '/mnt/skills'

package/src/constants/tools/index.ts

@@ -1,3 +1,34 @@
-export const DANGEROUS_PATTERNS = [/rm\s+-rf\s+\//, /mkfs/, /dd\s+if=/, /:(){ :\|:& };:/]
+// Patterns the verification gate's `deny_dangerous_patterns` rule
+// matches against the JSON-serialised tool input. The list is
+// intentionally short and high-signal: the goal is to catch the
+// canonical "I will brick the host" mistakes (filesystem wipes,
+// disk reformat, fork bomb) plus the most common shell-side
+// privilege/escape patterns (root sudo, world-writable chmod, the
+// classic curl|bash / wget|bash exfil-then-exec pipe, raw eval).
+//
+// This is NOT a security boundary — Cursor learned the hard way
+// that bash denylists are bypassed via shell tricks like `e""cho`
+// (see Backslash Security 2025). Sandbox enforcement (FS isolation,
+// network egress proxy) is the real boundary; these patterns only
+// catch the most blatant attempts and turn them into an explicit
+// review prompt instead of a silent execute.
+export const DANGEROUS_PATTERNS = [
+	// Filesystem wipe / fork bomb / raw disk write.
+	/rm\s+-rf\s+\//,
+	/mkfs/,
+	/dd\s+if=/,
+	/:(){ :\|:& };:/,
+	// Privilege escalation + world-writable chmod on /.
+	/\bsudo\b/,
+	/\bsu\s+-/,
+	/chmod\s+(?:-R\s+)?777\s+\//,
+	// Pipe-to-shell from network — exfil-then-exec staging.
+	/\bcurl\b[^|]*\|\s*(?:sh|bash|zsh)\b/,
+	/\bwget\b[^|]*\|\s*(?:sh|bash|zsh)\b/,
+	// Remote shell / outbound SSH.
+	/\bssh\s+\S+@/,
+	// Raw eval of dynamic strings.
+	/\beval\s+["'`$]/,
+]
 
-export const FILESYSTEM_TOOLS = new Set(['glob', 'read_file', 'write_file', 'bash'])
+export const FILESYSTEM_TOOLS = new Set(['glob', 'read', 'write', 'bash'])

package/src/manager/run/persistence.ts

@@ -1,8 +1,9 @@
 import { EMPTY_TOKEN_USAGE } from '../../constants/limits.js'
+import { AUTO_CONTINUATION_USER_MESSAGE } from '../../runtime/query/continuation.js'
 import { RunDiskStore } from '../../store/run/disk.js'
 import { type CostInfo, type TokenUsage, accumulateTokenUsage } from '../../types/common/index.js'
 import type { RunId, SessionId, TenantId } from '../../types/ids/index.js'
-import type { AssistantMessage, Message } from '../../types/message/index.js'
+import type { Message } from '../../types/message/index.js'
 import type { EmergencySaveData } from '../../types/run/emergency.js'
 import type { Run, RunPersistenceConfig, StopReason } from '../../types/run/index.js'
 import type { ProjectId, ThreadId } from '../../types/session/ids.js'
@@ -169,12 +170,39 @@ export class RunPersistence {
 	}
 
 	private resolveResult(): void {
-		const lastAssistant = [...this.run.messages]
-			.reverse()
-			.find((m): m is AssistantMessage => m.role === 'assistant' && m.content !== null)
+		// Walk the tail of the message log to assemble the final
+		// assistant output. The iteration loop's auto-continuation
+		// path (see `runtime/query/iteration/index.ts`) inserts a
+		// synthetic user prompt — exactly equal to
+		// `AUTO_CONTINUATION_USER_MESSAGE` — between two assistant
+		// messages whenever a turn ended with
+		// `stop_reason: max_tokens` mid-text. Treat that synthetic
+		// user as transparent: keep collecting assistant content past
+		// it so the run's persisted `result` carries the full
+		// multi-turn output, not just the trailing continuation
+		// chunk. Stops at the first non-assistant, non-marker
+		// message (e.g. the real user prompt that started the run,
+		// or a tool message between turns).
+		const chunks: string[] = []
+		for (let i = this.run.messages.length - 1; i >= 0; i--) {
+			const msg = this.run.messages[i]
+			if (!msg) continue
+			if (msg.role === 'assistant') {
+				if (msg.content !== null) chunks.push(msg.content)
+				continue
+			}
+			if (msg.role === 'user' && msg.content === AUTO_CONTINUATION_USER_MESSAGE) {
+				// Synthetic continuation prompt — skip and keep
+				// collecting the partial that preceded it.
+				continue
+			}
+			break
+		}
 
-		if (lastAssistant?.content) {
-			this.run.result = lastAssistant.content
+		if (chunks.length > 0) {
+			// chunks were collected newest-first; reverse so the
+			// assembled string is chronological.
+			this.run.result = chunks.reverse().join('')
 		}
 	}
 

package/src/persona/assembler.ts

@@ -23,14 +23,9 @@ export function assembleSystemPrompt(persona: AgentPersona, skills?: Skill[]): s
 		}
 	}
 
-	if (skills && skills.length > 0) {
-		const loadedSkills = skills.filter((s) => s.body)
-		if (loadedSkills.length > 0) {
-			const skillSections = loadedSkills.map(
-				(s) => `### ${s.metadata.name}\n**Skill directory:** \`${s.dirPath}\`\n\n${s.body}`,
-			)
-			sections.push(`## Skills\n\n${skillSections.join('\n\n')}`)
-		}
+	const skillsSection = renderSkillsSection(skills)
+	if (skillsSection) {
+		sections.push(skillsSection)
 	}
 
 	if (persona.reflexes?.outputDiscipline) {
@@ -48,6 +43,46 @@ export function assembleSystemPrompt(persona: AgentPersona, skills?: Skill[]): s
 	return sections.join('\n\n')
 }
 
+export function renderSkillsSection(skills?: Skill[]): string | null {
+	if (!skills || skills.length === 0) return null
+
+	const available = skills
+		.map((s) => {
+			const lines = [
+				'<skill>',
+				`<name>${s.metadata.name}</name>`,
+				`<description>${s.metadata.description.trim()}</description>`,
+				`<location>${s.dirPath}/SKILL.md</location>`,
+			]
+			if (s.metadata.compatibility) {
+				lines.push(`<compatibility>${s.metadata.compatibility}</compatibility>`)
+			}
+			if (s.metadata.license) {
+				lines.push(`<license>${s.metadata.license}</license>`)
+			}
+			if (s.metadata.allowedTools) {
+				lines.push(`<allowed_tools>${s.metadata.allowedTools}</allowed_tools>`)
+			}
+			lines.push('</skill>')
+			return lines.join('\n')
+		})
+		.join('\n')
+
+	const loadedSkills = skills.filter((s) => s.body)
+	const sections = [
+		`## Available Skills\nThe following block is a manifest, not the full skill content. Skill metadata is always visible; SKILL.md bodies are loaded only when the user's task matches the skill description.\n\n<available_skills>\n${available}\n</available_skills>\n\nSkill usage protocol:\n- Plain questions do not require a skill.\n- When a matching skill is already listed under Loaded Skills, apply its loaded instructions.\n- When a matching skill is not loaded and the runtime exposes filesystem or skill-loading tools, read the SKILL.md at its <location> before writing code, creating files, running shell commands for that workflow, or calling mutation tools guided by the skill.\n- Do not claim to have read a SKILL.md until its content is actually present in the prompt or returned by a tool.\n- Tool schemas and runtime permissions remain authoritative; skills provide guidance, not hidden tools.`,
+	]
+
+	if (loadedSkills.length > 0) {
+		const skillSections = loadedSkills.map(
+			(s) => `### ${s.metadata.name}\n**Skill directory:** \`${s.dirPath}\`\n\n${s.body}`,
+		)
+		sections.push(`## Loaded Skills\n\n${skillSections.join('\n\n')}`)
+	}
+
+	return sections.join('\n\n')
+}
+
 export function renderOutputDiscipline(discipline: OutputDiscipline): string {
 	const lines: string[] = []
 

package/src/provider/collect.test.ts

@@ -57,7 +57,7 @@ describe('collect()', () => {
 					id: 'm',
 					delta: {
 						toolCalls: [
-							{ index: 0, id: 'toolu_a', function: { name: 'Read' } },
+							{ index: 0, id: 'toolu_a', function: { name: 'read' } },
 							{ index: 1, id: 'toolu_b', function: { name: 'WebSearch' } },
 						],
 					},
@@ -84,7 +84,7 @@ describe('collect()', () => {
 			{
 				id: 'toolu_a',
 				type: 'function',
-				function: { name: 'Read', arguments: '{"file_path":"/a"}' },
+				function: { name: 'read', arguments: '{"file_path":"/a"}' },
 			},
 			{
 				id: 'toolu_b',

package/src/provider/collect.ts

@@ -1,3 +1,4 @@
+import { mergeTokenUsage } from '../types/common/index.js'
 import type { ChatCompletionResponse } from '../types/provider/chat.js'
 import type { StreamChunk } from '../types/provider/stream.js'
 
@@ -60,7 +61,9 @@ export async function collect(stream: AsyncIterable<StreamChunk>): Promise<ChatC
 		}
 
 		if (chunk.finishReason) finishReason = chunk.finishReason
-		if (chunk.usage) usage = chunk.usage
+		// Merge (per-field max), not last-write-wins: a late frame that omits
+		// input/cache tokens must not zero the counts captured earlier in the stream.
+		if (chunk.usage) usage = mergeTokenUsage(usage, chunk.usage)
 	}
 
 	const toolCalls = [...toolBuckets.entries()]

package/src/public-runtime.ts

@@ -113,7 +113,11 @@ export {
 	ManagedRegistry,
 	PluginRegistry,
 	Registry,
+	ToolCatalog,
 	ToolRegistry,
+	createToolCatalogFromRegistry,
+	loadingFromAvailability,
+	toolDefinitionToCatalogEntry,
 } from './registry/index.js'
 
 export {
@@ -129,8 +133,11 @@ export {
 	EmergencySaveManager,
 	PlanManager,
 	RunPersistence,
+	ThreadManager,
 } from './manager/index.js'
 
+export { InMemoryThreadStore } from './store/thread/memory.js'
+
 export { LocalTaskGateway } from './gateway/local.js'
 
 // ─── providers, sandbox, vault ───────────────────────────────────────────
@@ -187,6 +194,7 @@ export {
 	RemoteExecutionContext,
 	ScopedConnectorRegistry,
 	StdioTransport,
+	StreamableHttpTransport,
 	TenantConnectorManager,
 	toolDefinitionToMCPTool,
 	toolResultToMCPToolResult,
@@ -220,7 +228,12 @@ export {
 	FileLockManager,
 } from './bus/index.js'
 
-export { evaluateRule, VerificationGate } from './verification/index.js'
+export {
+	defaultSandboxedGateConfig,
+	defaultSandboxedShellGateConfig,
+	evaluateRule,
+	VerificationGate,
+} from './verification/index.js'
 
 // ─── probe (typed observation over AgentBus + RunEvent stream) ───────────
 
@@ -254,6 +267,7 @@ export {
 	DefaultPathBuilder,
 	GitWorktreeDriver,
 	parseWorktreeList,
+	SharedRunWorkspace,
 	WorkspaceBackendRegistry,
 } from './session/workspace/index.js'
 

package/src/public-tools.ts

@@ -24,6 +24,7 @@ export { GlobTool } from './tools/builtins/glob.js'
 export { GrepTool } from './tools/builtins/grep.js'
 export { LsTool } from './tools/builtins/ls.js'
 export { SearchToolsTool } from './tools/builtins/search-tools.js'
+export { VerifyOutputsTool } from './tools/builtins/verify-outputs.js'
 export {
 	createStructuredOutputTool,
 	STRUCTURED_OUTPUT_TOOL_NAME,
@@ -44,6 +45,7 @@ export {
 export { buildAdvisoryTools } from './tools/advisory/index.js'
 export { buildMemoryTools } from './tools/memory/index.js'
 export { buildCoordinatorTools } from './tools/coordinator/index.js'
+export { buildAgentTool, type AgentToolOptions } from './tools/coordinator/agent.js'
 
 // ─── RAG tool builder ────────────────────────────────────────────────────
 

package/src/public-types.ts

@@ -17,6 +17,7 @@ export type * from './types/ids/index.js'
 export type * from './types/message/index.js'
 export type * from './types/common/index.js'
 export type * from './types/tool/index.js'
+export type * from './types/toolset/index.js'
 export type * from './types/permission/index.js'
 export type * from './types/run/index.js'
 export type * from './types/provider/index.js'
@@ -44,6 +45,7 @@ export type * from './types/verification/index.js'
 export type * from './types/bus/index.js'
 export type * from './types/probe/index.js'
 export type * from './types/doctor/index.js'
+export type * from './types/workspace/index.js'
 
 // Session-hierarchy type surface (ses_010 moved entities here).
 export type * from './types/session/index.js'
@@ -118,6 +120,11 @@ export type { AdvisoryToolsOptions } from './tools/advisory/index.js'
 
 export type { CoordinatorToolsOptions, TaskLaunchedCallback } from './tools/coordinator/index.js'
 
+export type {
+	RegisterSharedRunPlanInput,
+	SharedRunWorkspaceConfig,
+} from './session/workspace/index.js'
+
 export type {
 	ConnectorManagerConfig,
 	EnvironmentConnectorManagerConfig,