@namzu/sdk 0.1.1 → 0.1.2

package/src/runtime/query/index.ts

@@ -1,321 +1,319 @@
-import type {
-  AgentRun,
-  AgentRunConfig,
-  RunEvent,
-  RunEventListener,
-} from '../../types/run/index.js'
-import type { LLMProvider } from '../../types/provider/index.js'
-import type { ModelPricing } from '../../utils/cost.js'
-import type { AgentPersona } from '../../types/persona/index.js'
-import type { Skill } from '../../types/skills/index.js'
+import { getTracer } from '../../provider/telemetry/setup.js'
 import type { ToolRegistry } from '../../registry/tool/execute.js'
-import type { ResumeHandler, CheckpointId } from '../../types/hitl/index.js'
-import type { ThreadId, RunId } from '../../types/ids/index.js'
-import type { AgentContextLevel } from '../../types/agent/factory.js'
-import type { RuntimeToolOverrides } from '../../types/agent/base.js'
-import type { TaskStore } from '../../types/task/index.js'
-import type { ContextCache } from './context-cache.js'
-import { buildTaskTools } from '../../tools/task/index.js'
+import { GENAI, NAMZU, agentSessionSpanName } from '../../telemetry/attributes.js'
 import { SearchToolsTool } from '../../tools/builtins/search-tools.js'
+import { buildTaskTools } from '../../tools/task/index.js'
+import type { RuntimeToolOverrides } from '../../types/agent/base.js'
+import type { AgentContextLevel } from '../../types/agent/factory.js'
+import type { CheckpointId, ResumeHandler } from '../../types/hitl/index.js'
 import { autoApproveHandler } from '../../types/hitl/index.js'
+import type { RunId, ThreadId } from '../../types/ids/index.js'
 import { type Message, createSystemMessage } from '../../types/message/index.js'
-import { getTracer } from '../../provider/telemetry/setup.js'
-import {
-  GENAI,
-  NAMZU,
-  agentSessionSpanName,
-} from '../../telemetry/attributes.js'
+import type { AgentPersona } from '../../types/persona/index.js'
+import type { LLMProvider } from '../../types/provider/index.js'
+import type { AgentRun, AgentRunConfig, RunEvent, RunEventListener } from '../../types/run/index.js'
+import type { Skill } from '../../types/skills/index.js'
+import type { TaskStore } from '../../types/task/index.js'
+import type { ModelPricing } from '../../utils/cost.js'
+import { CheckpointManager } from './checkpoint.js'
+import type { ContextCache } from './context-cache.js'
 import { RunContextFactory } from './context.js'
-import { PromptBuilder } from './prompt.js'
-import { ToolingBootstrap } from './tooling.js'
-import { GuardCoordinator } from './guard.js'
 import { EventTranslator } from './events.js'
+import { GuardCoordinator } from './guard.js'
 import { IterationOrchestrator } from './iteration/index.js'
+import { PromptBuilder } from './prompt.js'
 import { ResultAssembler } from './result.js'
-import { CheckpointManager } from './checkpoint.js'
+import { ToolingBootstrap } from './tooling.js'
 
 export interface QueryParams {
-  systemPrompt?: string
-  persona?: AgentPersona
-  skills?: Skill[]
-  basePrompt?: string
-  provider: LLMProvider
-  tools: ToolRegistry
-  sessionConfig: AgentRunConfig
-  allowedTools?: string[]
-  agentId: string
-  agentName: string
-  workingDirectory?: string
-  pricing?: ModelPricing
-  enableActivityTracking?: boolean
-  messages: Message[]
-  signal?: AbortSignal
-  resumeHandler: ResumeHandler
-  resumeFromCheckpoint?: CheckpointId
+	systemPrompt?: string
+	persona?: AgentPersona
+	skills?: Skill[]
+	basePrompt?: string
+	provider: LLMProvider
+	tools: ToolRegistry
+	sessionConfig: AgentRunConfig
+	allowedTools?: string[]
+	agentId: string
+	agentName: string
+	workingDirectory?: string
+	pricing?: ModelPricing
+	enableActivityTracking?: boolean
+	messages: Message[]
+	signal?: AbortSignal
+	resumeHandler: ResumeHandler
+	resumeFromCheckpoint?: CheckpointId
 
-  threadId: ThreadId
+	threadId: ThreadId
 
-  runId?: RunId
+	runId?: RunId
 
-  parentRunId?: RunId
+	parentRunId?: RunId
 
-  depth?: number
+	depth?: number
 
-  contextCache?: ContextCache
+	contextCache?: ContextCache
 
-  contextLevel?: AgentContextLevel
+	contextLevel?: AgentContextLevel
 
-  continuationMode?: boolean
+	continuationMode?: boolean
 
-  taskStore?: TaskStore
+	taskStore?: TaskStore
 
-  runtimeToolOverrides?: RuntimeToolOverrides
+	runtimeToolOverrides?: RuntimeToolOverrides
 
-  taskGateway?: import('../../types/agent/gateway.js').TaskGateway
+	taskGateway?: import('../../types/agent/gateway.js').TaskGateway
 
-  launchedTasks?: Map<import('../../types/ids/index.js').TaskId, import('./iteration/phases/context.js').LaunchedTaskMeta>
+	launchedTasks?: Map<
+		import('../../types/ids/index.js').TaskId,
+		import('./iteration/phases/context.js').LaunchedTaskMeta
+	>
 
-  onContextCreated?: (ctx: { planManager: import('../../manager/plan/lifecycle.js').PlanManager }) => void
+	onContextCreated?: (ctx: {
+		planManager: import('../../manager/plan/lifecycle.js').PlanManager
+	}) => void
 }
 
-export async function* query(
-  params: QueryParams,
-): AsyncGenerator<RunEvent, AgentRun> {
-  const ctx = RunContextFactory.build({
-    agentId: params.agentId,
-    agentName: params.agentName,
-    sessionConfig: params.sessionConfig,
-    provider: params.provider,
-    workingDirectory: params.workingDirectory,
-    pricing: params.pricing,
-    enableActivityTracking: params.enableActivityTracking,
-    messages: params.messages,
-    signal: params.signal,
-    threadId: params.threadId,
-    runId: params.runId,
-    parentRunId: params.parentRunId,
-    depth: params.depth,
-  })
-
-  ctx.planManager.setApprovalHandler(async (request) => {
-    const decision = await params.resumeHandler({
-      type: 'plan_approval',
-      runId: ctx.runId,
-      checkpointId: `cp_plan_${request.planId}` as import('../../types/ids/index.js').CheckpointId,
-      plan: {
-        planId: request.planId,
-        title: request.title,
-        steps: request.steps.map((s, i) => ({
-          id: s.id,
-          description: s.description,
-          toolName: s.toolName,
-          dependsOn: s.dependsOn,
-          order: s.order ?? i + 1,
-        })),
-        summary: request.summary,
-      },
-    })
-
-    if (decision.action === 'approve_plan') {
-      return { approved: true }
-    }
-    if (decision.action === 'reject_plan') {
-      return { approved: false, feedback: decision.feedback }
-    }
-
-    return { approved: false, feedback: `Action: ${decision.action}` }
-  })
-
-  params.onContextCreated?.({ planManager: ctx.planManager })
-
-  const eventTranslator = new EventTranslator(ctx.sessionMgr)
-  eventTranslator.wireActivityStore(ctx.activityStore, ctx.runId)
-  eventTranslator.wirePlanManager(ctx.planManager, ctx.runId)
-  const unsubscribeTaskStore = params.taskStore
-    ? eventTranslator.wireTaskStore(params.taskStore, ctx.runId)
-    : undefined
-
-  if (params.taskStore) {
-    const taskTools = buildTaskTools(params.taskStore, ctx.runId)
-    const overrides = params.runtimeToolOverrides
-    for (const tool of taskTools) {
-      const override = overrides?.[tool.name]
-      if (override === 'disabled') continue
-      params.tools.register(tool, override ?? 'deferred')
-    }
-  }
-
-  if (!params.tools.has(SearchToolsTool.name)) {
-    const hasDeferred = params.tools.listNames().some(
-      (n) => params.tools.getAvailability(n) === 'deferred',
-    )
-    if (hasDeferred) {
-      params.tools.register(SearchToolsTool)
-    }
-  }
-
-  const toolExecutor = ToolingBootstrap.init(
-    {
-      tools: params.tools,
-      runId: ctx.runId,
-      workingDirectory: ctx.cwd,
-      permissionMode: ctx.permissionMode,
-      env: params.sessionConfig.env ?? {},
-      abortSignal: ctx.abortController.signal,
-    },
-    ctx.activityStore,
-    eventTranslator.emitEvent,
-    ctx.log,
-  )
-
-  const promptBuilder = new PromptBuilder({
-    systemPrompt: params.systemPrompt,
-    persona: params.persona,
-    skills: params.skills,
-    basePrompt: params.basePrompt,
-    tools: params.tools,
-    allowedTools: params.allowedTools,
-  })
-
-  const guard = new GuardCoordinator({
-    tokenBudget: params.sessionConfig.tokenBudget,
-    timeoutMs: params.sessionConfig.timeoutMs,
-    costLimitUsd: params.sessionConfig.costLimitUsd,
-    maxIterations: params.sessionConfig.maxIterations,
-  })
-
-  const checkpointMgr = new CheckpointManager(ctx.sessionMgr.getRunStore())
-
-  const resultAssembler = new ResultAssembler({
-    sessionMgr: ctx.sessionMgr,
-    planManager: ctx.planManager,
-    activityStore: ctx.activityStore,
-    log: ctx.log,
-    emitEvent: eventTranslator.emitEvent,
-    drainPending: () => eventTranslator.drainPending(),
-  })
-
-  const iterationOrchestrator = new IterationOrchestrator(
-    {
-      provider: params.provider,
-      sessionConfig: params.sessionConfig,
-      tools: params.tools,
-      allowedTools: params.allowedTools,
-      taskGateway: params.taskGateway,
-      taskStore: params.taskStore,
-      launchedTasks: params.launchedTasks,
-    },
-    ctx.sessionMgr,
-    toolExecutor,
-    guard,
-    ctx.activityStore,
-    eventTranslator.emitEvent,
-    () => eventTranslator.drainPending(),
-    ctx.abortController,
-    ctx.log,
-    params.resumeHandler,
-    checkpointMgr,
-    ctx.planManager,
-  )
-
-  const tracer = getTracer()
-
-  return yield* (async function* (): AsyncGenerator<RunEvent, AgentRun> {
-    const rootSpan = tracer.startSpan(agentSessionSpanName(params.agentName))
-    rootSpan.setAttributes({
-      [NAMZU.SESSION_ID]: ctx.sessionMgr.id,
-      [GENAI.AGENT_NAME]: params.agentName,
-      [GENAI.AGENT_ID]: params.agentId,
-      [GENAI.REQUEST_MODEL]: params.sessionConfig.model,
-      [GENAI.SYSTEM]: params.provider.id,
-    })
-
-    try {
-      await ctx.sessionMgr.init()
-
-      ctx.log.info('Starting query', {
-        runId: ctx.sessionMgr.id,
-        agent: params.agentName,
-        model: params.sessionConfig.model,
-        tokenBudget: params.sessionConfig.tokenBudget,
-        activityTracking: ctx.activityStore.enabled,
-        permissionMode: ctx.permissionMode,
-        resumeFromCheckpoint: params.resumeFromCheckpoint ?? null,
-      })
-
-      const contextLevel = params.contextLevel ?? 'full'
-      const assembledPrompt = params.contextCache
-        ? params.contextCache.getSystemPrompt({
-            systemPrompt: params.systemPrompt,
-            persona: params.persona,
-            skills: params.skills,
-            basePrompt: contextLevel === 'full' ? params.basePrompt : undefined,
-            tools: params.tools,
-            allowedTools: params.allowedTools,
-          })
-        : promptBuilder.build(contextLevel, params.workingDirectory)
-
-      if (params.resumeFromCheckpoint) {
-        const checkpoint = await checkpointMgr.restore(params.resumeFromCheckpoint)
-        await eventTranslator.emitEvent({
-          type: 'run_resuming',
-          runId: ctx.sessionMgr.id,
-          fromCheckpointId: checkpoint.id,
-        })
-        yield* eventTranslator.drainPending()
-
-        ctx.sessionMgr.pushMessage(createSystemMessage(assembledPrompt))
-        for (const msg of checkpoint.messages) {
-          if (msg.role === 'system') continue
-          ctx.sessionMgr.pushMessage(msg)
-        }
-      } else if (params.continuationMode) {
-        for (const msg of params.messages) {
-          ctx.sessionMgr.pushMessage(msg)
-        }
-      } else {
-        ctx.sessionMgr.pushMessage(createSystemMessage(assembledPrompt))
-        for (const msg of params.messages) {
-          if (msg.role === 'system') continue
-          ctx.sessionMgr.pushMessage(msg)
-        }
-      }
-
-      ctx.sessionMgr.markRunning()
-      await eventTranslator.emitEvent({ type: 'run_started', runId: ctx.sessionMgr.id, systemPrompt: assembledPrompt })
-      yield* eventTranslator.drainPending()
-
-      yield* iterationOrchestrator.runLoop()
-
-      yield* resultAssembler.completeRun(rootSpan)
-    } catch (err) {
-      yield* resultAssembler.handleError(err, rootSpan)
-    } finally {
-      unsubscribeTaskStore?.()
-      rootSpan.end()
-    }
-
-    return await resultAssembler.finalize()
-  })()
+export async function* query(params: QueryParams): AsyncGenerator<RunEvent, AgentRun> {
+	const ctx = RunContextFactory.build({
+		agentId: params.agentId,
+		agentName: params.agentName,
+		sessionConfig: params.sessionConfig,
+		provider: params.provider,
+		workingDirectory: params.workingDirectory,
+		pricing: params.pricing,
+		enableActivityTracking: params.enableActivityTracking,
+		messages: params.messages,
+		signal: params.signal,
+		threadId: params.threadId,
+		runId: params.runId,
+		parentRunId: params.parentRunId,
+		depth: params.depth,
+	})
+
+	ctx.planManager.setApprovalHandler(async (request) => {
+		const decision = await params.resumeHandler({
+			type: 'plan_approval',
+			runId: ctx.runId,
+			checkpointId: `cp_plan_${request.planId}` as import('../../types/ids/index.js').CheckpointId,
+			plan: {
+				planId: request.planId,
+				title: request.title,
+				steps: request.steps.map((s, i) => ({
+					id: s.id,
+					description: s.description,
+					toolName: s.toolName,
+					dependsOn: s.dependsOn,
+					order: s.order ?? i + 1,
+				})),
+				summary: request.summary,
+			},
+		})
+
+		if (decision.action === 'approve_plan') {
+			return { approved: true }
+		}
+		if (decision.action === 'reject_plan') {
+			return { approved: false, feedback: decision.feedback }
+		}
+
+		return { approved: false, feedback: `Action: ${decision.action}` }
+	})
+
+	params.onContextCreated?.({ planManager: ctx.planManager })
+
+	const eventTranslator = new EventTranslator(ctx.sessionMgr)
+	eventTranslator.wireActivityStore(ctx.activityStore, ctx.runId)
+	eventTranslator.wirePlanManager(ctx.planManager, ctx.runId)
+	const unsubscribeTaskStore = params.taskStore
+		? eventTranslator.wireTaskStore(params.taskStore, ctx.runId)
+		: undefined
+
+	if (params.taskStore) {
+		const taskTools = buildTaskTools(params.taskStore, ctx.runId)
+		const overrides = params.runtimeToolOverrides
+		for (const tool of taskTools) {
+			const override = overrides?.[tool.name]
+			if (override === 'disabled') continue
+			params.tools.register(tool, override ?? 'deferred')
+		}
+	}
+
+	if (!params.tools.has(SearchToolsTool.name)) {
+		const hasDeferred = params.tools
+			.listNames()
+			.some((n) => params.tools.getAvailability(n) === 'deferred')
+		if (hasDeferred) {
+			params.tools.register(SearchToolsTool)
+		}
+	}
+
+	const toolExecutor = ToolingBootstrap.init(
+		{
+			tools: params.tools,
+			runId: ctx.runId,
+			workingDirectory: ctx.cwd,
+			permissionMode: ctx.permissionMode,
+			env: params.sessionConfig.env ?? {},
+			abortSignal: ctx.abortController.signal,
+		},
+		ctx.activityStore,
+		eventTranslator.emitEvent,
+		ctx.log,
+	)
+
+	const promptBuilder = new PromptBuilder({
+		systemPrompt: params.systemPrompt,
+		persona: params.persona,
+		skills: params.skills,
+		basePrompt: params.basePrompt,
+		tools: params.tools,
+		allowedTools: params.allowedTools,
+	})
+
+	const guard = new GuardCoordinator({
+		tokenBudget: params.sessionConfig.tokenBudget,
+		timeoutMs: params.sessionConfig.timeoutMs,
+		costLimitUsd: params.sessionConfig.costLimitUsd,
+		maxIterations: params.sessionConfig.maxIterations,
+	})
+
+	const checkpointMgr = new CheckpointManager(ctx.sessionMgr.getRunStore())
+
+	const resultAssembler = new ResultAssembler({
+		sessionMgr: ctx.sessionMgr,
+		planManager: ctx.planManager,
+		activityStore: ctx.activityStore,
+		log: ctx.log,
+		emitEvent: eventTranslator.emitEvent,
+		drainPending: () => eventTranslator.drainPending(),
+	})
+
+	const iterationOrchestrator = new IterationOrchestrator(
+		{
+			provider: params.provider,
+			sessionConfig: params.sessionConfig,
+			tools: params.tools,
+			allowedTools: params.allowedTools,
+			taskGateway: params.taskGateway,
+			taskStore: params.taskStore,
+			launchedTasks: params.launchedTasks,
+		},
+		ctx.sessionMgr,
+		toolExecutor,
+		guard,
+		ctx.activityStore,
+		eventTranslator.emitEvent,
+		() => eventTranslator.drainPending(),
+		ctx.abortController,
+		ctx.log,
+		params.resumeHandler,
+		checkpointMgr,
+		ctx.planManager,
+	)
+
+	const tracer = getTracer()
+
+	return yield* (async function* (): AsyncGenerator<RunEvent, AgentRun> {
+		const rootSpan = tracer.startSpan(agentSessionSpanName(params.agentName))
+		rootSpan.setAttributes({
+			[NAMZU.SESSION_ID]: ctx.sessionMgr.id,
+			[GENAI.AGENT_NAME]: params.agentName,
+			[GENAI.AGENT_ID]: params.agentId,
+			[GENAI.REQUEST_MODEL]: params.sessionConfig.model,
+			[GENAI.SYSTEM]: params.provider.id,
+		})
+
+		try {
+			await ctx.sessionMgr.init()
+
+			ctx.log.info('Starting query', {
+				runId: ctx.sessionMgr.id,
+				agent: params.agentName,
+				model: params.sessionConfig.model,
+				tokenBudget: params.sessionConfig.tokenBudget,
+				activityTracking: ctx.activityStore.enabled,
+				permissionMode: ctx.permissionMode,
+				resumeFromCheckpoint: params.resumeFromCheckpoint ?? null,
+			})
+
+			const contextLevel = params.contextLevel ?? 'full'
+			const assembledPrompt = params.contextCache
+				? params.contextCache.getSystemPrompt({
+						systemPrompt: params.systemPrompt,
+						persona: params.persona,
+						skills: params.skills,
+						basePrompt: contextLevel === 'full' ? params.basePrompt : undefined,
+						tools: params.tools,
+						allowedTools: params.allowedTools,
+					})
+				: promptBuilder.build(contextLevel, params.workingDirectory)
+
+			if (params.resumeFromCheckpoint) {
+				const checkpoint = await checkpointMgr.restore(params.resumeFromCheckpoint)
+				await eventTranslator.emitEvent({
+					type: 'run_resuming',
+					runId: ctx.sessionMgr.id,
+					fromCheckpointId: checkpoint.id,
+				})
+				yield* eventTranslator.drainPending()
+
+				ctx.sessionMgr.pushMessage(createSystemMessage(assembledPrompt))
+				for (const msg of checkpoint.messages) {
+					if (msg.role === 'system') continue
+					ctx.sessionMgr.pushMessage(msg)
+				}
+			} else if (params.continuationMode) {
+				for (const msg of params.messages) {
+					ctx.sessionMgr.pushMessage(msg)
+				}
+			} else {
+				ctx.sessionMgr.pushMessage(createSystemMessage(assembledPrompt))
+				for (const msg of params.messages) {
+					if (msg.role === 'system') continue
+					ctx.sessionMgr.pushMessage(msg)
+				}
+			}
+
+			ctx.sessionMgr.markRunning()
+			await eventTranslator.emitEvent({
+				type: 'run_started',
+				runId: ctx.sessionMgr.id,
+				systemPrompt: assembledPrompt,
+			})
+			yield* eventTranslator.drainPending()
+
+			yield* iterationOrchestrator.runLoop()
+
+			yield* resultAssembler.completeRun(rootSpan)
+		} catch (err) {
+			yield* resultAssembler.handleError(err, rootSpan)
+		} finally {
+			unsubscribeTaskStore?.()
+			rootSpan.end()
+		}
+
+		return await resultAssembler.finalize()
+	})()
 }
 
 export async function drainQuery(
-  params: Omit<QueryParams, 'resumeHandler'> & { resumeHandler?: ResumeHandler },
-  listener?: RunEventListener,
+	params: Omit<QueryParams, 'resumeHandler'> & { resumeHandler?: ResumeHandler },
+	listener?: RunEventListener,
 ): Promise<AgentRun> {
-  const fullParams: QueryParams = {
-    ...params,
-    resumeHandler: params.resumeHandler ?? autoApproveHandler,
-  }
-  const gen = query(fullParams)
-  let result = await gen.next()
-
-  while (!result.done) {
-    if (listener) {
-      await listener(result.value)
-    }
-    result = await gen.next()
-  }
-
-  return result.value
+	const fullParams: QueryParams = {
+		...params,
+		resumeHandler: params.resumeHandler ?? autoApproveHandler,
+	}
+	const gen = query(fullParams)
+	let result = await gen.next()
+
+	while (!result.done) {
+		if (listener) {
+			await listener(result.value)
+		}
+		result = await gen.next()
+	}
+
+	return result.value
 }