@code-yeongyu/senpi 2026.7.5-2 → 2026.7.9

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/eval-tool.ts

@@ -0,0 +1,264 @@
+import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext, ToolDefinition } from "@code-yeongyu/senpi";
+import type { KernelToHostMessage } from "../bridge/protocol.ts";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import { handleCompletionToolCall } from "../completion/tool-bridge.ts";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "../host-sdk.ts";
+import { buildEvalPrompt } from "../prompt/eval-prompt.ts";
+import { renderEvalCall, renderEvalResult } from "./render.ts";
+import {
+	createEvalInputSchema,
+	type EnabledEvalLanguages,
+	type EvalKernel,
+	type EvalKernelManager,
+	type EvalToolDetails,
+	type EvalToolInput,
+	type ExecuteTool,
+	enabledLanguageList,
+} from "./types.ts";
+
+export type { EnabledEvalLanguages, EvalKernel, EvalKernelManager } from "./types.ts";
+
+type ImageContent = { type: "image"; mimeType: string; data: string };
+type ToolContent = AgentToolResult<unknown>["content"][number];
+type TextPart = Extract<ToolContent, { type: "text" }>;
+type RuntimeImagePart = { type: "image"; mimeType: string; data: string };
+
+export interface CreateEvalToolOptions {
+	readonly enabledLanguages: EnabledEvalLanguages;
+	readonly kernelManager: EvalKernelManager;
+	readonly cellTimeoutSeconds: number;
+	readonly executeTool: ExecuteTool;
+	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
+}
+
+interface CellState {
+	readonly cellId: string;
+	readonly language: EvalToolInput["language"];
+	readonly title: string | undefined;
+	readonly signal: AbortSignal | undefined;
+	readonly onUpdate: AgentToolUpdateCallback<EvalToolDetails> | undefined;
+	readonly toolCalls: EvalToolDetails["toolCalls"] extends readonly (infer T)[] ? T[] : never;
+	readonly images: ImageContent[];
+	readonly pendingBridgeCalls: Promise<void>[];
+	output: string;
+	phase: string | undefined;
+	durationMs: number;
+}
+
+export function createEvalTool(
+	options: CreateEvalToolOptions,
+): ToolDefinition<ReturnType<typeof createEvalInputSchema>, EvalToolDetails> {
+	const parameters = createEvalInputSchema(options.enabledLanguages);
+	const prompt = buildEvalPrompt(options.enabledLanguages);
+	const languages = enabledLanguageList(options.enabledLanguages);
+	return {
+		name: "eval",
+		label: "Eval",
+		description: prompt.description,
+		promptSnippet: prompt.promptSnippet,
+		promptGuidelines: [...prompt.promptGuidelines],
+		parameters,
+		renderCall: renderEvalCall,
+		renderResult: renderEvalResult,
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			if (!languages.includes(params.language)) {
+				throw new Error(
+					`Unsupported eval language "${params.language}". Enabled languages: ${languages.join(", ")}`,
+				);
+			}
+			const state: CellState = {
+				cellId: toolCallId,
+				language: params.language,
+				title: params.title,
+				signal,
+				onUpdate,
+				toolCalls: [],
+				images: [],
+				pendingBridgeCalls: [],
+				output: "",
+				phase: undefined,
+				durationMs: 0,
+			};
+			// `kernel` is referenced by the onMessage closure below. Subprocess kernels
+			// (py/rb/jl) emit their `ready` frame synchronously from within getKernel's
+			// await, before the binding is assigned — a `const` here would be in the
+			// temporal dead zone and throw. A pre-declared `let` yields `undefined` for
+			// that pre-ready frame instead (which is a control message, never a tool-call,
+			// so the kernel argument is unused for it).
+			let kernel!: EvalKernel;
+			kernel = await options.kernelManager.getKernel(
+				params.language,
+				(message) => void handleMessage(message, kernel, state, options.executeTool, options.complete, ctx),
+			);
+			if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
+				options.kernelManager.setContext(ctx);
+			}
+			if (params.reset) await kernel.reset();
+			const timeoutMs = Math.floor((params.timeout ?? options.cellTimeoutSeconds) * 1000);
+			const result = await kernel.run({ cellId: toolCallId, code: params.code, timeoutMs });
+			await Promise.all(state.pendingBridgeCalls);
+			return finalizeResult(result, state);
+		},
+	};
+}
+
+async function handleMessage(
+	message: KernelToHostMessage,
+	kernel: EvalKernel,
+	state: CellState,
+	executeTool: ExecuteTool,
+	complete: CreateEvalToolOptions["complete"],
+	ctx: ExtensionContext,
+): Promise<void> {
+	if (message.type === "text") {
+		state.output += message.data;
+		emitUpdate(state, false);
+		return;
+	}
+	if (message.type === "phase") {
+		state.phase = message.title;
+		emitUpdate(state, false);
+		return;
+	}
+	if (message.type === "log") {
+		state.output += `${message.message}\n`;
+		emitUpdate(state, false);
+		return;
+	}
+	if (message.type === "display") {
+		state.images.push({ type: "image", mimeType: message.mimeType, data: message.dataBase64 });
+		state.output += `[display: ${message.mimeType}]\n`;
+		emitUpdate(state, false);
+		return;
+	}
+	if (message.type === "tool-call") {
+		const pending = handleToolCall(message, kernel, state, executeTool, complete, ctx);
+		state.pendingBridgeCalls.push(pending);
+		await pending;
+	}
+}
+
+async function handleToolCall(
+	message: Extract<KernelToHostMessage, { type: "tool-call" }>,
+	kernel: EvalKernel,
+	state: CellState,
+	executeTool: ExecuteTool,
+	complete: CreateEvalToolOptions["complete"],
+	ctx: ExtensionContext,
+): Promise<void> {
+	if (message.toolName === "eval") {
+		const error = "recursive eval is not allowed";
+		state.toolCalls.push({ name: message.toolName, ok: false, error });
+		kernel.deliverToolReply({ type: "tool-reply", callId: message.callId, ok: false, error: { message: error } });
+		return;
+	}
+	if (message.toolName === "completion" && complete) {
+		const result = await handleCompletionToolCall({ message, kernel, complete, ctx });
+		state.toolCalls.push(
+			result.ok ? { name: message.toolName, ok: true } : { name: message.toolName, ok: false, error: result.error },
+		);
+		emitUpdate(state, false);
+		return;
+	}
+	try {
+		const result = await executeTool(message.toolName, message.args, { signal: state.signal });
+		state.toolCalls.push({ name: message.toolName, ok: !toolResultIsError(result) });
+		kernel.deliverToolReply({
+			type: "tool-reply",
+			callId: message.callId,
+			ok: true,
+			value: marshalToolResult(result),
+		});
+	} catch (error) {
+		const messageText = errorMessage(error);
+		state.toolCalls.push({ name: message.toolName, ok: false, error: messageText });
+		kernel.deliverToolReply({
+			type: "tool-reply",
+			callId: message.callId,
+			ok: false,
+			error: { message: messageText },
+		});
+	}
+	emitUpdate(state, false);
+}
+
+function marshalToolResult(result: AgentToolResult<unknown>): unknown {
+	const texts: string[] = [];
+	const images: Array<{ mimeType: string; dataBase64: string }> = [];
+	for (const part of result.content) {
+		if (isTextPart(part)) texts.push(part.text);
+		if (isRuntimeImagePart(part)) images.push({ mimeType: part.mimeType, dataBase64: part.data });
+	}
+	const text = texts.join("\n");
+	const details = isEmptyObject(result.details) ? undefined : result.details;
+	const hasError = toolResultIsError(result);
+	if (images.length === 0 && details === undefined && !hasError) return { text };
+	return { text, details, images, hasError };
+}
+
+function finalizeResult(
+	result: Extract<KernelToHostMessage, { type: "result" }>,
+	state: CellState,
+): AgentToolResult<EvalToolDetails> {
+	state.durationMs = result.durationMs;
+	if (result.ok && result.valueRepr) state.output += `${result.valueRepr}\n`;
+	if (!result.ok) state.output += `${result.error.message}\n`;
+	const truncation = truncateTail(state.output, { maxBytes: DEFAULT_MAX_BYTES, maxLines: DEFAULT_MAX_LINES });
+	const suffix = truncation.truncated
+		? `\n\n[Output truncated: ${truncation.outputLines} of ${truncation.totalLines} lines (${truncation.outputBytes} of ${truncation.totalBytes} bytes).]`
+		: "";
+	const details = detailsFor(state, truncation.truncated, !result.ok);
+	return {
+		content: [{ type: "text", text: `${truncation.content}${suffix}` }, ...state.images],
+		details,
+	};
+}
+
+function detailsFor(state: CellState, truncated: boolean, isError: boolean): EvalToolDetails {
+	return {
+		language: state.language,
+		title: state.title,
+		durationMs: state.durationMs,
+		toolCalls: state.toolCalls,
+		truncated,
+		isError,
+		phase: state.phase,
+	};
+}
+
+function emitUpdate(state: CellState, isError: boolean): void {
+	state.onUpdate?.({
+		content: [{ type: "text", text: state.output }],
+		details: detailsFor(state, false, isError),
+	});
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function isEmptyObject(value: unknown): boolean {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+
+function toolResultIsError(result: AgentToolResult<unknown>): boolean {
+	const details = result.details;
+	return typeof details === "object" && details !== null && "isError" in details && details.isError === true;
+}
+
+function isTextPart(part: ToolContent): part is TextPart {
+	return part.type === "text";
+}
+
+function isRuntimeImagePart(part: unknown): part is RuntimeImagePart {
+	return (
+		typeof part === "object" &&
+		part !== null &&
+		"type" in part &&
+		part.type === "image" &&
+		"mimeType" in part &&
+		typeof part.mimeType === "string" &&
+		"data" in part &&
+		typeof part.data === "string"
+	);
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/render.ts

@@ -0,0 +1,77 @@
+import type { AgentToolResult, ToolDefinition, ToolRenderResultOptions } from "@code-yeongyu/senpi";
+import type { createEvalInputSchema, EvalToolDetails, EvalToolInput } from "./types.ts";
+
+type EvalToolDefinition = ToolDefinition<ReturnType<typeof createEvalInputSchema>, EvalToolDetails>;
+type RenderContext = Parameters<NonNullable<EvalToolDefinition["renderCall"]>>[2];
+type Component = ReturnType<NonNullable<EvalToolDefinition["renderCall"]>>;
+
+class PlainTextComponent {
+	#text = "";
+
+	setText(text: string): void {
+		this.#text = text;
+	}
+
+	render(): string[] {
+		return this.#text ? this.#text.split("\n") : [];
+	}
+
+	invalidate(): void {}
+}
+
+function componentFor(context: RenderContext): PlainTextComponent {
+	const existing = context.lastComponent;
+	if (existing instanceof PlainTextComponent) return existing;
+	return new PlainTextComponent();
+}
+
+function firstCodeLine(code: string | undefined): string {
+	const line = code?.split(/\r?\n/, 1)[0]?.trim();
+	return line && line.length > 0 ? line : "...";
+}
+
+function textOutput(result: AgentToolResult<EvalToolDetails>, showImages: boolean): string {
+	const lines: string[] = [];
+	for (const part of result.content) {
+		if (part.type === "text") lines.push(part.text);
+		else if (showImages && part.type === "image") lines.push(`[image: ${part.mimeType}]`);
+	}
+	return lines.join("\n");
+}
+
+function toolCallLines(details: EvalToolDetails | undefined): string[] {
+	if (!details?.toolCalls || details.toolCalls.length === 0) return [];
+	return details.toolCalls.map((call) => {
+		const status = call.ok ? "ok" : "error";
+		return `- tool.${call.name}: ${status}${call.error ? ` (${call.error})` : ""}`;
+	});
+}
+
+export function renderEvalCall(args: EvalToolInput, _theme: unknown, context: RenderContext): Component {
+	const component = componentFor(context);
+	const title = args.title ? ` ${args.title}` : "";
+	const reset = args.reset ? " reset" : "";
+	const timeout = args.timeout ? ` timeout ${args.timeout}s` : "";
+	component.setText(`eval ${args.language}${title}${reset}${timeout}\n${firstCodeLine(args.code)}`);
+	return component;
+}
+
+export function renderEvalResult(
+	result: AgentToolResult<EvalToolDetails>,
+	options: ToolRenderResultOptions,
+	_theme: unknown,
+	context: Parameters<NonNullable<EvalToolDefinition["renderResult"]>>[3],
+): Component {
+	const component = componentFor(context);
+	const details = result.details;
+	const status = details?.isError ? "error" : options.isPartial ? "running" : "done";
+	const title = details?.title ? ` ${details.title}` : "";
+	const lines = [`eval ${details?.language ?? "?"}${title} ${status}`];
+	const output = textOutput(result, context.showImages).trimEnd();
+	if (output) lines.push("", output);
+	const calls = toolCallLines(details);
+	if (calls.length > 0) lines.push("", ...calls);
+	if (details?.truncated) lines.push("", "[output truncated]");
+	component.setText(lines.join("\n"));
+	return component;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/types.ts

@@ -0,0 +1,85 @@
+import type { AgentToolResult, AgentToolUpdateCallback } from "@code-yeongyu/senpi";
+import { Type } from "typebox";
+import type { HostToKernelMessage, KernelToHostMessage } from "../bridge/protocol.ts";
+
+export const evalLanguageOrder = ["py", "js", "rb", "jl"] as const;
+export type EvalLanguage = (typeof evalLanguageOrder)[number];
+export type EnabledEvalLanguages = Readonly<Record<EvalLanguage, boolean>>;
+
+export function enabledLanguageList(enabled: EnabledEvalLanguages): EvalLanguage[] {
+	return evalLanguageOrder.filter((language) => enabled[language]);
+}
+
+const fullEvalInputSchema = Type.Object({
+	language: Type.Union([Type.Literal("py"), Type.Literal("js"), Type.Literal("rb"), Type.Literal("jl")]),
+	code: Type.String({ description: "Cell body, verbatim." }),
+	title: Type.Optional(Type.String({ description: "Short transcript label." })),
+	timeout: Type.Optional(Type.Number({ minimum: 1, description: "Timeout in seconds." })),
+	reset: Type.Optional(Type.Boolean({ description: "Reset this language kernel before running." })),
+});
+
+export function createEvalInputSchema(enabled: EnabledEvalLanguages): typeof fullEvalInputSchema {
+	const languages = enabledLanguageList(enabled);
+	if (languages.length === 0) throw new Error("eval requires at least one enabled language");
+	const languageSchema =
+		languages.length === 1
+			? Type.Union([Type.Literal(languages[0])])
+			: Type.Union(languages.map((item) => Type.Literal(item)));
+	return Type.Object({
+		language: languageSchema,
+		code: Type.String({ description: "Cell body, verbatim." }),
+		title: Type.Optional(Type.String({ description: "Short transcript label." })),
+		timeout: Type.Optional(Type.Number({ minimum: 1, description: "Timeout in seconds." })),
+		reset: Type.Optional(Type.Boolean({ description: "Reset this language kernel before running." })),
+	}) as typeof fullEvalInputSchema;
+}
+
+export type EvalInputSchema = ReturnType<typeof createEvalInputSchema>;
+export interface EvalToolInput {
+	readonly language: EvalLanguage;
+	readonly code: string;
+	readonly title?: string;
+	readonly timeout?: number;
+	readonly reset?: boolean;
+}
+export type EvalKernelResult = Extract<KernelToHostMessage, { type: "result" }>;
+export type EvalToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;
+
+export interface EvalKernelRunInput {
+	readonly cellId: string;
+	readonly code: string;
+	readonly timeoutMs?: number;
+}
+
+export interface EvalKernel {
+	run(input: EvalKernelRunInput): Promise<EvalKernelResult>;
+	deliverToolReply(message: Extract<HostToKernelMessage, { type: "tool-reply" }>): void;
+	reset(): Promise<void>;
+	close(): Promise<void>;
+}
+
+export interface EvalKernelManager {
+	getKernel(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): Promise<EvalKernel>;
+}
+
+export type ExecuteTool = (
+	toolName: string,
+	params: unknown,
+	options?: { signal?: AbortSignal; onUpdate?: AgentToolUpdateCallback<unknown> },
+) => Promise<AgentToolResult<unknown>>;
+
+export interface EvalToolCallSummary {
+	readonly name: string;
+	readonly ok: boolean;
+	readonly error?: string;
+}
+
+export interface EvalToolDetails {
+	readonly language: EvalLanguage;
+	readonly title?: string;
+	readonly durationMs: number;
+	readonly toolCalls: readonly EvalToolCallSummary[];
+	readonly truncated: boolean;
+	readonly isError?: boolean;
+	readonly phase?: string;
+}

package/node_modules/@earendil-works/pi-agent-core/dist/agent-loop.d.ts

@@ -3,7 +3,7 @@
  * Transforms to Message[] only at the LLM call boundary.
  */
 import { EventStream } from "@earendil-works/pi-ai";
-import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types.ts";
+import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, AgentTool, AgentToolCall, StreamFn } from "./types.ts";
 export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
 /**
  * Start an agent loop with a new prompt message.
@@ -21,4 +21,11 @@ export declare function agentLoop(prompts: AgentMessage[], context: AgentContext
 export declare function agentLoopContinue(context: AgentContext, config: AgentLoopConfig, signal?: AbortSignal, streamFn?: StreamFn): EventStream<AgentEvent, AgentMessage[]>;
 export declare function runAgentLoop(prompts: AgentMessage[], context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal?: AbortSignal, streamFn?: StreamFn): Promise<AgentMessage[]>;
 export declare function runAgentLoopContinue(context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal?: AbortSignal, streamFn?: StreamFn): Promise<AgentMessage[]>;
+export interface PreparedAgentToolCall {
+    toolCall: AgentToolCall;
+    tool: AgentTool;
+    args: unknown;
+}
+export declare function prepareAgentToolCallArguments(tool: AgentTool, toolCall: AgentToolCall): AgentToolCall;
+export declare function prepareAgentToolCall(tool: AgentTool, toolCall: AgentToolCall): PreparedAgentToolCall;
 //# sourceMappingURL=agent-loop.d.ts.map

package/node_modules/@earendil-works/pi-agent-core/dist/agent-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIN,WAAW,EAGX,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EAIZ,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIN,WAAW,EAGX,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EACZ,SAAS,EACT,aAAa,EAEb,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAonBD,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,aAAa,CAYrG;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,qBAAqB,CAOpG"}

package/node_modules/@earendil-works/pi-agent-core/dist/agent-loop.js

@@ -191,6 +191,20 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
 async function streamAssistantResponse(context, config, signal, emit, streamFn) {
     let partialMessage = null;
     let addedPartial = false;
+    // Dedicated controller for the provider request so the loop can tear the
+    // request down itself (idle timeout), not only when the caller aborts.
+    const requestAbortController = new AbortController();
+    let detachCallerAbort;
+    if (signal !== undefined) {
+        if (signal.aborted) {
+            requestAbortController.abort(signal.reason);
+        }
+        else {
+            const onCallerAbort = () => requestAbortController.abort(signal.reason);
+            signal.addEventListener("abort", onCallerAbort, { once: true });
+            detachCallerAbort = () => signal.removeEventListener("abort", onCallerAbort);
+        }
+    }
     try {
         // Apply context transform if configured (AgentMessage[] → AgentMessage[])
         let messages = context.messages;
@@ -211,10 +225,10 @@ async function streamAssistantResponse(context, config, signal, emit, streamFn)
         const response = await streamFunction(config.model, llmContext, {
             ...config,
             apiKey: resolvedApiKey,
-            signal,
+            signal: requestAbortController.signal,
         });
         const iterator = response[Symbol.asyncIterator]();
-        const eventReader = createAssistantEventReader(iterator, config.timeoutMs, signal);
+        const eventReader = createAssistantEventReader(iterator, config.timeoutMs, requestAbortController.signal, (error) => requestAbortController.abort(error));
         try {
             while (true) {
                 const next = await eventReader.next();
@@ -291,9 +305,12 @@ async function streamAssistantResponse(context, config, signal, emit, streamFn)
         await emit({ type: "message_end", message: finalMessage });
         return finalMessage;
     }
+    finally {
+        detachCallerAbort?.();
+    }
 }
 const ABORTED = Symbol("aborted");
-function createAssistantEventReader(iterator, timeoutMs, signal) {
+function createAssistantEventReader(iterator, timeoutMs, signal, onIdleTimeout) {
     const idleTimeoutMs = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
     let removeAbortListener;
     let abortPromise;
@@ -315,12 +332,12 @@ function createAssistantEventReader(iterator, timeoutMs, signal) {
                 void iterator.return?.();
                 return Promise.reject(new Error("Request was aborted"));
             }
-            return readNextAssistantEvent(iterator, idleTimeoutMs, abortPromise);
+            return readNextAssistantEvent(iterator, idleTimeoutMs, abortPromise, onIdleTimeout);
         },
         dispose: () => removeAbortListener?.(),
     };
 }
-async function readNextAssistantEvent(iterator, idleTimeoutMs, abortPromise) {
+async function readNextAssistantEvent(iterator, idleTimeoutMs, abortPromise, onIdleTimeout) {
     if (idleTimeoutMs === undefined && abortPromise === undefined) {
         return iterator.next();
     }
@@ -338,8 +355,12 @@ async function readNextAssistantEvent(iterator, idleTimeoutMs, abortPromise) {
         };
         if (idleTimeoutMs !== undefined) {
             timeout = setTimeout(() => {
+                const error = new StreamIdleTimeoutError(idleTimeoutMs);
                 void iterator.return?.();
-                settle(() => reject(new StreamIdleTimeoutError(idleTimeoutMs)));
+                settle(() => reject(error));
+                // Abort after settling so the failure surfaces as an idle timeout,
+                // not as a generic abort, while the dead request still gets torn down.
+                onIdleTimeout?.(error);
             }, idleTimeoutMs);
         }
         const next = abortPromise ? Promise.race([iterator.next(), abortPromise]) : iterator.next();
@@ -496,7 +517,7 @@ function isSequentialToolCall(currentContext, toolCall) {
 function shouldTerminateToolBatch(finalizedCalls) {
     return finalizedCalls.length > 0 && finalizedCalls.every((finalized) => finalized.result.terminate === true);
 }
-function prepareToolCallArguments(tool, toolCall) {
+export function prepareAgentToolCallArguments(tool, toolCall) {
     if (!tool.prepareArguments) {
         return toolCall;
     }
@@ -509,6 +530,14 @@ function prepareToolCallArguments(tool, toolCall) {
         arguments: preparedArguments,
     };
 }
+export function prepareAgentToolCall(tool, toolCall) {
+    const preparedToolCall = prepareAgentToolCallArguments(tool, toolCall);
+    return {
+        toolCall: preparedToolCall,
+        tool,
+        args: validateToolArguments(tool, preparedToolCall),
+    };
+}
 async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
     const tool = currentContext.tools?.find((t) => t.name === toolCall.name);
     if (!tool) {
@@ -520,12 +549,12 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
         };
     }
     try {
-        const preparedToolCall = prepareToolCallArguments(tool, toolCall);
-        const validatedArgs = validateToolArguments(tool, preparedToolCall);
+        const preparedToolCall = prepareAgentToolCall(tool, toolCall);
+        const validatedArgs = preparedToolCall.args;
         if (config.beforeToolCall) {
             const beforeResult = await config.beforeToolCall({
                 assistantMessage,
-                toolCall,
+                toolCall: preparedToolCall.toolCall,
                 args: validatedArgs,
                 context: currentContext,
             }, signal);
@@ -556,7 +585,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
         }
         return {
             kind: "prepared",
-            toolCall,
+            toolCall: preparedToolCall.toolCall,
             tool,
             args: validatedArgs,
         };