@namzu/sdk 0.6.0 → 1.1.0

package/src/runtime/query/executor.ts

@@ -7,13 +7,18 @@ import { type ProbeRegistry, probe as defaultProbeRegistry } from '../../probe/r
 import type { ActivityStore } from '../../store/activity/memory.js'
 import type { RunId } from '../../types/ids/index.js'
 import type { InvocationState } from '../../types/invocation/index.js'
-import { type Message, createToolMessage } from '../../types/message/index.js'
+import { type Message, type ToolCall, createToolMessage } from '../../types/message/index.js'
 import type { PermissionMode } from '../../types/permission/index.js'
 import type { PluginHookResult } from '../../types/plugin/index.js'
 import type { ChatCompletionResponse } from '../../types/provider/index.js'
 import type { RunEvent } from '../../types/run/index.js'
 import type { Sandbox } from '../../types/sandbox/index.js'
-import type { ToolContext, ToolRegistryContract, ToolResult } from '../../types/tool/index.js'
+import type {
+	FileReadTracker,
+	ToolContext,
+	ToolRegistryContract,
+	ToolResult,
+} from '../../types/tool/index.js'
 import type { Logger } from '../../utils/logger.js'
 import { compressShellOutput } from '../../utils/shell-compress.js'
 
@@ -26,6 +31,7 @@ export interface ToolExecutorConfig {
 	permissionMode: PermissionMode
 	env: Record<string, string>
 	abortSignal: AbortSignal
+	allowedTools?: readonly string[]
 	sandbox?: Sandbox
 	invocationState?: InvocationState
 	pluginManager?: PluginLifecycleManager
@@ -48,6 +54,13 @@ export class ToolExecutor {
 	private log: Logger
 	private workingStateManager?: WorkingStateManager
 	private probes: ProbeRegistry
+	private readonly readPaths: Set<string> = new Set()
+	private readonly fileReadTracker: FileReadTracker = {
+		recordRead: (key: string) => {
+			this.readPaths.add(key)
+		},
+		hasRead: (key: string) => this.readPaths.has(key),
+	}
 
 	constructor(
 		config: ToolExecutorConfig,
@@ -83,11 +96,38 @@ export class ToolExecutor {
 			tools: toolCalls.map((tc) => tc.function.name),
 		})
 
-		const toolContext = this.buildToolContext()
-
-		const results = await Promise.all(
-			toolCalls.map((toolCall) => this.executeSingle(toolCall, toolContext)),
-		)
+		// One context per call so each execution can see its own
+		// `toolUseId`. The base context is built once; we spread + add
+		// per-call to keep allocations cheap.
+		const baseContext = this.buildToolContext()
+
+		// Respect each tool's `concurrencySafe` flag. Read-only tools
+		// (ls/grep/glob/…) run in parallel; tools that mutate shared state
+		// (edit/write/append/bash — `concurrencySafe: false`) are serialized in
+		// a single chain, so e.g. several `edit` calls to the SAME file in one
+		// turn apply one-after-another instead of racing read→modify→write
+		// (which let the last writer clobber the rest). Results are written by
+		// index to preserve the original tool-call order.
+		const results: Array<{ toolCallId: string; output: string }> = new Array(toolCalls.length)
+		const parallel: Promise<void>[] = []
+		let serial: Promise<void> = Promise.resolve()
+		toolCalls.forEach((toolCall, i) => {
+			const ctx = { ...baseContext, toolUseId: toolCall.id }
+			const run = async () => {
+				results[i] = await this.executeSingle(toolCall, ctx)
+			}
+			let input: unknown = {}
+			try {
+				input = JSON.parse(toolCall.function.arguments || '{}')
+			} catch {
+				// non-JSON args → treat as unsafe (serialize), the conservative path
+			}
+			const safe =
+				this.config.tools.get(toolCall.function.name)?.isConcurrencySafe?.(input) === true
+			if (safe) parallel.push(run())
+			else serial = serial.then(run)
+		})
+		await Promise.all([...parallel, serial])
 
 		const messages: Message[] = results.map((r) => createToolMessage(r.output, r.toolCallId))
 
@@ -108,19 +148,38 @@ export class ToolExecutor {
 			},
 			invocationState: this.config.invocationState,
 			toolRegistry: this.config.tools,
+			allowedTools: this.config.allowedTools,
 			sandbox: this.config.sandbox,
+			fileReadTracker: this.fileReadTracker,
 		}
 	}
 
 	private async executeSingle(
-		toolCall: {
-			id: string
-			type: string
-			function: { name: string; arguments: string }
-		},
+		toolCall: ToolCall,
 		toolContext: ToolContext,
 	): Promise<{ toolCallId: string; output: string }> {
 		const toolName = toolCall.function.name
+
+		if (toolCall.metadata?.inputTruncated === true) {
+			const message = truncatedToolInputMessage(toolName)
+			await this.emitEvent({
+				type: 'tool_executing',
+				runId: this.config.runId,
+				toolUseId: toolCall.id,
+				toolName,
+				input: {},
+			})
+			await this.emitEvent({
+				type: 'tool_completed',
+				runId: this.config.runId,
+				toolUseId: toolCall.id,
+				toolName,
+				result: message,
+				isError: true,
+			})
+			return { toolCallId: toolCall.id, output: message }
+		}
+
 		let input: unknown
 
 		try {
@@ -238,7 +297,7 @@ export class ToolExecutor {
 
 		const rawOutput = result.success
 			? result.output
-			: `Error: ${result.error ?? 'Tool execution failed'}`
+			: formatFailedToolOutput(result.output, result.error)
 
 		let output = result.success ? this.maybeCompress(toolName, rawOutput) : rawOutput
 
@@ -430,3 +489,13 @@ export class ToolExecutor {
 		return compressed
 	}
 }
+
+function formatFailedToolOutput(output: string | undefined, error: string | undefined): string {
+	const errorText = `Error: ${error ?? 'Tool execution failed'}`
+	if (!output || output.trim().length === 0) return errorText
+	return `${output}\n\n${errorText}`
+}
+
+function truncatedToolInputMessage(toolName: string): string {
+	return `Error: Tool "${toolName}" call was cut off while the model was streaming JSON arguments. The tool was NOT executed. Retry with a much shorter input. Self-budget any content/newStr payload under 12000 characters before calling file tools. For long files, create a short opening with write, then extend it with edit using insertLine: "end" in bounded section chunks; for delegated work, pass a shared workspace filename/reference instead of embedding the content in the tool call.`
+}

package/src/runtime/query/index.ts

@@ -16,6 +16,7 @@ import { buildTaskTools } from '../../tools/task/index.js'
 import type { AdvisoryConfig } from '../../types/advisory/index.js'
 import type { AgentRuntimeContext, RuntimeToolOverrides } from '../../types/agent/base.js'
 import type { AgentContextLevel } from '../../types/agent/factory.js'
+import type { WorkingMemoryProvider } from '../../types/agent/working-memory.js'
 import {
 	type CheckpointId,
 	type ResumeHandler,
@@ -42,6 +43,8 @@ import { RunContextFactory } from './context.js'
 import { EventTranslator } from './events.js'
 import { GuardCoordinator } from './guard.js'
 import { IterationOrchestrator } from './iteration/index.js'
+import { isCompactionMessage } from './iteration/phases/compaction.js'
+import { isWorkingMemoryMessage } from './iteration/phases/working-memory.js'
 import { applyLifecycleHookResults } from './plugin-hooks.js'
 import { PromptBuilder } from './prompt.js'
 import type { PromptSegments } from './prompt.js'
@@ -127,6 +130,15 @@ export interface QueryParams {
 
 	compactionConfig?: CompactionConfig
 
+	/**
+	 * Optional neutral working-memory seam. When set, the iteration loop
+	 * re-renders the provider's string into a single pinned leading system
+	 * message every turn (the primacy-edge, compaction-preserved slot).
+	 * Absent ⇒ `refreshWorkingMemory` early-returns and the run path is
+	 * byte-identical.
+	 */
+	workingMemoryProvider?: WorkingMemoryProvider
+
 	agentBus?: import('../../bus/index.js').AgentBus
 
 	verificationGate?: VerificationGateConfig
@@ -187,7 +199,15 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		})
 
 		if (decision.action === 'approve_plan') {
-			return { approved: true }
+			// Optional approve-with-edits channel: the host may attach
+			// feedback to an approval. `PlanApprovalResponse.feedback`
+			// already exists on the type; threading it through lets the
+			// coordinator's approve_plan tool surface the user's edits in
+			// the same tool_result that unblocks the park. Bare approvals
+			// stay byte-identical (`{ approved: true }`).
+			return decision.feedback
+				? { approved: true, feedback: decision.feedback }
+				: { approved: true }
 		}
 		if (decision.action === 'reject_plan') {
 			return { approved: false, feedback: decision.feedback }
@@ -224,6 +244,8 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		}
 	}
 
+	const effectiveAllowedTools = withDeferredDiscoveryTool(params.tools, params.allowedTools)
+
 	const toolExecutor = ToolingBootstrap.init(
 		{
 			tools: params.tools,
@@ -232,6 +254,7 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 			permissionMode: ctx.permissionMode,
 			env: params.runConfig.env ?? {},
 			abortSignal: ctx.abortController.signal,
+			allowedTools: effectiveAllowedTools,
 			invocationState: params.invocationState,
 			pluginManager: params.pluginManager,
 		},
@@ -252,7 +275,7 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		skills: params.skills,
 		basePrompt: params.basePrompt,
 		tools: params.tools,
-		allowedTools: params.allowedTools,
+		allowedTools: effectiveAllowedTools,
 		runtimeContext: params.runtimeContext,
 	})
 
@@ -312,13 +335,14 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 			provider: params.provider,
 			runConfig: params.runConfig,
 			tools: params.tools,
-			allowedTools: params.allowedTools,
+			allowedTools: effectiveAllowedTools,
 			taskGateway: params.taskGateway,
 			taskStore: params.taskStore,
 			launchedTasks: params.launchedTasks,
 			advisoryCtx,
 			compactionConfig: params.compactionConfig,
 			workingStateManager,
+			workingMemoryProvider: params.workingMemoryProvider,
 			agentBus: params.agentBus,
 			verificationGate: verificationGate,
 			pluginManager: params.pluginManager,
@@ -370,7 +394,7 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 				skills: params.skills,
 				basePrompt: contextLevel === 'full' ? params.basePrompt : undefined,
 				tools: params.tools,
-				allowedTools: params.allowedTools,
+				allowedTools: effectiveAllowedTools,
 				runtimeContext: params.runtimeContext,
 			}
 
@@ -405,7 +429,18 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 
 				pushSystemMessages()
 				for (const msg of checkpoint.messages) {
-					if (msg.role === 'system') continue
+					if (msg.role === 'system') {
+						// Re-push the FRESH static/dynamic floor (done above) but PRESERVE
+						// the two system messages that carry irreplaceable run state: the
+						// `[COMPACTED CONTEXT]` summary is the only surviving record of the
+						// older history a compaction pass deleted, and the working-memory
+						// slot pins the produced-artifact ledger. Dropping every system
+						// message on restore silently lost both on resume.
+						if (isCompactionMessage(msg.content) || isWorkingMemoryMessage(msg.content)) {
+							ctx.runMgr.pushMessage(msg)
+						}
+						continue
+					}
 					ctx.runMgr.pushMessage(msg)
 				}
 			} else if (params.continuationMode) {
@@ -536,3 +571,21 @@ export async function drainQuery(
 
 	return result.value
 }
+
+function withDeferredDiscoveryTool(
+	tools: ToolRegistryContract,
+	allowedTools?: string[],
+): string[] | undefined {
+	if (!allowedTools) return undefined
+	if (allowedTools.includes(SearchToolsTool.name)) return allowedTools
+
+	const allowedHasDeferred = allowedTools.some(
+		(name) => tools.has(name) && tools.getAvailability(name) === 'deferred',
+	)
+	if (!allowedHasDeferred) return allowedTools
+
+	if (!tools.has(SearchToolsTool.name)) return allowedTools
+	if (tools.getAvailability(SearchToolsTool.name) !== 'active') return allowedTools
+
+	return [...allowedTools, SearchToolsTool.name]
+}