@minpeter/pss-runtime 0.1.0-next.1 → 0.1.0-next.2

package/dist/llm-tool-execution.js

@@ -0,0 +1,126 @@
+//#region src/llm-tool-execution.ts
+const toolCallIdPrefix = "call_";
+const publicToolCallIdPattern = /^call[-_]/;
+var ToolExecutionNeedsRecoveryError = class extends Error {
+	idempotencyKey;
+	status = "needs-recovery";
+	toolCallId;
+	toolName;
+	constructor(checkpoint) {
+		super(`Tool ${checkpoint.toolName} requires manual recovery for ${checkpoint.idempotencyKey}`);
+		this.idempotencyKey = checkpoint.idempotencyKey;
+		this.name = "ToolExecutionNeedsRecoveryError";
+		this.toolCallId = checkpoint.toolCallId;
+		this.toolName = checkpoint.toolName;
+	}
+};
+function persistedToolExecutionCheckpoint(checkpoint) {
+	return {
+		attempt: checkpoint.attempt,
+		idempotencyKey: checkpoint.idempotencyKey,
+		policy: checkpoint.policy,
+		toolCallId: checkpoint.toolCallId,
+		toolName: checkpoint.toolName
+	};
+}
+function normalizeToolCallIds(tools, toolCallIds, toolExecution) {
+	if (!tools) return;
+	return Object.fromEntries(Object.entries(tools).map(([name, candidate]) => [name, wrapToolExecute(name, candidate, toolCallIds, toolExecution)]));
+}
+function rewriteMessageToolCallIds(message, toolCallIds) {
+	if (message.role === "assistant") return rewriteAssistantToolCallIds(message, toolCallIds);
+	if (message.role === "tool") return rewriteToolResultCallIds(message, toolCallIds);
+	return message;
+}
+function wrapToolExecute(toolName, toolDefinition, toolCallIds, toolExecution) {
+	if (!isExecutableToolDefinition(toolDefinition)) return toolDefinition;
+	const { execute } = toolDefinition;
+	if (!toolExecution) return {
+		...toolDefinition,
+		execute: (input, options) => execute(input, {
+			...options,
+			toolCallId: publicToolCallId(options.toolCallId, toolCallIds)
+		})
+	};
+	return {
+		...toolDefinition,
+		execute: async (input, options) => {
+			const toolCallId = publicToolCallId(options.toolCallId, toolCallIds);
+			const checkpoint = toolCheckpoint({
+				input,
+				policy: toolRetryPolicy(toolDefinition),
+				toolCallId,
+				toolExecution,
+				toolName
+			});
+			if ((await toolExecution.beforeTool?.(checkpoint))?.status === "needs-recovery") throw new ToolExecutionNeedsRecoveryError(checkpoint);
+			const output = await execute(input, {
+				...options,
+				attempt: checkpoint.attempt,
+				idempotencyKey: checkpoint.idempotencyKey,
+				retryPolicy: checkpoint.policy,
+				...options.abortSignal === void 0 ? {} : { signal: options.abortSignal },
+				toolCallId
+			});
+			await toolExecution.afterTool?.({
+				...checkpoint,
+				output
+			});
+			return output;
+		}
+	};
+}
+function isExecutableToolDefinition(value) {
+	return typeof value === "object" && value !== null && "execute" in value && typeof value.execute === "function";
+}
+function toolCheckpoint({ input, policy, toolCallId, toolExecution, toolName }) {
+	return {
+		attempt: toolExecution.attempt,
+		idempotencyKey: `${toolExecution.runId}:${toolCallId}`,
+		input,
+		policy,
+		toolCallId,
+		toolName
+	};
+}
+function toolRetryPolicy(toolDefinition) {
+	if (typeof toolDefinition === "object" && toolDefinition !== null && "retryPolicy" in toolDefinition && isToolRetryPolicy(toolDefinition.retryPolicy)) return toolDefinition.retryPolicy;
+	return "manual-recovery";
+}
+function isToolRetryPolicy(value) {
+	return value === "idempotent" || value === "manual-recovery" || value === "pure";
+}
+function rewriteAssistantToolCallIds(message, toolCallIds) {
+	if (typeof message.content === "string") return message;
+	return {
+		...message,
+		content: message.content.map((part) => "toolCallId" in part ? {
+			...part,
+			toolCallId: publicToolCallId(part.toolCallId, toolCallIds)
+		} : part)
+	};
+}
+function rewriteToolResultCallIds(message, toolCallIds) {
+	return {
+		...message,
+		content: message.content.map((part) => "toolCallId" in part ? {
+			...part,
+			toolCallId: publicToolCallId(part.toolCallId, toolCallIds)
+		} : part)
+	};
+}
+function publicToolCallId(toolCallId, toolCallIds) {
+	if (publicToolCallIdPattern.test(toolCallId)) return toolCallId;
+	const existing = toolCallIds.get(toolCallId);
+	if (existing) return existing;
+	const generated = createToolCallId();
+	toolCallIds.set(toolCallId, generated);
+	return generated;
+}
+function createToolCallId() {
+	return `${toolCallIdPrefix}${crypto.randomUUID().replaceAll("-", "")}`;
+}
+//#endregion
+export { ToolExecutionNeedsRecoveryError, normalizeToolCallIds, persistedToolExecutionCheckpoint, rewriteMessageToolCallIds };
+
+//# sourceMappingURL=llm-tool-execution.js.map

package/dist/llm-tool-execution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-tool-execution.js","names":[],"sources":["../src/llm-tool-execution.ts"],"sourcesContent":["import type { AssistantModelMessage, ToolModelMessage, ToolSet } from \"ai\";\nimport type { RuntimeLlmOutput } from \"./llm\";\n\nconst toolCallIdPrefix = \"call_\";\nconst publicToolCallIdPattern = /^call[-_]/;\n\ntype RuntimeLlmMessage = RuntimeLlmOutput[number];\n\nexport type RuntimeToolRetryPolicy = \"idempotent\" | \"manual-recovery\" | \"pure\";\n\nexport interface RuntimeToolExecutionCheckpointMetadata {\n  readonly attempt: number;\n  readonly idempotencyKey: string;\n  readonly policy: RuntimeToolRetryPolicy;\n  readonly toolCallId: string;\n  readonly toolName: string;\n}\n\nexport interface RuntimeToolExecutionCheckpoint\n  extends RuntimeToolExecutionCheckpointMetadata {\n  readonly input: unknown;\n}\n\nexport type RuntimePersistedToolExecutionCheckpoint =\n  RuntimeToolExecutionCheckpointMetadata;\n\nexport type RuntimeToolExecutionDecision =\n  | { readonly status: \"needs-recovery\" }\n  | undefined;\n\nexport interface RuntimeToolExecutionContext {\n  readonly afterTool?: (\n    checkpoint: RuntimeToolExecutionCheckpoint & { readonly output: unknown }\n  ) => Promise<void> | void;\n  readonly attempt: number;\n  readonly beforeTool?: (\n    checkpoint: RuntimeToolExecutionCheckpoint\n  ) => Promise<RuntimeToolExecutionDecision> | RuntimeToolExecutionDecision;\n  readonly runId: string;\n}\n\nexport class ToolExecutionNeedsRecoveryError extends Error {\n  readonly idempotencyKey: string;\n  readonly status = \"needs-recovery\";\n  readonly toolCallId: string;\n  readonly toolName: string;\n\n  constructor(checkpoint: RuntimeToolExecutionCheckpointMetadata) {\n    super(\n      `Tool ${checkpoint.toolName} requires manual recovery for ${checkpoint.idempotencyKey}`\n    );\n    this.idempotencyKey = checkpoint.idempotencyKey;\n    this.name = \"ToolExecutionNeedsRecoveryError\";\n    this.toolCallId = checkpoint.toolCallId;\n    this.toolName = checkpoint.toolName;\n  }\n}\n\nexport function persistedToolExecutionCheckpoint(\n  checkpoint: RuntimeToolExecutionCheckpointMetadata\n): RuntimePersistedToolExecutionCheckpoint {\n  return {\n    attempt: checkpoint.attempt,\n    idempotencyKey: checkpoint.idempotencyKey,\n    policy: checkpoint.policy,\n    toolCallId: checkpoint.toolCallId,\n    toolName: checkpoint.toolName,\n  };\n}\n\nexport function normalizeToolCallIds(\n  tools: ToolSet | undefined,\n  toolCallIds: Map<string, string>,\n  toolExecution: RuntimeToolExecutionContext | undefined\n): ToolSet | undefined {\n  if (!tools) {\n    return;\n  }\n\n  return Object.fromEntries(\n    Object.entries(tools).map(([name, candidate]) => [\n      name,\n      wrapToolExecute(name, candidate, toolCallIds, toolExecution),\n    ])\n  ) as ToolSet;\n}\n\nexport function rewriteMessageToolCallIds(\n  message: RuntimeLlmMessage,\n  toolCallIds: Map<string, string>\n): RuntimeLlmMessage {\n  if (message.role === \"assistant\") {\n    return rewriteAssistantToolCallIds(message, toolCallIds);\n  }\n\n  if (message.role === \"tool\") {\n    return rewriteToolResultCallIds(message, toolCallIds);\n  }\n\n  return message;\n}\n\nfunction wrapToolExecute(\n  toolName: string,\n  toolDefinition: unknown,\n  toolCallIds: Map<string, string>,\n  toolExecution: RuntimeToolExecutionContext | undefined\n): unknown {\n  if (!isExecutableToolDefinition(toolDefinition)) {\n    return toolDefinition;\n  }\n\n  const { execute } = toolDefinition;\n  if (!toolExecution) {\n    return {\n      ...toolDefinition,\n      execute: (input: unknown, options: ToolExecutionOptionsLike) =>\n        execute(input, {\n          ...options,\n          toolCallId: publicToolCallId(options.toolCallId, toolCallIds),\n        }),\n    };\n  }\n\n  return {\n    ...toolDefinition,\n    execute: async (input: unknown, options: ToolExecutionOptionsLike) => {\n      const toolCallId = publicToolCallId(options.toolCallId, toolCallIds);\n      const checkpoint = toolCheckpoint({\n        input,\n        policy: toolRetryPolicy(toolDefinition),\n        toolCallId,\n        toolExecution,\n        toolName,\n      });\n      const decision = await toolExecution.beforeTool?.(checkpoint);\n      if (decision?.status === \"needs-recovery\") {\n        throw new ToolExecutionNeedsRecoveryError(checkpoint);\n      }\n\n      const output = await execute(input, {\n        ...options,\n        attempt: checkpoint.attempt,\n        idempotencyKey: checkpoint.idempotencyKey,\n        retryPolicy: checkpoint.policy,\n        ...(options.abortSignal === undefined\n          ? {}\n          : { signal: options.abortSignal }),\n        toolCallId,\n      });\n      await toolExecution.afterTool?.({ ...checkpoint, output });\n      return output;\n    },\n  };\n}\n\nfunction isExecutableToolDefinition(value: unknown): value is {\n  readonly execute: (\n    input: unknown,\n    options: RuntimeToolExecutionOptionsLike | ToolExecutionOptionsLike\n  ) => unknown;\n} {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"execute\" in value &&\n    typeof value.execute === \"function\"\n  );\n}\n\ninterface ToolExecutionOptionsLike {\n  readonly abortSignal?: AbortSignal;\n  readonly toolCallId: string;\n}\n\ninterface RuntimeToolExecutionOptionsLike extends ToolExecutionOptionsLike {\n  readonly attempt: number;\n  readonly idempotencyKey: string;\n  readonly retryPolicy: RuntimeToolRetryPolicy;\n  readonly signal?: AbortSignal;\n}\n\nfunction toolCheckpoint({\n  input,\n  policy,\n  toolCallId,\n  toolExecution,\n  toolName,\n}: {\n  readonly input: unknown;\n  readonly policy: RuntimeToolRetryPolicy;\n  readonly toolCallId: string;\n  readonly toolExecution: RuntimeToolExecutionContext;\n  readonly toolName: string;\n}): RuntimeToolExecutionCheckpoint {\n  return {\n    attempt: toolExecution.attempt,\n    idempotencyKey: `${toolExecution.runId}:${toolCallId}`,\n    input,\n    policy,\n    toolCallId,\n    toolName,\n  };\n}\n\nfunction toolRetryPolicy(toolDefinition: unknown): RuntimeToolRetryPolicy {\n  if (\n    typeof toolDefinition === \"object\" &&\n    toolDefinition !== null &&\n    \"retryPolicy\" in toolDefinition &&\n    isToolRetryPolicy(toolDefinition.retryPolicy)\n  ) {\n    return toolDefinition.retryPolicy;\n  }\n\n  return \"manual-recovery\";\n}\n\nfunction isToolRetryPolicy(value: unknown): value is RuntimeToolRetryPolicy {\n  return (\n    value === \"idempotent\" || value === \"manual-recovery\" || value === \"pure\"\n  );\n}\n\nfunction rewriteAssistantToolCallIds(\n  message: AssistantModelMessage,\n  toolCallIds: Map<string, string>\n): AssistantModelMessage {\n  if (typeof message.content === \"string\") {\n    return message;\n  }\n\n  return {\n    ...message,\n    content: message.content.map((part) =>\n      \"toolCallId\" in part\n        ? {\n            ...part,\n            toolCallId: publicToolCallId(part.toolCallId, toolCallIds),\n          }\n        : part\n    ),\n  };\n}\n\nfunction rewriteToolResultCallIds(\n  message: ToolModelMessage,\n  toolCallIds: Map<string, string>\n): ToolModelMessage {\n  return {\n    ...message,\n    content: message.content.map((part) =>\n      \"toolCallId\" in part\n        ? {\n            ...part,\n            toolCallId: publicToolCallId(part.toolCallId, toolCallIds),\n          }\n        : part\n    ),\n  };\n}\n\nfunction publicToolCallId(\n  toolCallId: string,\n  toolCallIds: Map<string, string>\n): string {\n  if (publicToolCallIdPattern.test(toolCallId)) {\n    return toolCallId;\n  }\n\n  const existing = toolCallIds.get(toolCallId);\n  if (existing) {\n    return existing;\n  }\n\n  const generated = createToolCallId();\n  toolCallIds.set(toolCallId, generated);\n  return generated;\n}\n\nfunction createToolCallId(): string {\n  return `${toolCallIdPrefix}${crypto.randomUUID().replaceAll(\"-\", \"\")}`;\n}\n"],"mappings":"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"}

package/dist/llm.d.ts

@@ -1,32 +1,28 @@
-import { LanguageModel, ModelMessage, Tool, ToolExecutionOptions, ToolSet, generateText } from "ai";
+import { RuntimeToolExecutionCheckpoint, RuntimeToolExecutionCheckpointMetadata, RuntimeToolExecutionContext, RuntimeToolExecutionDecision, RuntimeToolRetryPolicy } from "./llm-tool-execution.js";
+import { LanguageModel, ModelMessage, ToolChoice, ToolSet, generateText } from "ai";
 
 //#region src/llm.d.ts
-type AgentToolExecutionOptions = ToolExecutionOptions<unknown>;
-type AgentToolExecute = NonNullable<Tool["execute"]>;
-type AgentToolChoice = "auto" | "required";
-type LlmOutput = Awaited<ReturnType<typeof generateText>>["responseMessages"];
-type LlmOutputPart = LlmOutput[number];
-interface LlmContext {
+type AgentToolChoice = ToolChoice<ToolSet>;
+type RuntimeLlmOutput = Awaited<ReturnType<typeof generateText>>["responseMessages"];
+type RuntimeLlmOutputPart = RuntimeLlmOutput[number];
+interface RuntimeLlmContext {
   history: readonly ModelMessage[];
   signal: AbortSignal;
+  toolExecution?: RuntimeToolExecutionContext;
 }
-type Llm = (context: LlmContext) => Promise<LlmOutput>;
-interface CreateLlmOptions {
+type RuntimeLlm = (context: RuntimeLlmContext) => Promise<RuntimeLlmOutput>;
+interface RuntimeCreateLlmOptions {
   instructions?: string;
   model: LanguageModel;
   toolChoice?: AgentToolChoice;
   tools?: ToolSet;
 }
-type RuntimeCreateLlmOptions = CreateLlmOptions;
-type RuntimeLlm = Llm;
-type RuntimeLlmContext = LlmContext;
-type RuntimeLlmOutput = LlmOutput;
 declare function createLlm({
   model,
   instructions,
   toolChoice,
   tools
-}: CreateLlmOptions): Llm;
+}: RuntimeCreateLlmOptions): RuntimeLlm;
 //#endregion
-export { AgentToolChoice, AgentToolExecute, AgentToolExecutionOptions, Llm, LlmOutputPart, RuntimeCreateLlmOptions, RuntimeLlm, RuntimeLlmContext, RuntimeLlmOutput, createLlm };
+export { AgentToolChoice, RuntimeCreateLlmOptions, RuntimeLlm, RuntimeLlmContext, RuntimeLlmOutput, RuntimeLlmOutputPart, createLlm };
 //# sourceMappingURL=llm.d.ts.map

package/dist/llm.js

@@ -1,16 +1,18 @@
+import { normalizeToolCallIds, rewriteMessageToolCallIds } from "./llm-tool-execution.js";
 import { generateText } from "ai";
 //#region src/llm.ts
 function createLlm({ model, instructions, toolChoice, tools }) {
-	return async ({ history, signal }) => {
+	return async ({ history, signal, toolExecution }) => {
+		const toolCallIds = /* @__PURE__ */ new Map();
 		const { responseMessages } = await generateText({
 			abortSignal: signal,
 			instructions,
 			messages: [...history],
 			model,
 			toolChoice,
-			tools
+			tools: normalizeToolCallIds(tools, toolCallIds, toolExecution)
 		});
-		return responseMessages;
+		return responseMessages.map((message) => rewriteMessageToolCallIds(message, toolCallIds));
 	};
 }
 //#endregion

package/dist/llm.js.map

@@ -1 +1 @@
-{"version":3,"file":"llm.js","names":[],"sources":["../src/llm.ts"],"sourcesContent":["import type {\n  LanguageModel,\n  ModelMessage,\n  Tool,\n  ToolExecutionOptions,\n  ToolSet,\n} from \"ai\";\nimport { generateText } from \"ai\";\n\nexport type AgentToolExecutionOptions = ToolExecutionOptions<unknown>;\nexport type AgentToolExecute = NonNullable<Tool[\"execute\"]>;\nexport type AgentToolChoice = \"auto\" | \"required\";\nexport type LlmOutput = Awaited<\n  ReturnType<typeof generateText>\n>[\"responseMessages\"];\nexport type LlmOutputPart = LlmOutput[number];\n\nexport interface LlmContext {\n  history: readonly ModelMessage[];\n  signal: AbortSignal;\n}\n\nexport type Llm = (context: LlmContext) => Promise<LlmOutput>;\n\nexport interface CreateLlmOptions {\n  instructions?: string;\n  model: LanguageModel;\n  toolChoice?: AgentToolChoice;\n  tools?: ToolSet;\n}\n\nexport type RuntimeCreateLlmOptions = CreateLlmOptions;\nexport type RuntimeLlm = Llm;\nexport type RuntimeLlmContext = LlmContext;\nexport type RuntimeLlmOutput = LlmOutput;\n\nexport function createLlm({\n  model,\n  instructions,\n  toolChoice,\n  tools,\n}: CreateLlmOptions): Llm {\n  return async ({ history, signal }) => {\n    const { responseMessages } = await generateText({\n      abortSignal: signal,\n      instructions,\n      messages: [...history],\n      model,\n      toolChoice,\n      tools,\n    });\n\n    return responseMessages;\n  };\n}\n"],"mappings":";;AAoCA,SAAgB,UAAU,EACxB,OACA,cACA,YACA,SACwB;CACxB,OAAO,OAAO,EAAE,SAAS,aAAa;EACpC,MAAM,EAAE,qBAAqB,MAAM,aAAa;GAC9C,aAAa;GACb;GACA,UAAU,CAAC,GAAG,OAAO;GACrB;GACA;GACA;EACF,CAAC;EAED,OAAO;CACT;AACF"}
+{"version":3,"file":"llm.js","names":[],"sources":["../src/llm.ts"],"sourcesContent":["import type { LanguageModel, ModelMessage, ToolChoice, ToolSet } from \"ai\";\nimport { generateText } from \"ai\";\nimport type { RuntimeToolExecutionContext } from \"./llm-tool-execution\";\nimport {\n  normalizeToolCallIds,\n  rewriteMessageToolCallIds,\n} from \"./llm-tool-execution\";\n\nexport type {\n  RuntimePersistedToolExecutionCheckpoint,\n  RuntimeToolExecutionCheckpoint,\n  RuntimeToolExecutionCheckpointMetadata,\n  RuntimeToolExecutionContext,\n  RuntimeToolExecutionDecision,\n  RuntimeToolRetryPolicy,\n} from \"./llm-tool-execution\";\n\nexport type AgentToolChoice = ToolChoice<ToolSet>;\nexport type RuntimeLlmOutput = Awaited<\n  ReturnType<typeof generateText>\n>[\"responseMessages\"];\nexport type RuntimeLlmOutputPart = RuntimeLlmOutput[number];\n\nexport interface RuntimeLlmContext {\n  history: readonly ModelMessage[];\n  signal: AbortSignal;\n  toolExecution?: RuntimeToolExecutionContext;\n}\n\nexport type RuntimeLlm = (\n  context: RuntimeLlmContext\n) => Promise<RuntimeLlmOutput>;\n\nexport interface RuntimeCreateLlmOptions {\n  instructions?: string;\n  model: LanguageModel;\n  toolChoice?: AgentToolChoice;\n  tools?: ToolSet;\n}\n\nexport function createLlm({\n  model,\n  instructions,\n  toolChoice,\n  tools,\n}: RuntimeCreateLlmOptions): RuntimeLlm {\n  return async ({ history, signal, toolExecution }) => {\n    const toolCallIds = new Map<string, string>();\n    const { responseMessages } = await generateText({\n      abortSignal: signal,\n      instructions,\n      messages: [...history],\n      model,\n      toolChoice,\n      tools: normalizeToolCallIds(tools, toolCallIds, toolExecution),\n    });\n\n    return responseMessages.map((message) =>\n      rewriteMessageToolCallIds(message, toolCallIds)\n    );\n  };\n}\n"],"mappings":";;;AAwCA,SAAgB,UAAU,EACxB,OACA,cACA,YACA,SACsC;CACtC,OAAO,OAAO,EAAE,SAAS,QAAQ,oBAAoB;EACnD,MAAM,8BAAc,IAAI,IAAoB;EAC5C,MAAM,EAAE,qBAAqB,MAAM,aAAa;GAC9C,aAAa;GACb;GACA,UAAU,CAAC,GAAG,OAAO;GACrB;GACA;GACA,OAAO,qBAAqB,OAAO,aAAa,aAAa;EAC/D,CAAC;EAED,OAAO,iBAAiB,KAAK,YAC3B,0BAA0B,SAAS,WAAW,CAChD;CACF;AACF"}

package/dist/plugins.d.ts

@@ -0,0 +1,20 @@
+import { RuntimeLlmContext } from "./llm.js";
+import { AgentEvent } from "./session/events.js";
+
+//#region src/plugins.d.ts
+type MaybePromise<T> = PromiseLike<T> | T;
+type AgentEventHistory = RuntimeLlmContext["history"];
+interface AgentEventContext {
+  readonly event: AgentEvent;
+  readonly history: AgentEventHistory;
+  readonly signal?: AbortSignal;
+}
+interface AgentPlugin {
+  readonly events?: {
+    readonly on?: (context: AgentEventContext) => MaybePromise<void>;
+  };
+  readonly name?: string;
+}
+//#endregion
+export { AgentEventContext, AgentPlugin };
+//# sourceMappingURL=plugins.d.ts.map

package/dist/plugins.js

@@ -0,0 +1,14 @@
+//#region src/plugins.ts
+function runEventPlugins(plugins, context) {
+	return runPluginHandlers(plugins, (plugin) => plugin.events?.on, context);
+}
+async function runPluginHandlers(plugins, handlerFor, context) {
+	for (const plugin of plugins) {
+		const handler = handlerFor(plugin);
+		if (handler) await handler(context);
+	}
+}
+//#endregion
+export { runEventPlugins };
+
+//# sourceMappingURL=plugins.js.map

package/dist/plugins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.js","names":[],"sources":["../src/plugins.ts"],"sourcesContent":["import type { RuntimeLlmContext } from \"./llm\";\nimport type { AgentEvent } from \"./session/events\";\n\ntype MaybePromise<T> = PromiseLike<T> | T;\ntype AgentEventHistory = RuntimeLlmContext[\"history\"];\n\nexport interface AgentEventContext {\n  readonly event: AgentEvent;\n  readonly history: AgentEventHistory;\n  readonly signal?: AbortSignal;\n}\n\nexport interface AgentPlugin {\n  readonly events?: {\n    readonly on?: (context: AgentEventContext) => MaybePromise<void>;\n  };\n  readonly name?: string;\n}\n\nexport function runEventPlugins(\n  plugins: readonly AgentPlugin[],\n  context: AgentEventContext\n): Promise<void> {\n  return runPluginHandlers(plugins, (plugin) => plugin.events?.on, context);\n}\n\nasync function runPluginHandlers<Context>(\n  plugins: readonly AgentPlugin[],\n  handlerFor: (\n    plugin: AgentPlugin\n  ) => ((context: Context) => MaybePromise<void>) | undefined,\n  context: Context\n): Promise<void> {\n  for (const plugin of plugins) {\n    const handler = handlerFor(plugin);\n    if (handler) {\n      await handler(context);\n    }\n  }\n}\n"],"mappings":";AAmBA,SAAgB,gBACd,SACA,SACe;CACf,OAAO,kBAAkB,UAAU,WAAW,OAAO,QAAQ,IAAI,OAAO;AAC1E;AAEA,eAAe,kBACb,SACA,YAGA,SACe;CACf,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,UAAU,WAAW,MAAM;EACjC,IAAI,SACF,MAAM,QAAQ,OAAO;CAEzB;AACF"}

package/dist/session/events.d.ts

@@ -44,12 +44,14 @@ type AgentEvent = /** User input was accepted into the session queue. */UserText
   type: "step-start";
 } /** The model produced reasoning content. */ | AssistantReasoning /** The model produced visible assistant text. */ | AssistantText /** The model requested a tool call. */ | ToolCall /** A tool call returned a result. */ | ToolResult | {
   description?: string;
+  delegateToolCallId?: string;
   run_in_background: boolean;
   subagent: string;
   task_id?: string;
   type: "subagent-job-start";
 } | {
   eventType?: AgentEvent["type"];
+  delegateToolCallId?: string;
   status: SubagentJobStatus;
   subagent: string;
   task_id: string;
@@ -57,6 +59,7 @@ type AgentEvent = /** User input was accepted into the session queue. */UserText
 } | {
   error?: string;
   eventCount: number;
+  delegateToolCallId?: string;
   status: Exclude<SubagentJobStatus, "pending" | "running">;
   subagent: string;
   task_id?: string;

package/dist/session/runtime-input.js

@@ -9,7 +9,7 @@ function createRuntimeInputState(queue) {
 function addSteeringInput(runtimeInput, input) {
 	const next = runtimeInput.pending.then(() => {
 		if (runtimeInput.closedReason) throw runtimeInputClosedError(runtimeInput.closedReason);
-		runtimeInput.queue.push({
+		queueRuntimeInput(runtimeInput, {
 			input: normalizeAgentInput(input),
 			placement: runtimeInput.steerPlacement ?? runtimeInput.placement ?? "step-end"
 		});
@@ -34,36 +34,18 @@ async function withRuntimeInputWindow(runtimeInput, placement, callback) {
 		runtimeInput.steerPlacement = previousSteerPlacement;
 	}
 }
-async function withSteeringPlacement(runtimeInput, placement, callback) {
-	const previousSteerPlacement = runtimeInput.steerPlacement;
-	runtimeInput.steerPlacement = placement;
-	try {
-		return await callback();
-	} finally {
-		runtimeInput.steerPlacement = previousSteerPlacement;
-	}
-}
-function hooksForRuntimeInput(hooks, runtimeInput) {
-	if (!hooks) return;
-	return {
-		...hooks,
-		afterStep: (context) => withSteeringPlacement(runtimeInput, "step-end", async () => {
-			await hooks.afterStep?.(context);
-		}),
-		beforeStep: (context) => withSteeringPlacement(runtimeInput, "step-start", async () => {
-			await hooks.beforeStep?.(context);
-		})
-	};
-}
 function shiftRuntimeInput(runtimeInput, placement) {
 	const index = runtimeInput.queue.findIndex((input) => input.placement === placement);
 	if (index === -1) return;
 	return runtimeInput.queue.splice(index, 1)[0];
 }
+function queueRuntimeInput(runtimeInput, input) {
+	runtimeInput.queue.push(input);
+}
 function runtimeInputClosedError(reason) {
 	return /* @__PURE__ */ new Error(`session.steer() cannot be used after ${reason}`);
 }
 //#endregion
-export { addSteeringInput, closeRuntimeInput, createRuntimeInputState, hooksForRuntimeInput, shiftRuntimeInput, withRuntimeInputWindow, withSteeringPlacement };
+export { addSteeringInput, closeRuntimeInput, createRuntimeInputState, queueRuntimeInput, shiftRuntimeInput, withRuntimeInputWindow };
 
 //# sourceMappingURL=runtime-input.js.map

package/dist/session/runtime-input.js.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-input.js","names":[],"sources":["../../src/session/runtime-input.ts"],"sourcesContent":["import type { AgentHooks } from \"../hooks\";\nimport type { RuntimeInput } from \"./events\";\nimport type { AgentInput, UserInput } from \"./input\";\nimport { normalizeAgentInput } from \"./input-normalization\";\nimport type { BufferedAgentRun } from \"./run\";\n\nexport type RuntimeInputPlacement = RuntimeInput[\"placement\"];\n\nexport interface QueuedRuntimeInput {\n  readonly input: UserInput;\n  readonly placement: RuntimeInputPlacement;\n}\n\nexport interface RuntimeInputState {\n  closedReason?: string;\n  pending: Promise<void>;\n  placement?: RuntimeInputPlacement;\n  readonly queue: QueuedRuntimeInput[];\n  steerPlacement?: RuntimeInputPlacement;\n}\n\nexport interface QueuedInput {\n  readonly input: UserInput;\n  readonly run: BufferedAgentRun;\n  readonly runtimeInput: RuntimeInputState;\n}\n\nexport function createRuntimeInputState(\n  queue: QueuedRuntimeInput[]\n): RuntimeInputState {\n  return {\n    pending: Promise.resolve(),\n    queue,\n  };\n}\n\nexport function addSteeringInput(\n  runtimeInput: RuntimeInputState,\n  input: AgentInput\n): Promise<void> {\n  const next = runtimeInput.pending.then(() => {\n    if (runtimeInput.closedReason) {\n      throw runtimeInputClosedError(runtimeInput.closedReason);\n    }\n\n    runtimeInput.queue.push({\n      input: normalizeAgentInput(input),\n      placement:\n        runtimeInput.steerPlacement ?? runtimeInput.placement ?? \"step-end\",\n    });\n  });\n  runtimeInput.pending = next.catch(() => undefined);\n  return next;\n}\n\nexport function closeRuntimeInput(\n  runtimeInput: RuntimeInputState | undefined,\n  reason = \"the run reached a terminal state\"\n): void {\n  if (runtimeInput && !runtimeInput.closedReason) {\n    runtimeInput.closedReason = reason;\n    runtimeInput.placement = undefined;\n  }\n}\n\nexport async function withRuntimeInputWindow<T>(\n  runtimeInput: RuntimeInputState,\n  placement: RuntimeInputPlacement,\n  callback: () => Promise<T>\n): Promise<T> {\n  const previousSteerPlacement = runtimeInput.steerPlacement;\n  runtimeInput.placement = placement;\n  runtimeInput.steerPlacement = placement;\n  try {\n    return await callback();\n  } finally {\n    runtimeInput.placement = undefined;\n    runtimeInput.steerPlacement = previousSteerPlacement;\n  }\n}\n\nexport async function withSteeringPlacement<T>(\n  runtimeInput: RuntimeInputState,\n  placement: RuntimeInputPlacement,\n  callback: () => Promise<T>\n): Promise<T> {\n  const previousSteerPlacement = runtimeInput.steerPlacement;\n  runtimeInput.steerPlacement = placement;\n  try {\n    return await callback();\n  } finally {\n    runtimeInput.steerPlacement = previousSteerPlacement;\n  }\n}\n\nexport function hooksForRuntimeInput(\n  hooks: AgentHooks | undefined,\n  runtimeInput: RuntimeInputState\n): AgentHooks | undefined {\n  if (!hooks) {\n    return;\n  }\n\n  return {\n    ...hooks,\n    afterStep: (context) =>\n      withSteeringPlacement(runtimeInput, \"step-end\", async () => {\n        await hooks.afterStep?.(context);\n      }),\n    beforeStep: (context) =>\n      withSteeringPlacement(runtimeInput, \"step-start\", async () => {\n        await hooks.beforeStep?.(context);\n      }),\n  };\n}\n\nexport function shiftRuntimeInput(\n  runtimeInput: RuntimeInputState,\n  placement: RuntimeInputPlacement\n): QueuedRuntimeInput | undefined {\n  const index = runtimeInput.queue.findIndex(\n    (input) => input.placement === placement\n  );\n  if (index === -1) {\n    return;\n  }\n\n  return runtimeInput.queue.splice(index, 1)[0];\n}\n\nfunction runtimeInputClosedError(reason: string): Error {\n  return new Error(`session.steer() cannot be used after ${reason}`);\n}\n"],"mappings":";;AA2BA,SAAgB,wBACd,OACmB;CACnB,OAAO;EACL,SAAS,QAAQ,QAAQ;EACzB;CACF;AACF;AAEA,SAAgB,iBACd,cACA,OACe;CACf,MAAM,OAAO,aAAa,QAAQ,WAAW;EAC3C,IAAI,aAAa,cACf,MAAM,wBAAwB,aAAa,YAAY;EAGzD,aAAa,MAAM,KAAK;GACtB,OAAO,oBAAoB,KAAK;GAChC,WACE,aAAa,kBAAkB,aAAa,aAAa;EAC7D,CAAC;CACH,CAAC;CACD,aAAa,UAAU,KAAK,YAAY,KAAA,CAAS;CACjD,OAAO;AACT;AAEA,SAAgB,kBACd,cACA,SAAS,oCACH;CACN,IAAI,gBAAgB,CAAC,aAAa,cAAc;EAC9C,aAAa,eAAe;EAC5B,aAAa,YAAY,KAAA;CAC3B;AACF;AAEA,eAAsB,uBACpB,cACA,WACA,UACY;CACZ,MAAM,yBAAyB,aAAa;CAC5C,aAAa,YAAY;CACzB,aAAa,iBAAiB;CAC9B,IAAI;EACF,OAAO,MAAM,SAAS;CACxB,UAAU;EACR,aAAa,YAAY,KAAA;EACzB,aAAa,iBAAiB;CAChC;AACF;AAEA,eAAsB,sBACpB,cACA,WACA,UACY;CACZ,MAAM,yBAAyB,aAAa;CAC5C,aAAa,iBAAiB;CAC9B,IAAI;EACF,OAAO,MAAM,SAAS;CACxB,UAAU;EACR,aAAa,iBAAiB;CAChC;AACF;AAEA,SAAgB,qBACd,OACA,cACwB;CACxB,IAAI,CAAC,OACH;CAGF,OAAO;EACL,GAAG;EACH,YAAY,YACV,sBAAsB,cAAc,YAAY,YAAY;GAC1D,MAAM,MAAM,YAAY,OAAO;EACjC,CAAC;EACH,aAAa,YACX,sBAAsB,cAAc,cAAc,YAAY;GAC5D,MAAM,MAAM,aAAa,OAAO;EAClC,CAAC;CACL;AACF;AAEA,SAAgB,kBACd,cACA,WACgC;CAChC,MAAM,QAAQ,aAAa,MAAM,WAC9B,UAAU,MAAM,cAAc,SACjC;CACA,IAAI,UAAU,IACZ;CAGF,OAAO,aAAa,MAAM,OAAO,OAAO,CAAC,EAAE;AAC7C;AAEA,SAAS,wBAAwB,QAAuB;CACtD,uBAAO,IAAI,MAAM,wCAAwC,QAAQ;AACnE"}
+{"version":3,"file":"runtime-input.js","names":[],"sources":["../../src/session/runtime-input.ts"],"sourcesContent":["import type { AgentEvent, RuntimeInput } from \"./events\";\nimport type { AgentInput, UserInput } from \"./input\";\nimport { normalizeAgentInput } from \"./input-normalization\";\nimport type { BufferedAgentRun } from \"./run\";\n\nexport type RuntimeInputPlacement = RuntimeInput[\"placement\"];\n\nexport interface QueuedRuntimeInput {\n  readonly input: UserInput;\n  readonly placement: RuntimeInputPlacement;\n}\n\nexport interface RuntimeInputState {\n  closedReason?: string;\n  pending: Promise<void>;\n  placement?: RuntimeInputPlacement;\n  readonly queue: QueuedRuntimeInput[];\n  steerPlacement?: RuntimeInputPlacement;\n}\n\nexport interface QueuedInput {\n  readonly initialEvents: AgentEvent[];\n  readonly input?: UserInput;\n  readonly preUserRuntimeInputs: QueuedRuntimeInput[];\n  readonly run: BufferedAgentRun;\n  readonly runtimeInput: RuntimeInputState;\n}\n\nexport function createRuntimeInputState(\n  queue: QueuedRuntimeInput[]\n): RuntimeInputState {\n  return {\n    pending: Promise.resolve(),\n    queue,\n  };\n}\n\nexport function addSteeringInput(\n  runtimeInput: RuntimeInputState,\n  input: AgentInput\n): Promise<void> {\n  const next = runtimeInput.pending.then(() => {\n    if (runtimeInput.closedReason) {\n      throw runtimeInputClosedError(runtimeInput.closedReason);\n    }\n\n    queueRuntimeInput(runtimeInput, {\n      input: normalizeAgentInput(input),\n      placement:\n        runtimeInput.steerPlacement ?? runtimeInput.placement ?? \"step-end\",\n    });\n  });\n  runtimeInput.pending = next.catch(() => undefined);\n  return next;\n}\n\nexport function closeRuntimeInput(\n  runtimeInput: RuntimeInputState | undefined,\n  reason = \"the run reached a terminal state\"\n): void {\n  if (runtimeInput && !runtimeInput.closedReason) {\n    runtimeInput.closedReason = reason;\n    runtimeInput.placement = undefined;\n  }\n}\n\nexport async function withRuntimeInputWindow<T>(\n  runtimeInput: RuntimeInputState,\n  placement: RuntimeInputPlacement,\n  callback: () => Promise<T>\n): Promise<T> {\n  const previousSteerPlacement = runtimeInput.steerPlacement;\n  runtimeInput.placement = placement;\n  runtimeInput.steerPlacement = placement;\n  try {\n    return await callback();\n  } finally {\n    runtimeInput.placement = undefined;\n    runtimeInput.steerPlacement = previousSteerPlacement;\n  }\n}\n\nexport async function withSteeringPlacement<T>(\n  runtimeInput: RuntimeInputState,\n  placement: RuntimeInputPlacement,\n  callback: () => Promise<T>\n): Promise<T> {\n  const previousSteerPlacement = runtimeInput.steerPlacement;\n  runtimeInput.steerPlacement = placement;\n  try {\n    return await callback();\n  } finally {\n    runtimeInput.steerPlacement = previousSteerPlacement;\n  }\n}\n\nexport function shiftRuntimeInput(\n  runtimeInput: RuntimeInputState,\n  placement: RuntimeInputPlacement\n): QueuedRuntimeInput | undefined {\n  const index = runtimeInput.queue.findIndex(\n    (input) => input.placement === placement\n  );\n  if (index === -1) {\n    return;\n  }\n\n  return runtimeInput.queue.splice(index, 1)[0];\n}\n\nexport function queueRuntimeInput(\n  runtimeInput: RuntimeInputState,\n  input: QueuedRuntimeInput\n): void {\n  runtimeInput.queue.push(input);\n}\n\nfunction runtimeInputClosedError(reason: string): Error {\n  return new Error(`session.steer() cannot be used after ${reason}`);\n}\n"],"mappings":";;AA4BA,SAAgB,wBACd,OACmB;CACnB,OAAO;EACL,SAAS,QAAQ,QAAQ;EACzB;CACF;AACF;AAEA,SAAgB,iBACd,cACA,OACe;CACf,MAAM,OAAO,aAAa,QAAQ,WAAW;EAC3C,IAAI,aAAa,cACf,MAAM,wBAAwB,aAAa,YAAY;EAGzD,kBAAkB,cAAc;GAC9B,OAAO,oBAAoB,KAAK;GAChC,WACE,aAAa,kBAAkB,aAAa,aAAa;EAC7D,CAAC;CACH,CAAC;CACD,aAAa,UAAU,KAAK,YAAY,KAAA,CAAS;CACjD,OAAO;AACT;AAEA,SAAgB,kBACd,cACA,SAAS,oCACH;CACN,IAAI,gBAAgB,CAAC,aAAa,cAAc;EAC9C,aAAa,eAAe;EAC5B,aAAa,YAAY,KAAA;CAC3B;AACF;AAEA,eAAsB,uBACpB,cACA,WACA,UACY;CACZ,MAAM,yBAAyB,aAAa;CAC5C,aAAa,YAAY;CACzB,aAAa,iBAAiB;CAC9B,IAAI;EACF,OAAO,MAAM,SAAS;CACxB,UAAU;EACR,aAAa,YAAY,KAAA;EACzB,aAAa,iBAAiB;CAChC;AACF;AAgBA,SAAgB,kBACd,cACA,WACgC;CAChC,MAAM,QAAQ,aAAa,MAAM,WAC9B,UAAU,MAAM,cAAc,SACjC;CACA,IAAI,UAAU,IACZ;CAGF,OAAO,aAAa,MAAM,OAAO,OAAO,CAAC,EAAE;AAC7C;AAEA,SAAgB,kBACd,cACA,OACM;CACN,aAAa,MAAM,KAAK,KAAK;AAC/B;AAEA,SAAS,wBAAwB,QAAuB;CACtD,uBAAO,IAAI,MAAM,wCAAwC,QAAQ;AACnE"}

package/dist/session/session-errors.js

@@ -1,9 +1,4 @@
 //#region src/session/session-errors.ts
-async function runAfterTurnHook(hooks, context) {
-	const hook = hooks?.afterTurn;
-	if (!hook) return;
-	await Promise.allSettled([Promise.resolve().then(() => hook(context))]);
-}
 function errorMessage(error) {
 	if (error instanceof Error) return error.message;
 	return String(error);
@@ -18,6 +13,6 @@ function sessionTerminalError(killed) {
 	return killed ? sessionKilledError() : sessionDeleteInProgressError();
 }
 //#endregion
-export { errorMessage, runAfterTurnHook, sessionKilledError, sessionTerminalError };
+export { errorMessage, sessionKilledError, sessionTerminalError };
 
 //# sourceMappingURL=session-errors.js.map

package/dist/session/session-errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"session-errors.js","names":[],"sources":["../../src/session/session-errors.ts"],"sourcesContent":["import type { AgentHooks } from \"../hooks\";\n\nexport async function runAfterTurnHook(\n  hooks: AgentHooks | undefined,\n  context: Parameters<NonNullable<AgentHooks[\"afterTurn\"]>>[0]\n): Promise<void> {\n  const hook = hooks?.afterTurn;\n  if (!hook) {\n    return;\n  }\n\n  await Promise.allSettled([Promise.resolve().then(() => hook(context))]);\n}\n\nexport function errorMessage(error: unknown): string {\n  if (error instanceof Error) {\n    return error.message;\n  }\n\n  return String(error);\n}\n\nexport function sessionKilledError(): Error {\n  return new Error(\"Session killed\");\n}\n\nexport function sessionDeleteInProgressError(): Error {\n  return new Error(\"Session delete in progress\");\n}\n\nexport function sessionTerminalError(killed: boolean): Error {\n  return killed ? sessionKilledError() : sessionDeleteInProgressError();\n}\n"],"mappings":";AAEA,eAAsB,iBACpB,OACA,SACe;CACf,MAAM,OAAO,OAAO;CACpB,IAAI,CAAC,MACH;CAGF,MAAM,QAAQ,WAAW,CAAC,QAAQ,QAAQ,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;AACxE;AAEA,SAAgB,aAAa,OAAwB;CACnD,IAAI,iBAAiB,OACnB,OAAO,MAAM;CAGf,OAAO,OAAO,KAAK;AACrB;AAEA,SAAgB,qBAA4B;CAC1C,uBAAO,IAAI,MAAM,gBAAgB;AACnC;AAEA,SAAgB,+BAAsC;CACpD,uBAAO,IAAI,MAAM,4BAA4B;AAC/C;AAEA,SAAgB,qBAAqB,QAAwB;CAC3D,OAAO,SAAS,mBAAmB,IAAI,6BAA6B;AACtE"}
+{"version":3,"file":"session-errors.js","names":[],"sources":["../../src/session/session-errors.ts"],"sourcesContent":["export function errorMessage(error: unknown): string {\n  if (error instanceof Error) {\n    return error.message;\n  }\n\n  return String(error);\n}\n\nexport function sessionKilledError(): Error {\n  return new Error(\"Session killed\");\n}\n\nexport function sessionDeleteInProgressError(): Error {\n  return new Error(\"Session delete in progress\");\n}\n\nexport function sessionTerminalError(killed: boolean): Error {\n  return killed ? sessionKilledError() : sessionDeleteInProgressError();\n}\n"],"mappings":";AAAA,SAAgB,aAAa,OAAwB;CACnD,IAAI,iBAAiB,OACnB,OAAO,MAAM;CAGf,OAAO,OAAO,KAAK;AACrB;AAEA,SAAgB,qBAA4B;CAC1C,uBAAO,IAAI,MAAM,gBAAgB;AACnC;AAEA,SAAgB,+BAAsC;CACpD,uBAAO,IAAI,MAAM,4BAA4B;AAC/C;AAEA,SAAgB,qBAAqB,QAAwB;CAC3D,OAAO,SAAS,mBAAmB,IAAI,6BAA6B;AACtE"}

package/dist/session/session-events.js

@@ -0,0 +1,59 @@
+import { runEventPlugins } from "../plugins.js";
+//#region src/session/session-events.ts
+var SessionEventDispatcher = class {
+	#history;
+	#observerEventBuffer;
+	#plugins;
+	#signal;
+	constructor(options) {
+		this.#history = options.history;
+		this.#plugins = options.plugins;
+		this.#signal = options.signal;
+	}
+	async captureObserverEvents(run, callback) {
+		const previousBuffer = this.#observerEventBuffer;
+		const buffer = [];
+		this.#observerEventBuffer = buffer;
+		try {
+			return {
+				events: buffer,
+				release: () => {
+					if (this.#observerEventBuffer === buffer) this.#observerEventBuffer = previousBuffer;
+				},
+				value: await callback()
+			};
+		} catch (error) {
+			for (const event of buffer.splice(0)) await this.emitRunEvent(run, event);
+			this.#observerEventBuffer = previousBuffer;
+			throw error;
+		}
+	}
+	emitObserverEvent(activeRun, event) {
+		const observerEventBuffer = this.#observerEventBuffer;
+		if (observerEventBuffer) {
+			observerEventBuffer.push(structuredClone(event));
+			return Promise.resolve();
+		}
+		if (!activeRun) return Promise.resolve();
+		return this.emitRunEvent(activeRun, event);
+	}
+	async emitRunBoundaryEvent(run, event) {
+		await this.#runPlugins(event);
+		await run.emitBoundary(event);
+	}
+	async emitRunEvent(run, event) {
+		await this.#runPlugins(event);
+		run.emit(event);
+	}
+	#runPlugins(event) {
+		return runEventPlugins(this.#plugins, {
+			event,
+			history: this.#history(),
+			signal: this.#signal()
+		});
+	}
+};
+//#endregion
+export { SessionEventDispatcher };
+
+//# sourceMappingURL=session-events.js.map

package/dist/session/session-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-events.js","names":["#history","#plugins","#signal","#observerEventBuffer","#runPlugins"],"sources":["../../src/session/session-events.ts"],"sourcesContent":["import type { RuntimeLlmContext } from \"../llm\";\nimport { type AgentPlugin, runEventPlugins } from \"../plugins\";\nimport type { AgentEvent } from \"./events\";\nimport type { BufferedAgentRun } from \"./run\";\n\ninterface SessionEventDispatcherOptions {\n  readonly history: () => RuntimeLlmContext[\"history\"];\n  readonly plugins: readonly AgentPlugin[];\n  readonly signal: () => AbortSignal | undefined;\n}\n\nexport class SessionEventDispatcher {\n  readonly #history: () => RuntimeLlmContext[\"history\"];\n  #observerEventBuffer?: AgentEvent[];\n  readonly #plugins: readonly AgentPlugin[];\n  readonly #signal: () => AbortSignal | undefined;\n\n  constructor(options: SessionEventDispatcherOptions) {\n    this.#history = options.history;\n    this.#plugins = options.plugins;\n    this.#signal = options.signal;\n  }\n\n  async captureObserverEvents<T>(\n    run: BufferedAgentRun,\n    callback: () => Promise<T>\n  ): Promise<{\n    readonly events: AgentEvent[];\n    readonly release: () => void;\n    readonly value: T;\n  }> {\n    const previousBuffer = this.#observerEventBuffer;\n    const buffer: AgentEvent[] = [];\n    this.#observerEventBuffer = buffer;\n    try {\n      const value = await callback();\n      return {\n        events: buffer,\n        release: () => {\n          if (this.#observerEventBuffer === buffer) {\n            this.#observerEventBuffer = previousBuffer;\n          }\n        },\n        value,\n      };\n    } catch (error) {\n      for (const event of buffer.splice(0)) {\n        await this.emitRunEvent(run, event);\n      }\n      this.#observerEventBuffer = previousBuffer;\n      throw error;\n    }\n  }\n\n  emitObserverEvent(\n    activeRun: BufferedAgentRun | undefined,\n    event: AgentEvent\n  ): Promise<void> {\n    const observerEventBuffer = this.#observerEventBuffer;\n    if (observerEventBuffer) {\n      observerEventBuffer.push(structuredClone(event));\n      return Promise.resolve();\n    }\n\n    if (!activeRun) {\n      return Promise.resolve();\n    }\n\n    return this.emitRunEvent(activeRun, event);\n  }\n\n  async emitRunBoundaryEvent(\n    run: BufferedAgentRun,\n    event: AgentEvent\n  ): Promise<void> {\n    await this.#runPlugins(event);\n    await run.emitBoundary(event);\n  }\n\n  async emitRunEvent(run: BufferedAgentRun, event: AgentEvent): Promise<void> {\n    await this.#runPlugins(event);\n    run.emit(event);\n  }\n\n  #runPlugins(event: AgentEvent): Promise<void> {\n    return runEventPlugins(this.#plugins, {\n      event,\n      history: this.#history(),\n      signal: this.#signal(),\n    });\n  }\n}\n"],"mappings":";;AAWA,IAAa,yBAAb,MAAoC;CAClC;CACA;CACA;CACA;CAEA,YAAY,SAAwC;EAClD,KAAKA,WAAW,QAAQ;EACxB,KAAKC,WAAW,QAAQ;EACxB,KAAKC,UAAU,QAAQ;CACzB;CAEA,MAAM,sBACJ,KACA,UAKC;EACD,MAAM,iBAAiB,KAAKC;EAC5B,MAAM,SAAuB,CAAC;EAC9B,KAAKA,uBAAuB;EAC5B,IAAI;GAEF,OAAO;IACL,QAAQ;IACR,eAAe;KACb,IAAI,KAAKA,yBAAyB,QAChC,KAAKA,uBAAuB;IAEhC;IACA,OAAA,MARkB,SAAS;GAS7B;EACF,SAAS,OAAO;GACd,KAAK,MAAM,SAAS,OAAO,OAAO,CAAC,GACjC,MAAM,KAAK,aAAa,KAAK,KAAK;GAEpC,KAAKA,uBAAuB;GAC5B,MAAM;EACR;CACF;CAEA,kBACE,WACA,OACe;EACf,MAAM,sBAAsB,KAAKA;EACjC,IAAI,qBAAqB;GACvB,oBAAoB,KAAK,gBAAgB,KAAK,CAAC;GAC/C,OAAO,QAAQ,QAAQ;EACzB;EAEA,IAAI,CAAC,WACH,OAAO,QAAQ,QAAQ;EAGzB,OAAO,KAAK,aAAa,WAAW,KAAK;CAC3C;CAEA,MAAM,qBACJ,KACA,OACe;EACf,MAAM,KAAKC,YAAY,KAAK;EAC5B,MAAM,IAAI,aAAa,KAAK;CAC9B;CAEA,MAAM,aAAa,KAAuB,OAAkC;EAC1E,MAAM,KAAKA,YAAY,KAAK;EAC5B,IAAI,KAAK,KAAK;CAChB;CAEA,YAAY,OAAkC;EAC5C,OAAO,gBAAgB,KAAKH,UAAU;GACpC;GACA,SAAS,KAAKD,SAAS;GACvB,QAAQ,KAAKE,QAAQ;EACvB,CAAC;CACH;AACF"}

package/dist/session/session-execution.js

@@ -0,0 +1,88 @@
+import { persistedToolExecutionCheckpoint } from "../llm-tool-execution.js";
+//#region src/session/session-execution.ts
+const maxCheckpointWriteAttempts = 5;
+var SessionExecutionCheckpointError = class extends Error {
+	constructor(runId, expectedVersion, currentVersion) {
+		super(`Session execution run ${runId} checkpoint conflict: expected ${expectedVersion}, got ${currentVersion}`);
+		this.name = "SessionExecutionCheckpointError";
+	}
+};
+async function startSessionExecutionRun({ executionHost, sessionKey, state, turnId }) {
+	if (!executionHost) return;
+	const runId = `turn:${sessionKey}:${turnId}`;
+	const run = {
+		checkpointVersion: 0,
+		dedupeKey: runId,
+		kind: "user-turn",
+		rootRunId: runId,
+		runId,
+		sessionKey,
+		status: "running"
+	};
+	await executionHost.store.runs.create(run);
+	return {
+		complete: (status) => completeSessionExecutionRun({
+			executionHost,
+			runId,
+			status
+		}),
+		runId,
+		toolExecution: {
+			attempt: 1,
+			afterTool: (checkpoint) => appendToolExecutionCheckpoint({
+				executionHost,
+				phase: "after-tool",
+				runId,
+				state,
+				toolCall: checkpoint
+			}),
+			beforeTool: async (checkpoint) => {
+				await appendToolExecutionCheckpoint({
+					executionHost,
+					phase: "before-tool",
+					runId,
+					state,
+					toolCall: checkpoint
+				});
+			},
+			runId
+		}
+	};
+}
+async function appendToolExecutionCheckpoint({ executionHost, phase, runId, state, toolCall }) {
+	let lastConflict;
+	for (let attempt = 0; attempt < maxCheckpointWriteAttempts; attempt += 1) {
+		const run = await executionHost.store.runs.get(runId);
+		if (!run) throw new Error(`Session execution run ${runId} is missing.`);
+		const result = await executionHost.store.checkpoints.append({
+			checkpointId: crypto.randomUUID(),
+			pendingToolCall: persistedToolExecutionCheckpoint(toolCall),
+			phase,
+			runId,
+			runtimeState: {
+				toolCallId: toolCall.toolCallId,
+				toolName: toolCall.toolName
+			},
+			sessionSnapshot: { history: state.modelSnapshot() },
+			version: run.checkpointVersion + 1
+		}, { expectedVersion: run.checkpointVersion });
+		if (result.ok) return;
+		lastConflict = {
+			current: result.currentVersion,
+			expected: run.checkpointVersion
+		};
+	}
+	throw new SessionExecutionCheckpointError(runId, lastConflict?.expected ?? 0, lastConflict?.current ?? 0);
+}
+async function completeSessionExecutionRun({ executionHost, runId, status }) {
+	const run = await executionHost.store.runs.get(runId);
+	if (!run) return;
+	await executionHost.store.runs.update({
+		...run,
+		status
+	});
+}
+//#endregion
+export { startSessionExecutionRun };
+
+//# sourceMappingURL=session-execution.js.map

package/dist/session/session-execution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-execution.js","names":[],"sources":["../../src/session/session-execution.ts"],"sourcesContent":["import type {\n  CheckpointPhase,\n  ExecutionHost,\n  RunRecord,\n  RunStatus,\n} from \"../execution/types\";\nimport type {\n  RuntimeToolExecutionCheckpoint,\n  RuntimeToolExecutionContext,\n} from \"../llm\";\nimport { persistedToolExecutionCheckpoint } from \"../llm-tool-execution\";\nimport type { SessionState } from \"./session-state\";\n\nconst maxCheckpointWriteAttempts = 5;\n\nexport interface SessionExecutionOptions {\n  readonly executionHost?: ExecutionHost;\n}\n\nexport interface SessionExecutionRun {\n  complete(status: SessionExecutionTerminalStatus): Promise<void>;\n  readonly runId: string;\n  readonly toolExecution: RuntimeToolExecutionContext;\n}\n\nexport type SessionExecutionTerminalStatus = Extract<\n  RunStatus,\n  \"cancelled\" | \"completed\" | \"error\" | \"needs-recovery\"\n>;\n\nexport class SessionExecutionCheckpointError extends Error {\n  constructor(runId: string, expectedVersion: number, currentVersion: number) {\n    super(\n      `Session execution run ${runId} checkpoint conflict: expected ${expectedVersion}, got ${currentVersion}`\n    );\n    this.name = \"SessionExecutionCheckpointError\";\n  }\n}\n\nexport async function startSessionExecutionRun({\n  executionHost,\n  sessionKey,\n  state,\n  turnId,\n}: {\n  readonly executionHost?: ExecutionHost;\n  readonly sessionKey: string;\n  readonly state: SessionState;\n  readonly turnId: string;\n}): Promise<SessionExecutionRun | undefined> {\n  if (!executionHost) {\n    return;\n  }\n\n  const runId = `turn:${sessionKey}:${turnId}`;\n  const run: RunRecord = {\n    checkpointVersion: 0,\n    dedupeKey: runId,\n    kind: \"user-turn\",\n    rootRunId: runId,\n    runId,\n    sessionKey,\n    status: \"running\",\n  };\n  await executionHost.store.runs.create(run);\n\n  return {\n    complete: (status) =>\n      completeSessionExecutionRun({ executionHost, runId, status }),\n    runId,\n    toolExecution: {\n      attempt: 1,\n      afterTool: (checkpoint) =>\n        appendToolExecutionCheckpoint({\n          executionHost,\n          phase: \"after-tool\",\n          runId,\n          state,\n          toolCall: checkpoint,\n        }),\n      beforeTool: async (checkpoint) => {\n        await appendToolExecutionCheckpoint({\n          executionHost,\n          phase: \"before-tool\",\n          runId,\n          state,\n          toolCall: checkpoint,\n        });\n        return;\n      },\n      runId,\n    },\n  };\n}\n\nasync function appendToolExecutionCheckpoint({\n  executionHost,\n  phase,\n  runId,\n  state,\n  toolCall,\n}: {\n  readonly executionHost: ExecutionHost;\n  readonly phase: Extract<CheckpointPhase, \"after-tool\" | \"before-tool\">;\n  readonly runId: string;\n  readonly state: SessionState;\n  readonly toolCall: RuntimeToolExecutionCheckpoint & {\n    readonly output?: unknown;\n  };\n}): Promise<void> {\n  let lastConflict:\n    | { readonly current: number; readonly expected: number }\n    | undefined;\n  for (let attempt = 0; attempt < maxCheckpointWriteAttempts; attempt += 1) {\n    const run = await executionHost.store.runs.get(runId);\n    if (!run) {\n      throw new Error(`Session execution run ${runId} is missing.`);\n    }\n\n    const result = await executionHost.store.checkpoints.append(\n      {\n        checkpointId: crypto.randomUUID(),\n        pendingToolCall: persistedToolExecutionCheckpoint(toolCall),\n        phase,\n        runId,\n        runtimeState: {\n          toolCallId: toolCall.toolCallId,\n          toolName: toolCall.toolName,\n        },\n        sessionSnapshot: { history: state.modelSnapshot() },\n        version: run.checkpointVersion + 1,\n      },\n      { expectedVersion: run.checkpointVersion }\n    );\n\n    if (result.ok) {\n      return;\n    }\n\n    lastConflict = {\n      current: result.currentVersion,\n      expected: run.checkpointVersion,\n    };\n  }\n\n  throw new SessionExecutionCheckpointError(\n    runId,\n    lastConflict?.expected ?? 0,\n    lastConflict?.current ?? 0\n  );\n}\n\nasync function completeSessionExecutionRun({\n  executionHost,\n  runId,\n  status,\n}: {\n  readonly executionHost: ExecutionHost;\n  readonly runId: string;\n  readonly status: SessionExecutionTerminalStatus;\n}): Promise<void> {\n  const run = await executionHost.store.runs.get(runId);\n  if (!run) {\n    return;\n  }\n\n  await executionHost.store.runs.update({ ...run, status });\n}\n"],"mappings":";;AAaA,MAAM,6BAA6B;AAiBnC,IAAa,kCAAb,cAAqD,MAAM;CACzD,YAAY,OAAe,iBAAyB,gBAAwB;EAC1E,MACE,yBAAyB,MAAM,iCAAiC,gBAAgB,QAAQ,gBAC1F;EACA,KAAK,OAAO;CACd;AACF;AAEA,eAAsB,yBAAyB,EAC7C,eACA,YACA,OACA,UAM2C;CAC3C,IAAI,CAAC,eACH;CAGF,MAAM,QAAQ,QAAQ,WAAW,GAAG;CACpC,MAAM,MAAiB;EACrB,mBAAmB;EACnB,WAAW;EACX,MAAM;EACN,WAAW;EACX;EACA;EACA,QAAQ;CACV;CACA,MAAM,cAAc,MAAM,KAAK,OAAO,GAAG;CAEzC,OAAO;EACL,WAAW,WACT,4BAA4B;GAAE;GAAe;GAAO;EAAO,CAAC;EAC9D;EACA,eAAe;GACb,SAAS;GACT,YAAY,eACV,8BAA8B;IAC5B;IACA,OAAO;IACP;IACA;IACA,UAAU;GACZ,CAAC;GACH,YAAY,OAAO,eAAe;IAChC,MAAM,8BAA8B;KAClC;KACA,OAAO;KACP;KACA;KACA,UAAU;IACZ,CAAC;GAEH;GACA;EACF;CACF;AACF;AAEA,eAAe,8BAA8B,EAC3C,eACA,OACA,OACA,OACA,YASgB;CAChB,IAAI;CAGJ,KAAK,IAAI,UAAU,GAAG,UAAU,4BAA4B,WAAW,GAAG;EACxE,MAAM,MAAM,MAAM,cAAc,MAAM,KAAK,IAAI,KAAK;EACpD,IAAI,CAAC,KACH,MAAM,IAAI,MAAM,yBAAyB,MAAM,aAAa;EAG9D,MAAM,SAAS,MAAM,cAAc,MAAM,YAAY,OACnD;GACE,cAAc,OAAO,WAAW;GAChC,iBAAiB,iCAAiC,QAAQ;GAC1D;GACA;GACA,cAAc;IACZ,YAAY,SAAS;IACrB,UAAU,SAAS;GACrB;GACA,iBAAiB,EAAE,SAAS,MAAM,cAAc,EAAE;GAClD,SAAS,IAAI,oBAAoB;EACnC,GACA,EAAE,iBAAiB,IAAI,kBAAkB,CAC3C;EAEA,IAAI,OAAO,IACT;EAGF,eAAe;GACb,SAAS,OAAO;GAChB,UAAU,IAAI;EAChB;CACF;CAEA,MAAM,IAAI,gCACR,OACA,cAAc,YAAY,GAC1B,cAAc,WAAW,CAC3B;AACF;AAEA,eAAe,4BAA4B,EACzC,eACA,OACA,UAKgB;CAChB,MAAM,MAAM,MAAM,cAAc,MAAM,KAAK,IAAI,KAAK;CACpD,IAAI,CAAC,KACH;CAGF,MAAM,cAAc,MAAM,KAAK,OAAO;EAAE,GAAG;EAAK;CAAO,CAAC;AAC1D"}

package/dist/session/session-notification.js

@@ -0,0 +1,58 @@
+import { BufferedAgentRun } from "./run.js";
+import { normalizeAgentInput } from "./input-normalization.js";
+import { createRuntimeInputState, queueRuntimeInput } from "./runtime-input.js";
+import { errorMessage } from "./session-errors.js";
+//#region src/session/session-notification.ts
+function queueSessionNotification(input, options, state) {
+	const queuedRuntimeInput = {
+		input: normalizeAgentInput(input),
+		placement: "turn-start"
+	};
+	const observerEvents = cloneObserverEvents(options.observerEvents ?? []);
+	const queuedTurn = state.inputQueue[0];
+	if (queuedTurn) {
+		queuedTurn.initialEvents.push(...observerEvents);
+		queuedTurn.preUserRuntimeInputs.push(queuedRuntimeInput);
+		return queuedTurn.run;
+	}
+	const activeRun = state.activeRun;
+	const runtimeInput = state.activeRuntimeInput;
+	if (runtimeInput && activeRun && !runtimeInput.closedReason) {
+		queueRuntimeInput(runtimeInput, {
+			input: structuredClone(queuedRuntimeInput.input),
+			placement: "step-end"
+		});
+		return activeRun;
+	}
+	if (options.deferWhenUnobserved === true) {
+		state.pendingRuntimeInputs.push(queuedRuntimeInput);
+		const deferredRun = new BufferedAgentRun();
+		deferredRun.close();
+		return deferredRun;
+	}
+	const run = new BufferedAgentRun();
+	state.inputQueue.push({
+		initialEvents: observerEvents,
+		preUserRuntimeInputs: [],
+		run,
+		runtimeInput: createRuntimeInputState([queuedRuntimeInput])
+	});
+	startSessionQueueDrain(run, state.drain);
+	return run;
+}
+function startSessionQueueDrain(run, drain) {
+	drain().catch((error) => {
+		run.emit({
+			type: "turn-error",
+			message: errorMessage(error)
+		});
+		run.close();
+	});
+}
+function cloneObserverEvents(events) {
+	return events.map((event) => structuredClone(event));
+}
+//#endregion
+export { queueSessionNotification, startSessionQueueDrain };
+
+//# sourceMappingURL=session-notification.js.map

package/dist/session/session-notification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-notification.js","names":[],"sources":["../../src/session/session-notification.ts"],"sourcesContent":["import type { AgentEvent } from \"./events\";\nimport type { AgentInput } from \"./input\";\nimport { normalizeAgentInput } from \"./input-normalization\";\nimport { type AgentRun, BufferedAgentRun } from \"./run\";\nimport {\n  createRuntimeInputState,\n  type QueuedInput,\n  type QueuedRuntimeInput,\n  queueRuntimeInput,\n  type RuntimeInputState,\n} from \"./runtime-input\";\nimport { errorMessage } from \"./session-errors\";\n\nexport interface NotifyOptions {\n  readonly deferWhenUnobserved?: boolean;\n  readonly observerEvents?: readonly AgentEvent[];\n}\n\ninterface QueueSessionNotificationOptions {\n  readonly activeRun: BufferedAgentRun | undefined;\n  readonly activeRuntimeInput: RuntimeInputState | undefined;\n  readonly drain: () => Promise<void>;\n  readonly inputQueue: QueuedInput[];\n  readonly pendingRuntimeInputs: QueuedRuntimeInput[];\n}\n\nexport function queueSessionNotification(\n  input: AgentInput,\n  options: NotifyOptions,\n  state: QueueSessionNotificationOptions\n): AgentRun {\n  const queuedRuntimeInput: QueuedRuntimeInput = {\n    input: normalizeAgentInput(input),\n    placement: \"turn-start\",\n  };\n  const observerEvents = cloneObserverEvents(options.observerEvents ?? []);\n  const queuedTurn = state.inputQueue[0];\n  if (queuedTurn) {\n    queuedTurn.initialEvents.push(...observerEvents);\n    queuedTurn.preUserRuntimeInputs.push(queuedRuntimeInput);\n    return queuedTurn.run;\n  }\n\n  const activeRun = state.activeRun;\n  const runtimeInput = state.activeRuntimeInput;\n  if (runtimeInput && activeRun && !runtimeInput.closedReason) {\n    queueRuntimeInput(runtimeInput, {\n      input: structuredClone(queuedRuntimeInput.input),\n      placement: \"step-end\",\n    });\n    return activeRun;\n  }\n\n  if (options.deferWhenUnobserved === true) {\n    state.pendingRuntimeInputs.push(queuedRuntimeInput);\n    const deferredRun = new BufferedAgentRun();\n    deferredRun.close();\n    return deferredRun;\n  }\n\n  const run = new BufferedAgentRun();\n  state.inputQueue.push({\n    initialEvents: observerEvents,\n    preUserRuntimeInputs: [],\n    run,\n    runtimeInput: createRuntimeInputState([queuedRuntimeInput]),\n  });\n  startSessionQueueDrain(run, state.drain);\n  return run;\n}\n\nexport function startSessionQueueDrain(\n  run: BufferedAgentRun,\n  drain: () => Promise<void>\n): void {\n  drain().catch((error: unknown) => {\n    run.emit({ type: \"turn-error\", message: errorMessage(error) });\n    run.close();\n  });\n}\n\nfunction cloneObserverEvents(events: readonly AgentEvent[]): AgentEvent[] {\n  return events.map((event) => structuredClone(event));\n}\n"],"mappings":";;;;;AA0BA,SAAgB,yBACd,OACA,SACA,OACU;CACV,MAAM,qBAAyC;EAC7C,OAAO,oBAAoB,KAAK;EAChC,WAAW;CACb;CACA,MAAM,iBAAiB,oBAAoB,QAAQ,kBAAkB,CAAC,CAAC;CACvE,MAAM,aAAa,MAAM,WAAW;CACpC,IAAI,YAAY;EACd,WAAW,cAAc,KAAK,GAAG,cAAc;EAC/C,WAAW,qBAAqB,KAAK,kBAAkB;EACvD,OAAO,WAAW;CACpB;CAEA,MAAM,YAAY,MAAM;CACxB,MAAM,eAAe,MAAM;CAC3B,IAAI,gBAAgB,aAAa,CAAC,aAAa,cAAc;EAC3D,kBAAkB,cAAc;GAC9B,OAAO,gBAAgB,mBAAmB,KAAK;GAC/C,WAAW;EACb,CAAC;EACD,OAAO;CACT;CAEA,IAAI,QAAQ,wBAAwB,MAAM;EACxC,MAAM,qBAAqB,KAAK,kBAAkB;EAClD,MAAM,cAAc,IAAI,iBAAiB;EACzC,YAAY,MAAM;EAClB,OAAO;CACT;CAEA,MAAM,MAAM,IAAI,iBAAiB;CACjC,MAAM,WAAW,KAAK;EACpB,eAAe;EACf,sBAAsB,CAAC;EACvB;EACA,cAAc,wBAAwB,CAAC,kBAAkB,CAAC;CAC5D,CAAC;CACD,uBAAuB,KAAK,MAAM,KAAK;CACvC,OAAO;AACT;AAEA,SAAgB,uBACd,KACA,OACM;CACN,MAAM,EAAE,OAAO,UAAmB;EAChC,IAAI,KAAK;GAAE,MAAM;GAAc,SAAS,aAAa,KAAK;EAAE,CAAC;EAC7D,IAAI,MAAM;CACZ,CAAC;AACH;AAEA,SAAS,oBAAoB,QAA6C;CACxE,OAAO,OAAO,KAAK,UAAU,gBAAgB,KAAK,CAAC;AACrD"}