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

package/dist/index.js

@@ -1,3 +1,8 @@
+import { executionHost } from "./execution/host.js";
 import { createLlm } from "./llm.js";
+import { attachInputMeta, attachRuntimeInputMeta, stripEventMeta, stripInputMeta, userInputFromEvent } from "./session/input-meta.js";
+import { runPluginsForEvent } from "./plugins.js";
 import { Agent } from "./agent.js";
-export { Agent, createLlm };
+import { delegateUserInput } from "./session/delegate-input.js";
+import { isControlAgentEvent, isLifecycleAgentEvent, isTelemetryAgentEvent, isToolAgentEvent, isVisibleAgentEvent } from "./session/events.js";
+export { Agent, attachInputMeta, attachRuntimeInputMeta, createLlm, delegateUserInput, executionHost, isControlAgentEvent, isLifecycleAgentEvent, isTelemetryAgentEvent, isToolAgentEvent, isVisibleAgentEvent, runPluginsForEvent, stripEventMeta, stripInputMeta, userInputFromEvent };

package/dist/llm-tool-execution.d.ts

@@ -0,0 +1,35 @@
+import { ToolSet } from "ai";
+
+//#region src/llm-tool-execution.d.ts
+type RuntimeToolRetryPolicy = "idempotent" | "manual-recovery" | "pure";
+interface RuntimeToolExecutionCheckpointMetadata {
+  readonly attempt: number;
+  readonly idempotencyKey: string;
+  readonly policy: RuntimeToolRetryPolicy;
+  readonly toolCallId: string;
+  readonly toolName: string;
+}
+interface RuntimeToolExecutionCheckpoint extends RuntimeToolExecutionCheckpointMetadata {
+  readonly input: unknown;
+}
+type RuntimeToolExecutionDecision = {
+  readonly status: "needs-recovery";
+} | undefined;
+interface RuntimeToolExecutionContext {
+  readonly afterTool?: (checkpoint: RuntimeToolExecutionCheckpoint & {
+    readonly output: unknown;
+  }) => Promise<void> | void;
+  readonly attempt: number;
+  readonly beforeTool?: (checkpoint: RuntimeToolExecutionCheckpoint) => Promise<RuntimeToolExecutionDecision> | RuntimeToolExecutionDecision;
+  readonly runId: string;
+}
+declare class ToolExecutionNeedsRecoveryError extends Error {
+  readonly idempotencyKey: string;
+  readonly status = "needs-recovery";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  constructor(checkpoint: RuntimeToolExecutionCheckpointMetadata);
+}
+//#endregion
+export { RuntimeToolExecutionCheckpoint, RuntimeToolExecutionCheckpointMetadata, RuntimeToolExecutionContext, RuntimeToolExecutionDecision, RuntimeToolRetryPolicy, ToolExecutionNeedsRecoveryError };
+//# sourceMappingURL=llm-tool-execution.d.ts.map

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":";AAGA,MAAM,mBAAmB;AACzB,MAAM,0BAA0B;AAqChC,IAAa,kCAAb,cAAqD,MAAM;CACzD;CACA,SAAkB;CAClB;CACA;CAEA,YAAY,YAAoD;EAC9D,MACE,QAAQ,WAAW,SAAS,gCAAgC,WAAW,gBACzE;EACA,KAAK,iBAAiB,WAAW;EACjC,KAAK,OAAO;EACZ,KAAK,aAAa,WAAW;EAC7B,KAAK,WAAW,WAAW;CAC7B;AACF;AAEA,SAAgB,iCACd,YACyC;CACzC,OAAO;EACL,SAAS,WAAW;EACpB,gBAAgB,WAAW;EAC3B,QAAQ,WAAW;EACnB,YAAY,WAAW;EACvB,UAAU,WAAW;CACvB;AACF;AAEA,SAAgB,qBACd,OACA,aACA,eACqB;CACrB,IAAI,CAAC,OACH;CAGF,OAAO,OAAO,YACZ,OAAO,QAAQ,KAAK,EAAE,KAAK,CAAC,MAAM,eAAe,CAC/C,MACA,gBAAgB,MAAM,WAAW,aAAa,aAAa,CAC7D,CAAC,CACH;AACF;AAEA,SAAgB,0BACd,SACA,aACmB;CACnB,IAAI,QAAQ,SAAS,aACnB,OAAO,4BAA4B,SAAS,WAAW;CAGzD,IAAI,QAAQ,SAAS,QACnB,OAAO,yBAAyB,SAAS,WAAW;CAGtD,OAAO;AACT;AAEA,SAAS,gBACP,UACA,gBACA,aACA,eACS;CACT,IAAI,CAAC,2BAA2B,cAAc,GAC5C,OAAO;CAGT,MAAM,EAAE,YAAY;CACpB,IAAI,CAAC,eACH,OAAO;EACL,GAAG;EACH,UAAU,OAAgB,YACxB,QAAQ,OAAO;GACb,GAAG;GACH,YAAY,iBAAiB,QAAQ,YAAY,WAAW;EAC9D,CAAC;CACL;CAGF,OAAO;EACL,GAAG;EACH,SAAS,OAAO,OAAgB,YAAsC;GACpE,MAAM,aAAa,iBAAiB,QAAQ,YAAY,WAAW;GACnE,MAAM,aAAa,eAAe;IAChC;IACA,QAAQ,gBAAgB,cAAc;IACtC;IACA;IACA;GACF,CAAC;GAED,KAAI,MADmB,cAAc,aAAa,UAAU,IAC9C,WAAW,kBACvB,MAAM,IAAI,gCAAgC,UAAU;GAGtD,MAAM,SAAS,MAAM,QAAQ,OAAO;IAClC,GAAG;IACH,SAAS,WAAW;IACpB,gBAAgB,WAAW;IAC3B,aAAa,WAAW;IACxB,GAAI,QAAQ,gBAAgB,KAAA,IACxB,CAAC,IACD,EAAE,QAAQ,QAAQ,YAAY;IAClC;GACF,CAAC;GACD,MAAM,cAAc,YAAY;IAAE,GAAG;IAAY;GAAO,CAAC;GACzD,OAAO;EACT;CACF;AACF;AAEA,SAAS,2BAA2B,OAKlC;CACA,OACE,OAAO,UAAU,YACjB,UAAU,QACV,aAAa,SACb,OAAO,MAAM,YAAY;AAE7B;AAcA,SAAS,eAAe,EACtB,OACA,QACA,YACA,eACA,YAOiC;CACjC,OAAO;EACL,SAAS,cAAc;EACvB,gBAAgB,GAAG,cAAc,MAAM,GAAG;EAC1C;EACA;EACA;EACA;CACF;AACF;AAEA,SAAS,gBAAgB,gBAAiD;CACxE,IACE,OAAO,mBAAmB,YAC1B,mBAAmB,QACnB,iBAAiB,kBACjB,kBAAkB,eAAe,WAAW,GAE5C,OAAO,eAAe;CAGxB,OAAO;AACT;AAEA,SAAS,kBAAkB,OAAiD;CAC1E,OACE,UAAU,gBAAgB,UAAU,qBAAqB,UAAU;AAEvE;AAEA,SAAS,4BACP,SACA,aACuB;CACvB,IAAI,OAAO,QAAQ,YAAY,UAC7B,OAAO;CAGT,OAAO;EACL,GAAG;EACH,SAAS,QAAQ,QAAQ,KAAK,SAC5B,gBAAgB,OACZ;GACE,GAAG;GACH,YAAY,iBAAiB,KAAK,YAAY,WAAW;EAC3D,IACA,IACN;CACF;AACF;AAEA,SAAS,yBACP,SACA,aACkB;CAClB,OAAO;EACL,GAAG;EACH,SAAS,QAAQ,QAAQ,KAAK,SAC5B,gBAAgB,OACZ;GACE,GAAG;GACH,YAAY,iBAAiB,KAAK,YAAY,WAAW;EAC3D,IACA,IACN;CACF;AACF;AAEA,SAAS,iBACP,YACA,aACQ;CACR,IAAI,wBAAwB,KAAK,UAAU,GACzC,OAAO;CAGT,MAAM,WAAW,YAAY,IAAI,UAAU;CAC3C,IAAI,UACF,OAAO;CAGT,MAAM,YAAY,iBAAiB;CACnC,YAAY,IAAI,YAAY,SAAS;CACrC,OAAO;AACT;AAEA,SAAS,mBAA2B;CAClC,OAAO,GAAG,mBAAmB,OAAO,WAAW,EAAE,WAAW,KAAK,EAAE;AACrE"}

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,42 @@
+import { RuntimeLlmContext } from "./llm.js";
+import { InputEventMeta, InputSource } from "./session/input-meta-types.js";
+import { UserMessage, UserText } from "./session/input.js";
+import { AgentEvent, RuntimeInput } from "./session/events.js";
+
+//#region src/plugins.d.ts
+type MaybePromise<T> = PromiseLike<T> | T;
+type AgentEventHistory = RuntimeLlmContext["history"];
+type InterceptableAgentEvent = RuntimeInput | UserMessage | UserText;
+type AgentPluginInterceptResult = {
+  readonly action: "continue";
+} | {
+  readonly action: "handled";
+} | {
+  readonly action: "transform";
+  readonly event: InterceptableAgentEvent;
+};
+type AgentPluginResult = AgentPluginInterceptResult | undefined;
+interface AgentEventContext {
+  readonly event: AgentEvent;
+  readonly history: AgentEventHistory;
+  readonly signal?: AbortSignal;
+}
+interface AgentPlugin {
+  readonly events?: {
+    /** @deprecated Use top-level `on`. */readonly on?: (context: AgentEventContext) => MaybePromise<void>;
+  };
+  readonly name?: string;
+  readonly on?: (context: AgentEventContext) => MaybePromise<AgentPluginResult>;
+}
+type PluginPipelineResult = {
+  readonly event: AgentEvent;
+  readonly kind: "emit";
+} | {
+  readonly kind: "handled";
+};
+declare function runPluginsForEvent(plugins: readonly AgentPlugin[], context: AgentEventContext, options?: {
+  readonly observeOnly?: boolean;
+}): Promise<PluginPipelineResult>;
+//#endregion
+export { AgentEventContext, AgentPlugin, AgentPluginInterceptResult, AgentPluginResult, InterceptableAgentEvent, PluginPipelineResult, runPluginsForEvent };
+//# sourceMappingURL=plugins.d.ts.map

package/dist/plugins.js

@@ -0,0 +1,43 @@
+//#region src/plugins.ts
+function runPluginsForEvent(plugins, context, options = {}) {
+	return runPluginPipeline(plugins, context, options.observeOnly === true);
+}
+function isInterceptableEvent(event) {
+	return event.type === "user-text" || event.type === "user-message" || event.type === "runtime-input";
+}
+function resolvePluginHandler(plugin) {
+	if (plugin.on) return plugin.on;
+	const legacyHandler = plugin.events?.on;
+	if (!legacyHandler) return;
+	return (legacyContext) => Promise.resolve(legacyHandler(legacyContext)).then(() => void 0);
+}
+function normalizeInterceptResult(result) {
+	if (result === void 0) return;
+	if (result.action === "continue") return result;
+	if (result.action === "handled") return result;
+	if (result.action === "transform") return result;
+}
+async function runPluginPipeline(plugins, context, observeOnly) {
+	let currentEvent = context.event;
+	for (const plugin of plugins) {
+		const handler = resolvePluginHandler(plugin);
+		if (!handler) continue;
+		const result = await handler({
+			...context,
+			event: currentEvent
+		});
+		if (observeOnly || !isInterceptableEvent(currentEvent)) continue;
+		const intercept = normalizeInterceptResult(result);
+		if (!intercept || intercept.action === "continue") continue;
+		if (intercept.action === "handled") return { kind: "handled" };
+		currentEvent = intercept.event;
+	}
+	return {
+		kind: "emit",
+		event: currentEvent
+	};
+}
+//#endregion
+export { runPluginsForEvent };
+
+//# 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 {\n  AgentEvent,\n  RuntimeInput,\n  UserMessage,\n  UserText,\n} from \"./session/events\";\n\nexport type { InputEventMeta, InputSource } from \"./session/input-meta-types\";\n\ntype MaybePromise<T> = PromiseLike<T> | T;\ntype AgentEventHistory = RuntimeLlmContext[\"history\"];\n\nexport type InterceptableAgentEvent = RuntimeInput | UserMessage | UserText;\n\nexport type AgentPluginInterceptResult =\n  | { readonly action: \"continue\" }\n  | { readonly action: \"handled\" }\n  | { readonly action: \"transform\"; readonly event: InterceptableAgentEvent };\n\nexport type AgentPluginResult = AgentPluginInterceptResult | undefined;\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    /** @deprecated Use top-level `on`. */\n    readonly on?: (context: AgentEventContext) => MaybePromise<void>;\n  };\n  readonly name?: string;\n  readonly on?: (context: AgentEventContext) => MaybePromise<AgentPluginResult>;\n}\n\nexport type PluginPipelineResult =\n  | { readonly event: AgentEvent; readonly kind: \"emit\" }\n  | { readonly kind: \"handled\" };\n\nexport function runEventPlugins(\n  plugins: readonly AgentPlugin[],\n  context: AgentEventContext\n): Promise<void> {\n  return runPluginsForEvent(plugins, context, { observeOnly: true }).then(\n    () => undefined\n  );\n}\n\nexport function runPluginsForEvent(\n  plugins: readonly AgentPlugin[],\n  context: AgentEventContext,\n  options: { readonly observeOnly?: boolean } = {}\n): Promise<PluginPipelineResult> {\n  return runPluginPipeline(plugins, context, options.observeOnly === true);\n}\n\nfunction isInterceptableEvent(\n  event: AgentEvent\n): event is InterceptableAgentEvent {\n  return (\n    event.type === \"user-text\" ||\n    event.type === \"user-message\" ||\n    event.type === \"runtime-input\"\n  );\n}\n\nfunction resolvePluginHandler(\n  plugin: AgentPlugin\n):\n  | ((context: AgentEventContext) => MaybePromise<AgentPluginResult>)\n  | undefined {\n  if (plugin.on) {\n    return plugin.on;\n  }\n\n  const legacyHandler = plugin.events?.on;\n  if (!legacyHandler) {\n    return;\n  }\n\n  return (legacyContext) =>\n    Promise.resolve(legacyHandler(legacyContext)).then(() => undefined);\n}\n\nfunction normalizeInterceptResult(\n  result: AgentPluginResult | undefined\n): AgentPluginInterceptResult | undefined {\n  if (result === undefined) {\n    return;\n  }\n\n  if (result.action === \"continue\") {\n    return result;\n  }\n\n  if (result.action === \"handled\") {\n    return result;\n  }\n\n  if (result.action === \"transform\") {\n    return result;\n  }\n\n  return;\n}\n\nasync function runPluginPipeline(\n  plugins: readonly AgentPlugin[],\n  context: AgentEventContext,\n  observeOnly: boolean\n): Promise<PluginPipelineResult> {\n  let currentEvent = context.event;\n\n  for (const plugin of plugins) {\n    const handler = resolvePluginHandler(plugin);\n    if (!handler) {\n      continue;\n    }\n\n    const result = await handler({ ...context, event: currentEvent });\n    if (observeOnly || !isInterceptableEvent(currentEvent)) {\n      continue;\n    }\n\n    const intercept = normalizeInterceptResult(result);\n    if (!intercept || intercept.action === \"continue\") {\n      continue;\n    }\n\n    if (intercept.action === \"handled\") {\n      return { kind: \"handled\" };\n    }\n\n    currentEvent = intercept.event;\n  }\n\n  return { kind: \"emit\", event: currentEvent };\n}\n"],"mappings":";AAkDA,SAAgB,mBACd,SACA,SACA,UAA8C,CAAC,GAChB;CAC/B,OAAO,kBAAkB,SAAS,SAAS,QAAQ,gBAAgB,IAAI;AACzE;AAEA,SAAS,qBACP,OACkC;CAClC,OACE,MAAM,SAAS,eACf,MAAM,SAAS,kBACf,MAAM,SAAS;AAEnB;AAEA,SAAS,qBACP,QAGY;CACZ,IAAI,OAAO,IACT,OAAO,OAAO;CAGhB,MAAM,gBAAgB,OAAO,QAAQ;CACrC,IAAI,CAAC,eACH;CAGF,QAAQ,kBACN,QAAQ,QAAQ,cAAc,aAAa,CAAC,EAAE,WAAW,KAAA,CAAS;AACtE;AAEA,SAAS,yBACP,QACwC;CACxC,IAAI,WAAW,KAAA,GACb;CAGF,IAAI,OAAO,WAAW,YACpB,OAAO;CAGT,IAAI,OAAO,WAAW,WACpB,OAAO;CAGT,IAAI,OAAO,WAAW,aACpB,OAAO;AAIX;AAEA,eAAe,kBACb,SACA,SACA,aAC+B;CAC/B,IAAI,eAAe,QAAQ;CAE3B,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,UAAU,qBAAqB,MAAM;EAC3C,IAAI,CAAC,SACH;EAGF,MAAM,SAAS,MAAM,QAAQ;GAAE,GAAG;GAAS,OAAO;EAAa,CAAC;EAChE,IAAI,eAAe,CAAC,qBAAqB,YAAY,GACnD;EAGF,MAAM,YAAY,yBAAyB,MAAM;EACjD,IAAI,CAAC,aAAa,UAAU,WAAW,YACrC;EAGF,IAAI,UAAU,WAAW,WACvB,OAAO,EAAE,MAAM,UAAU;EAG3B,eAAe,UAAU;CAC3B;CAEA,OAAO;EAAE,MAAM;EAAQ,OAAO;CAAa;AAC7C"}

package/dist/session/delegate-input.d.ts

@@ -0,0 +1,9 @@
+import { UserInput } from "./input.js";
+
+//#region src/session/delegate-input.d.ts
+declare function delegateUserInput(prompt: unknown, options?: {
+  readonly delegateToolName?: string;
+}): UserInput;
+//#endregion
+export { delegateUserInput };
+//# sourceMappingURL=delegate-input.d.ts.map

package/dist/session/delegate-input.js

@@ -0,0 +1,16 @@
+import { attachInputMeta } from "./input-meta.js";
+//#region src/session/delegate-input.ts
+function delegateUserInput(prompt, options = {}) {
+	if (typeof prompt !== "string") throw new TypeError("Delegate prompt must be a plain string.");
+	return attachInputMeta({
+		type: "user-text",
+		text: prompt
+	}, {
+		delegateToolName: options.delegateToolName,
+		source: "delegate"
+	});
+}
+//#endregion
+export { delegateUserInput };
+
+//# sourceMappingURL=delegate-input.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delegate-input.js","names":[],"sources":["../../src/session/delegate-input.ts"],"sourcesContent":["import type { UserInput } from \"./input\";\nimport { attachInputMeta } from \"./input-meta\";\n\nexport function delegateUserInput(\n  prompt: unknown,\n  options: { readonly delegateToolName?: string } = {}\n): UserInput {\n  if (typeof prompt !== \"string\") {\n    throw new TypeError(\"Delegate prompt must be a plain string.\");\n  }\n\n  return attachInputMeta(\n    {\n      type: \"user-text\",\n      text: prompt,\n    },\n    {\n      delegateToolName: options.delegateToolName,\n      source: \"delegate\",\n    }\n  );\n}\n"],"mappings":";;AAGA,SAAgB,kBACd,QACA,UAAkD,CAAC,GACxC;CACX,IAAI,OAAO,WAAW,UACpB,MAAM,IAAI,UAAU,yCAAyC;CAG/D,OAAO,gBACL;EACE,MAAM;EACN,MAAM;CACR,GACA;EACE,kBAAkB,QAAQ;EAC1B,QAAQ;CACV,CACF;AACF"}

package/dist/session/events.d.ts

@@ -1,3 +1,4 @@
+import { InputEventMeta, InputSource } from "./input-meta-types.js";
 import { UserInput, UserMessage, UserMessageContent, UserMessageContentPart, UserMessageFileData, UserMessageFilePart, UserMessageImagePart, UserMessageTextPart, UserText, UserTextContent } from "./input.js";
 
 //#region src/session/events.d.ts
@@ -7,6 +8,7 @@ interface RuntimeInput {
    * This is distinct from human-originated user-text and user-message input.
    */
   input: UserInput;
+  meta?: InputEventMeta;
   placement: "turn-start" | "step-start" | "step-end";
   type: "runtime-input";
 }
@@ -30,7 +32,6 @@ interface ToolResult {
   toolName: string;
   type: "tool-result";
 }
-type SubagentJobStatus = "aborted" | "cancelled" | "completed" | "error" | "pending" | "running";
 type AgentEvent = /** User input was accepted into the session queue. */UserText /** User multipart input was accepted into the session queue. */ | UserMessage /** Runtime/API-originated input inserted into the current turn, not human input. */ | RuntimeInput /** A queued user input started running as a turn. */ | {
   type: "turn-start";
 } /** The active turn was interrupted before normal completion. */ | {
@@ -42,29 +43,49 @@ type AgentEvent = /** User input was accepted into the session queue. */UserText
   type: "turn-end";
 } /** One model/tool-loop iteration started within the active turn. */ | {
   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;
-  run_in_background: boolean;
-  subagent: string;
-  task_id?: string;
-  type: "subagent-job-start";
-} | {
-  eventType?: AgentEvent["type"];
-  status: SubagentJobStatus;
-  subagent: string;
-  task_id: string;
-  type: "subagent-job-update";
-} | {
-  error?: string;
-  eventCount: number;
-  status: Exclude<SubagentJobStatus, "pending" | "running">;
-  subagent: string;
-  task_id?: string;
-  type: "subagent-job-end";
-} /** One model/tool-loop iteration finished within the active turn. */ | {
+} /** 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 /** One model/tool-loop iteration finished within the active turn. */ | {
   type: "step-end";
 };
 type AgentEventListener = (event: AgentEvent) => void;
+declare const visibleAgentEventTypes: {
+  "assistant-text": true;
+  "user-message": true;
+  "user-text": true;
+};
+declare const lifecycleAgentEventTypes: {
+  "step-end": true;
+  "step-start": true;
+  "turn-abort": true;
+  "turn-end": true;
+  "turn-error": true;
+  "turn-start": true;
+};
+declare const toolAgentEventTypes: {
+  "tool-call": true;
+  "tool-result": true;
+};
+declare const telemetryAgentEventTypes: {
+  "assistant-reasoning": true;
+  "runtime-input": true;
+};
+type VisibleAgentEvent = Extract<AgentEvent, {
+  type: keyof typeof visibleAgentEventTypes;
+}>;
+type LifecycleAgentEvent = Extract<AgentEvent, {
+  type: keyof typeof lifecycleAgentEventTypes;
+}>;
+type ToolAgentEvent = Extract<AgentEvent, {
+  type: keyof typeof toolAgentEventTypes;
+}>;
+type TelemetryAgentEvent = Extract<AgentEvent, {
+  type: keyof typeof telemetryAgentEventTypes;
+}>;
+type ControlAgentEvent = Exclude<AgentEvent, VisibleAgentEvent>;
+declare function isVisibleAgentEvent(event: AgentEvent): event is VisibleAgentEvent;
+declare function isLifecycleAgentEvent(event: AgentEvent): event is LifecycleAgentEvent;
+declare function isToolAgentEvent(event: AgentEvent): event is ToolAgentEvent;
+declare function isTelemetryAgentEvent(event: AgentEvent): event is TelemetryAgentEvent;
+declare function isControlAgentEvent(event: AgentEvent): event is ControlAgentEvent;
 //#endregion
-export { AgentEvent, AgentEventListener, AssistantReasoning, AssistantText, RuntimeInput, ToolCall, ToolResult };
+export { AgentEvent, AgentEventListener, AssistantReasoning, AssistantText, ControlAgentEvent, LifecycleAgentEvent, RuntimeInput, TelemetryAgentEvent, ToolAgentEvent, ToolCall, ToolResult, VisibleAgentEvent, isControlAgentEvent, isLifecycleAgentEvent, isTelemetryAgentEvent, isToolAgentEvent, isVisibleAgentEvent };
 //# sourceMappingURL=events.d.ts.map

package/dist/session/events.js

@@ -0,0 +1,41 @@
+//#region src/session/events.ts
+const visibleAgentEventTypes = {
+	"assistant-text": true,
+	"user-message": true,
+	"user-text": true
+};
+const lifecycleAgentEventTypes = {
+	"step-end": true,
+	"step-start": true,
+	"turn-abort": true,
+	"turn-end": true,
+	"turn-error": true,
+	"turn-start": true
+};
+const toolAgentEventTypes = {
+	"tool-call": true,
+	"tool-result": true
+};
+const telemetryAgentEventTypes = {
+	"assistant-reasoning": true,
+	"runtime-input": true
+};
+function isVisibleAgentEvent(event) {
+	return event.type in visibleAgentEventTypes;
+}
+function isLifecycleAgentEvent(event) {
+	return event.type in lifecycleAgentEventTypes;
+}
+function isToolAgentEvent(event) {
+	return event.type in toolAgentEventTypes;
+}
+function isTelemetryAgentEvent(event) {
+	return event.type in telemetryAgentEventTypes;
+}
+function isControlAgentEvent(event) {
+	return !isVisibleAgentEvent(event);
+}
+//#endregion
+export { isControlAgentEvent, isLifecycleAgentEvent, isTelemetryAgentEvent, isToolAgentEvent, isVisibleAgentEvent };
+
+//# sourceMappingURL=events.js.map

package/dist/session/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","names":[],"sources":["../../src/session/events.ts"],"sourcesContent":["import type { UserInput, UserMessage, UserText } from \"./input\";\nimport type { InputEventMeta } from \"./input-meta-types\";\n\nexport type {\n  UserInput,\n  UserMessage,\n  UserMessageContent,\n  UserMessageContentPart,\n  UserMessageFileData,\n  UserMessageFilePart,\n  UserMessageImagePart,\n  UserMessageTextPart,\n  UserText,\n  UserTextContent,\n} from \"./input\";\nexport type { InputEventMeta, InputSource } from \"./input-meta-types\";\n\nexport interface RuntimeInput {\n  /**\n   * Runtime/API-originated model input inserted into the current turn.\n   * This is distinct from human-originated user-text and user-message input.\n   */\n  input: UserInput;\n  meta?: InputEventMeta;\n  placement: \"turn-start\" | \"step-start\" | \"step-end\";\n  type: \"runtime-input\";\n}\n\nexport interface AssistantText {\n  text: string;\n  type: \"assistant-text\";\n}\nexport interface AssistantReasoning {\n  text: string;\n  type: \"assistant-reasoning\";\n}\nexport interface ToolCall {\n  input: unknown;\n  toolCallId: string;\n  toolName: string;\n  type: \"tool-call\";\n}\nexport interface ToolResult {\n  output: unknown;\n  toolCallId: string;\n  toolName: string;\n  type: \"tool-result\";\n}\n\nexport type AgentEvent =\n  /** User input was accepted into the session queue. */\n  | UserText\n  /** User multipart input was accepted into the session queue. */\n  | UserMessage\n  /** Runtime/API-originated input inserted into the current turn, not human input. */\n  | RuntimeInput\n  /** A queued user input started running as a turn. */\n  | { type: \"turn-start\" }\n  /** The active turn was interrupted before normal completion. */\n  | { type: \"turn-abort\" }\n  /** The active turn hit an unrecoverable runtime failure. */\n  | { type: \"turn-error\"; message: string }\n  /** The active turn completed normally. */\n  | { type: \"turn-end\" }\n  /** One model/tool-loop iteration started within the active turn. */\n  | { type: \"step-start\" }\n  /** The model produced reasoning content. */\n  | AssistantReasoning\n  /** The model produced visible assistant text. */\n  | AssistantText\n  /** The model requested a tool call. */\n  | ToolCall\n  /** A tool call returned a result. */\n  | ToolResult\n  /** One model/tool-loop iteration finished within the active turn. */\n  | { type: \"step-end\" };\n\nexport type AgentEventListener = (event: AgentEvent) => void;\n\nconst visibleAgentEventTypes = {\n  \"assistant-text\": true,\n  \"user-message\": true,\n  \"user-text\": true,\n} satisfies Partial<Record<AgentEvent[\"type\"], true>>;\n\nconst lifecycleAgentEventTypes = {\n  \"step-end\": true,\n  \"step-start\": true,\n  \"turn-abort\": true,\n  \"turn-end\": true,\n  \"turn-error\": true,\n  \"turn-start\": true,\n} satisfies Partial<Record<AgentEvent[\"type\"], true>>;\n\nconst toolAgentEventTypes = {\n  \"tool-call\": true,\n  \"tool-result\": true,\n} satisfies Partial<Record<AgentEvent[\"type\"], true>>;\n\nconst telemetryAgentEventTypes = {\n  \"assistant-reasoning\": true,\n  \"runtime-input\": true,\n} satisfies Partial<Record<AgentEvent[\"type\"], true>>;\n\nexport type VisibleAgentEvent = Extract<\n  AgentEvent,\n  { type: keyof typeof visibleAgentEventTypes }\n>;\nexport type LifecycleAgentEvent = Extract<\n  AgentEvent,\n  { type: keyof typeof lifecycleAgentEventTypes }\n>;\nexport type ToolAgentEvent = Extract<\n  AgentEvent,\n  { type: keyof typeof toolAgentEventTypes }\n>;\nexport type TelemetryAgentEvent = Extract<\n  AgentEvent,\n  { type: keyof typeof telemetryAgentEventTypes }\n>;\nexport type ControlAgentEvent = Exclude<AgentEvent, VisibleAgentEvent>;\n\nexport function isVisibleAgentEvent(\n  event: AgentEvent\n): event is VisibleAgentEvent {\n  return event.type in visibleAgentEventTypes;\n}\n\nexport function isLifecycleAgentEvent(\n  event: AgentEvent\n): event is LifecycleAgentEvent {\n  return event.type in lifecycleAgentEventTypes;\n}\n\nexport function isToolAgentEvent(event: AgentEvent): event is ToolAgentEvent {\n  return event.type in toolAgentEventTypes;\n}\n\nexport function isTelemetryAgentEvent(\n  event: AgentEvent\n): event is TelemetryAgentEvent {\n  return event.type in telemetryAgentEventTypes;\n}\n\nexport function isControlAgentEvent(\n  event: AgentEvent\n): event is ControlAgentEvent {\n  return !isVisibleAgentEvent(event);\n}\n"],"mappings":";AA+EA,MAAM,yBAAyB;CAC7B,kBAAkB;CAClB,gBAAgB;CAChB,aAAa;AACf;AAEA,MAAM,2BAA2B;CAC/B,YAAY;CACZ,cAAc;CACd,cAAc;CACd,YAAY;CACZ,cAAc;CACd,cAAc;AAChB;AAEA,MAAM,sBAAsB;CAC1B,aAAa;CACb,eAAe;AACjB;AAEA,MAAM,2BAA2B;CAC/B,uBAAuB;CACvB,iBAAiB;AACnB;AAoBA,SAAgB,oBACd,OAC4B;CAC5B,OAAO,MAAM,QAAQ;AACvB;AAEA,SAAgB,sBACd,OAC8B;CAC9B,OAAO,MAAM,QAAQ;AACvB;AAEA,SAAgB,iBAAiB,OAA4C;CAC3E,OAAO,MAAM,QAAQ;AACvB;AAEA,SAAgB,sBACd,OAC8B;CAC9B,OAAO,MAAM,QAAQ;AACvB;AAEA,SAAgB,oBACd,OAC4B;CAC5B,OAAO,CAAC,oBAAoB,KAAK;AACnC"}

package/dist/session/input-meta-types.d.ts

@@ -0,0 +1,10 @@
+//#region src/session/input-meta-types.d.ts
+type InputSource = "delegate" | "notify" | "send" | "steer";
+interface InputEventMeta {
+  readonly delegateToolName?: string;
+  readonly source: InputSource;
+  readonly streaming?: "follow-up" | "steer";
+}
+//#endregion
+export { InputEventMeta, InputSource };
+//# sourceMappingURL=input-meta-types.d.ts.map

package/dist/session/input-meta.d.ts

@@ -0,0 +1,13 @@
+import { InputEventMeta, InputSource } from "./input-meta-types.js";
+import { UserInput, UserMessage, UserText } from "./input.js";
+import { AgentEvent, RuntimeInput } from "./events.js";
+
+//#region src/session/input-meta.d.ts
+declare function attachInputMeta(input: UserInput, meta: InputEventMeta): UserText | UserMessage;
+declare function attachRuntimeInputMeta(input: UserInput, placement: RuntimeInput["placement"], meta: InputEventMeta): RuntimeInput;
+declare function stripInputMeta(input: UserInput): UserInput;
+declare function stripEventMeta(event: AgentEvent): AgentEvent;
+declare function userInputFromEvent(event: UserText | UserMessage): UserInput;
+//#endregion
+export { attachInputMeta, attachRuntimeInputMeta, stripEventMeta, stripInputMeta, userInputFromEvent };
+//# sourceMappingURL=input-meta.d.ts.map

package/dist/session/input-meta.js

@@ -0,0 +1,45 @@
+//#region src/session/input-meta.ts
+function attachInputMeta(input, meta) {
+	if (input.type === "user-text") return {
+		...input,
+		meta
+	};
+	return {
+		...input,
+		meta
+	};
+}
+function attachRuntimeInputMeta(input, placement, meta) {
+	return {
+		input: attachInputMeta(input, meta),
+		meta,
+		placement,
+		type: "runtime-input"
+	};
+}
+function stripInputMeta(input) {
+	if (input.type === "user-text") {
+		const { meta: _meta, ...rest } = input;
+		return rest;
+	}
+	const { meta: _meta, ...rest } = input;
+	return rest;
+}
+function stripEventMeta(event) {
+	if (event.type === "user-text" || event.type === "user-message") return stripInputMeta(event);
+	if (event.type === "runtime-input") {
+		const { meta: _meta, ...rest } = event;
+		return {
+			...rest,
+			input: stripInputMeta(event.input)
+		};
+	}
+	return event;
+}
+function userInputFromEvent(event) {
+	return stripInputMeta(event);
+}
+//#endregion
+export { attachInputMeta, attachRuntimeInputMeta, stripEventMeta, stripInputMeta, userInputFromEvent };
+
+//# sourceMappingURL=input-meta.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"input-meta.js","names":[],"sources":["../../src/session/input-meta.ts"],"sourcesContent":["import type { AgentEvent, RuntimeInput } from \"./events\";\nimport type { UserInput, UserMessage, UserText } from \"./input\";\nimport type { InputEventMeta } from \"./input-meta-types\";\n\nexport type { InputEventMeta, InputSource } from \"./input-meta-types\";\n\nexport function attachInputMeta(\n  input: UserInput,\n  meta: InputEventMeta\n): UserText | UserMessage {\n  if (input.type === \"user-text\") {\n    return { ...input, meta };\n  }\n\n  return { ...input, meta };\n}\n\nexport function attachRuntimeInputMeta(\n  input: UserInput,\n  placement: RuntimeInput[\"placement\"],\n  meta: InputEventMeta\n): RuntimeInput {\n  return {\n    input: attachInputMeta(input, meta),\n    meta,\n    placement,\n    type: \"runtime-input\",\n  };\n}\n\nexport function stripInputMeta(input: UserInput): UserInput {\n  if (input.type === \"user-text\") {\n    const { meta: _meta, ...rest } = input;\n    return rest;\n  }\n\n  const { meta: _meta, ...rest } = input;\n  return rest;\n}\n\nexport function stripEventMeta(event: AgentEvent): AgentEvent {\n  if (event.type === \"user-text\" || event.type === \"user-message\") {\n    return stripInputMeta(event);\n  }\n\n  if (event.type === \"runtime-input\") {\n    const { meta: _meta, ...rest } = event;\n    return {\n      ...rest,\n      input: stripInputMeta(event.input),\n    };\n  }\n\n  return event;\n}\n\nexport function userInputFromEvent(event: UserText | UserMessage): UserInput {\n  return stripInputMeta(event);\n}\n"],"mappings":";AAMA,SAAgB,gBACd,OACA,MACwB;CACxB,IAAI,MAAM,SAAS,aACjB,OAAO;EAAE,GAAG;EAAO;CAAK;CAG1B,OAAO;EAAE,GAAG;EAAO;CAAK;AAC1B;AAEA,SAAgB,uBACd,OACA,WACA,MACc;CACd,OAAO;EACL,OAAO,gBAAgB,OAAO,IAAI;EAClC;EACA;EACA,MAAM;CACR;AACF;AAEA,SAAgB,eAAe,OAA6B;CAC1D,IAAI,MAAM,SAAS,aAAa;EAC9B,MAAM,EAAE,MAAM,OAAO,GAAG,SAAS;EACjC,OAAO;CACT;CAEA,MAAM,EAAE,MAAM,OAAO,GAAG,SAAS;CACjC,OAAO;AACT;AAEA,SAAgB,eAAe,OAA+B;CAC5D,IAAI,MAAM,SAAS,eAAe,MAAM,SAAS,gBAC/C,OAAO,eAAe,KAAK;CAG7B,IAAI,MAAM,SAAS,iBAAiB;EAClC,MAAM,EAAE,MAAM,OAAO,GAAG,SAAS;EACjC,OAAO;GACL,GAAG;GACH,OAAO,eAAe,MAAM,KAAK;EACnC;CACF;CAEA,OAAO;AACT;AAEA,SAAgB,mBAAmB,OAA0C;CAC3E,OAAO,eAAe,KAAK;AAC7B"}