@code-yeongyu/senpi 2026.7.17 → 2026.7.20

package/docs/tui.md

@@ -90,19 +90,32 @@ Without this propagation, typing with an IME (Chinese, Japanese, Korean, etc.) w
 
 ```typescript
 pi.on("session_start", async (_event, ctx) => {
-  const handle = ctx.ui.custom(myComponent);
-  // handle.requestRender() - trigger re-render
-  // handle.close() - restore normal UI
+  const result = await ctx.ui.custom<string | null>((tui, theme, keybindings, done) =>
+    new MyComponent({
+      theme,
+      keybindings,
+      onChange: () => tui.requestRender(),
+      onSelect: (value) => done(value),
+      onCancel: () => done(null),
+    })
+  );
 });
 ```
 
-**In custom tools** via `pi.ui.custom()`:
+**In custom tools** via `ctx.ui.custom()`:
 
 ```typescript
-async execute(toolCallId, params, onUpdate, ctx, signal) {
-  const handle = pi.ui.custom(myComponent);
-  // ...
-  handle.close();
+async execute(toolCallId, params, signal, onUpdate, ctx) {
+  const result = await ctx.ui.custom<string | null>((tui, theme, keybindings, done) =>
+    new MyComponent({
+      theme,
+      keybindings,
+      onChange: () => tui.requestRender(),
+      onSelect: (value) => done(value),
+      onCancel: () => done(null),
+    })
+  );
+  // Use result...
 }
 ```
 
@@ -374,24 +387,26 @@ Usage in an extension:
 ```typescript
 pi.registerCommand("pick", {
   description: "Pick an item",
-  handler: async (args, ctx) => {
+  handler: async (_args, ctx) => {
     const items = ["Option A", "Option B", "Option C"];
-    const selector = new MySelector(items);
-    
-    let handle: { close: () => void; requestRender: () => void };
-    
-    await new Promise<void>((resolve) => {
-      selector.onSelect = (item) => {
-        ctx.ui.notify(`Selected: ${item}`, "info");
-        handle.close();
-        resolve();
-      };
-      selector.onCancel = () => {
-        handle.close();
-        resolve();
+    const selected = await ctx.ui.custom<string | null>((tui, _theme, _keybindings, done) => {
+      const selector = new MySelector(items);
+      selector.onSelect = done;
+      selector.onCancel = () => done(null);
+
+      return {
+        render: (width) => selector.render(width),
+        handleInput: (data) => {
+          selector.handleInput(data);
+          tui.requestRender();
+        },
+        invalidate: () => selector.invalidate(),
       };
-      handle = ctx.ui.custom(selector);
     });
+
+    if (selected !== null) {
+      ctx.ui.notify(`Selected: ${selected}`, "info");
+    }
   }
 });
 ```
@@ -486,7 +501,7 @@ class CachedComponent {
 }
 ```
 
-Call `invalidate()` when state changes, then `handle.requestRender()` to trigger re-render.
+Call `invalidate()` when state changes, then use the injected `tui.requestRender()` to trigger re-render.
 
 ## Invalidation and Theme Changes
 
@@ -885,9 +900,9 @@ class VimEditor extends CustomEditor {
 
 export default function (pi: ExtensionAPI) {
   pi.on("session_start", (_event, ctx) => {
-    // Factory receives theme and keybindings from the app
+    // Factory receives the TUI, theme, and keybindings from the app
     ctx.ui.setEditorComponent((tui, theme, keybindings) =>
-      new VimEditor(theme, keybindings)
+      new VimEditor(tui, theme, keybindings)
     );
   });
 }

package/docs/usage.md

@@ -37,6 +37,7 @@ Type `/` in the editor to open command completion. Extensions can register custo
 | Command | Description |
 |---------|-------------|
 | `/login`, `/logout` | Manage OAuth or API-key credentials |
+| [`/llama`](llama-cpp.md) | Download, load, and unload llama.cpp router models |
 | `/model` | Switch models |
 | `/scoped-models` | Enable/disable models for Ctrl+P cycling |
 | `/settings` | Thinking level, theme, message delivery, transport |

package/examples/AGENTS.md

@@ -9,6 +9,7 @@ extensions/        Tools, commands, UI, providers, hooks, resources
 extensions/*/      Multi-file examples and nested private workspaces
 sdk/               Programmatic SDK usage
 rpc-extension-ui.ts RPC-compatible extension UI example
+extensions/kimi-deferred-tools.ts  Deferred tool discovery/activation example
 ```
 
 ## CONVENTIONS
@@ -18,6 +19,8 @@ rpc-extension-ui.ts RPC-compatible extension UI example
 - Extension factories have no top-level runtime side effects. Register work through the public `pi.*` API and lifecycle events.
 - New interactive examples should use configurable keybindings and themed TUI helpers. Existing demos may keep fixed controls when the control scheme is part of the example. Direct terminal writes belong only in examples explicitly teaching a terminal protocol; ordinary SDK examples may use normal stdout.
 - Tool string enums use the shared `StringEnum` helper for provider compatibility.
+- SDK examples should use `ModelRuntime` for auth/custom-model/session composition; deprecated static catalog helpers import from `@earendil-works/pi-ai/compat`.
+- Deferred-tool examples preserve the Kimi flow: expose search first, activate via `pi.setActiveTools()`, and register lifecycle work in `session_start`.
 - Stateful examples persist reconstructable state in session entries or tool-result details so fork/resume behavior remains valid.
 - Nested example packages are private workspaces with exact-pinned dependencies. Treat their manifests and lock impact as production dependency changes.
 

package/examples/extensions/README.md

@@ -162,7 +162,7 @@ export default function (pi: ExtensionAPI) {
     parameters: Type.Object({
       name: Type.String({ description: "Name to greet" }),
     }),
-    async execute(toolCallId, params, onUpdate, ctx, signal) {
+    async execute(toolCallId, params, signal, onUpdate, ctx) {
       return {
         content: [{ type: "text", text: `Hello, ${params.name}!` }],
         details: {},

package/node_modules/@code-yeongyu/senpi-codemode/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Changelog
 
+## [2026.7.20] - 2026-07-20
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Fixed the Python kernel's `tool.<name>()` proxy injecting an omp-only `i` ("py prelude") intent field into every bridged tool call. Senpi tool schemas never declare `i`, so strict tools (`additionalProperties: false`, e.g. `web_search`) rejected every eval-bridged call with `Validation failed for tool …: must not have additional properties`. Args now pass through verbatim, matching the JS/Ruby/Julia preludes.
+
+### Removed
+
+## [2026.7.17-5] - 2026-07-17
+
+### Breaking Changes
+
+### Added
+
+### Changed
+- Changed the Kimi K-series eval prompt dialect to make eval-first, whole-step parallel batching the default: strong positive emphasis now directs multi-call work into one `eval` cell, parallelizes independent calls, handles failures in-kernel, and returns distilled facts.
+
+### Fixed
+
+### Removed
+
+## [2026.7.17-4] - 2026-07-17
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.7.17-3] - 2026-07-17
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.7.17-2] - 2026-07-17
+
+### Added
+
+- Added a host-sizing note to the `eval` prompt: the extension now passes a preformatted host line (platform, arch, CPU model, core count) at registration so the prompt tells the model to size `parallel(thunks)` pools to the local cores and keep shell commands platform-appropriate.
+- Added model-aware eval-first batching emphasis: the `eval` tool description and its system-prompt guideline now render in a dialect selected by the active model id (Claude/GLM, OpenAI, Kimi, and a maximum-emphasis default fallback), re-registering on `model_select` so mid-session model switches pick up the matching dialect.
+
+### Changed
+
+### Fixed
+
 ## [2026.7.17] - 2026-07-17
 
 ### Added

package/node_modules/@code-yeongyu/senpi-codemode/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.7.17",
+	"version": "2026.7.20",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "7.29.7",
-		"@earendil-works/pi-ai": "^2026.7.17",
+		"@earendil-works/pi-ai": "^2026.7.20",
 		"typebox": "1.1.38"
 	},
 	"peerDependencies": {
 		"@code-yeongyu/senpi": "*"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.7.17"
+		"@code-yeongyu/senpi": "2026.7.20"
 	},
 	"keywords": [
 		"senpi",

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

@@ -1,3 +1,4 @@
+import * as os from "node:os";
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "./bridge/protocol.ts";
 import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
@@ -35,6 +36,8 @@ const SESSION_LIFECYCLE_EVENTS = [
 
 type SessionLifecycleEvent = (typeof SESSION_LIFECYCLE_EVENTS)[number];
 
+type CodemodeEvent = SessionLifecycleEvent | "model_select";
+
 type TrackedExecution = {
 	readonly promise: Promise<unknown>;
 	readonly controller: AbortController;
@@ -51,7 +54,7 @@ type SessionRuntime = {
 
 export interface CodemodeExtensionAPI {
 	registerTool(tool: ReturnType<typeof createEvalTool>): void;
-	on(event: SessionLifecycleEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
+	on(event: CodemodeEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
 	executeTool: AgentExecuteTool;
 	getActiveTools(): string[];
 }
@@ -75,6 +78,32 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 	const manager = new SessionManagerProxy();
 	const complete = options.complete ?? ((request, ctx) => createCompletionHandler()(ctx)(request));
 	const renderers = { renderCall: renderEvalCall, renderResult: renderEvalResult };
+	let activeRuntime: SessionRuntime | undefined;
+	let activeModelId: string | undefined;
+	const registerEvalForRuntime = (runtime: SessionRuntime, modelId: string | undefined): void => {
+		pi.registerTool(
+			createEvalTool({
+				enabledLanguages: runtime.enabledLanguages,
+				kernelManager: manager,
+				cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
+				executeTool: runtime.executeTool,
+				complete,
+				settings: runtime.settings,
+				artifactsDir: runtime.artifactsDir,
+				executionTracker: manager,
+				renderers,
+				spawns: runtime.spawns,
+				spawnDefaultAgent: runtime.settings.taskTools.task,
+				hostLine: hostLine(),
+				...(modelId === undefined ? {} : { modelId }),
+			}),
+		);
+	};
+	const dropRuntime = async (): Promise<void> => {
+		activeRuntime = undefined;
+		activeModelId = undefined;
+		await manager.dispose();
+	};
 	pi.registerTool(
 		createEvalTool({
 			enabledLanguages: { py: true, js: true, rb: true, jl: true },
@@ -85,6 +114,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			settings: defaultCodemodeSettings,
 			executionTracker: manager,
 			renderers,
+			hostLine: hostLine(),
 		}),
 	);
 
@@ -92,25 +122,35 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		const generation = manager.beginReplacement();
 		const runtime = await createRuntime(pi, ctx, event, complete, options);
 		if (!(await manager.replace(generation, runtime.manager))) return;
-		pi.registerTool(
-			createEvalTool({
-				enabledLanguages: runtime.enabledLanguages,
-				kernelManager: manager,
-				cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
-				executeTool: runtime.executeTool,
-				complete,
-				settings: runtime.settings,
-				artifactsDir: runtime.artifactsDir,
-				executionTracker: manager,
-				renderers,
-				spawns: runtime.spawns,
-				spawnDefaultAgent: runtime.settings.taskTools.task,
-			}),
-		);
+		activeRuntime = runtime;
+		activeModelId = ctx.model?.id;
+		registerEvalForRuntime(runtime, activeModelId);
+	});
+	pi.on("session_shutdown", async () => dropRuntime());
+	pi.on("session_before_switch", async () => dropRuntime());
+	pi.on("session_before_fork", async () => dropRuntime());
+	pi.on("model_select", async (event) => {
+		const runtime = activeRuntime;
+		if (runtime === undefined) return;
+		const modelId = modelIdFrom(event);
+		if (modelId === undefined || modelId === activeModelId) return;
+		activeModelId = modelId;
+		registerEvalForRuntime(runtime, modelId);
 	});
-	pi.on("session_shutdown", async () => manager.dispose());
-	pi.on("session_before_switch", async () => manager.dispose());
-	pi.on("session_before_fork", async () => manager.dispose());
+}
+
+function hostLine(): string {
+	const cpu = os.cpus()[0]?.model?.trim();
+	return [`${os.platform()} ${os.arch()}`, cpu, `${os.availableParallelism()} cores`]
+		.filter((part): part is string => !!part)
+		.join(" \u00b7 ");
+}
+
+function modelIdFrom(event: unknown): string | undefined {
+	if (typeof event !== "object" || event === null || !("model" in event)) return undefined;
+	const model = event.model;
+	if (typeof model !== "object" || model === null || !("id" in model)) return undefined;
+	return typeof model.id === "string" ? model.id : undefined;
 }
 
 class SessionManagerProxy implements CodemodeSessionManager, EvalExecutionTracker {

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/py/prelude.py

@@ -326,7 +326,6 @@ class ToolCallable:
                 f"tool.{self._name}(...) expects a dict of arguments (got {type(args).__name__})"
             )
         merged.update(kwargs)
-        merged.setdefault("i", "py prelude")
         return bridge_post(
             "/call",
             {"callId": f"py-{uuid.uuid4()}", "toolName": self._name, "args": merged},

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

@@ -14,6 +14,36 @@ export interface EvalPromptParts {
 export interface EvalPromptOptions {
 	readonly spawns: boolean;
 	readonly spawnDefaultAgent?: string;
+	/** Active model id; selects the emphasis dialect of the batching guidance. */
+	readonly modelId?: string;
+	/** Preformatted host line (e.g. "darwin arm64 · Apple M5 Max · 18 cores"); enables the host-sizing note. */
+	readonly hostLine?: string;
+}
+
+/** Prompt dialect for the eval-first batching emphasis. */
+export type EvalEmphasisStyle = "default" | "claude" | "codex" | "kimi";
+
+const CLAUDE_MODEL_RE = /(^|[/.:])claude[-.]/i;
+const GLM_MODEL_RE = /(^|[/.:@-])glm[-.]?\d/i;
+const KIMI_MODEL_RE = /(^|[/.:])kimi[-.]/i;
+const OPENAI_MODEL_RE = /(^|[/.:])(gpt|chatgpt|codex)[-.]|(^|[/.:])o[134](?:[-.]|$)/i;
+
+/**
+ * Selects the eval-first batching dialect for a model id:
+ * - `claude`: Claude/GLM — direct imperatives; both are steered most reliably
+ *   by explicit tagged directives (GLM prompting guidance routes to Claude's).
+ * - `codex`: OpenAI reasoning families — terse bounded rules, no emphasis spam.
+ * - `kimi`: Kimi K-series — maximum-emphasis POSITIVE imperatives (uppercase/
+ *   bold DO-framing); all-caps NEVER prohibitions stay out because they make
+ *   K-series overthink instead of comply.
+ * - `default`: everything else (and no model) — maximum-emphasis fallback.
+ */
+export function evalEmphasisStyle(modelId: string | undefined): EvalEmphasisStyle {
+	if (!modelId) return "default";
+	if (CLAUDE_MODEL_RE.test(modelId) || GLM_MODEL_RE.test(modelId)) return "claude";
+	if (KIMI_MODEL_RE.test(modelId)) return "kimi";
+	if (OPENAI_MODEL_RE.test(modelId)) return "codex";
+	return "default";
 }
 
 type ContextValue = string | boolean;
@@ -57,7 +87,24 @@ const EVAL_PROMPT_TEMPLATE = `Run one step of code in a persistent kernel.
 
 Work incrementally: imports in one call, define in the next, test, then use — each its own eval call. Re-run setup ONLY after \`reset\`, a kernel crash, or a \`NameError\`/\`ReferenceError\` proving the state is gone.
 
-**Batch through eval.** One cell replaces many one-shot tool calls: loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time, post-process \`tool.<name>()\` results programmatically, and fan independent calls through \`parallel(thunks)\` within the cell — never one call per turn.
+{{#if styleClaude}}<eval_first_batching>
+\`eval\` is your default execution surface: if a step needs more than one tool call, write ONE cell that performs the whole step — never issue the calls one at a time.
+- Enumerate every lookup the step needs, then run all independent ones simultaneously with \`parallel(thunks)\` inside the cell; keep calls sequential only when one result feeds the next.
+- Write real code around the calls: loop or comprehend over file sets with \`read()\`/stdlib, branch per case, and wrap risky calls in try/except so one failure degrades only its item — recover or retry inside the cell, keep the batch alive.
+- Post-process \`tool.<name>()\` results programmatically and return distilled facts, not raw dumps.
+</eval_first_batching>{{/if}}{{#if styleCodex}}Route multi-call steps through eval: one cell per step, independent lookups dispatched together via \`parallel(thunks)\`; keep work sequential only when one result determines the next action.
+- Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically.
+- Wrap failable calls in try/except inside the cell; a failed item degrades only itself. After two distinct failed strategies for the same fact, fall back to direct tool calls.
+- Reduce large results in-kernel to the facts the task needs before returning.{{/if}}{{#if styleKimi}}**EVAL IS YOUR SUPERPOWER — MAKE IT YOUR DEFAULT WAY TO ACT.** Before any step, think: "how do I execute this WHOLE step in ONE parallelized cell?" — then write that ONE cell.
+- **BATCH EVERYTHING AT ONCE:** enumerate EVERY independent lookup the step needs and dispatch them ALL simultaneously with \`parallel(thunks)\` in that cell; keep calls sequential only when one result feeds the next.
+- **WRITE REAL CODE, NOT CALL CHAINS:** loop or comprehend over file sets with \`read()\`/stdlib, post-process \`tool.<name>()\` results programmatically, and put try/except around each risky call so the rest of the batch completes.
+- **DISTILL IN-KERNEL:** filter and aggregate results in code, then return ONLY the distilled facts.{{/if}}{{#if styleDefault}}**EVAL IS YOUR PRIMARY EXECUTION SURFACE.** Any step that needs MORE THAN ONE tool call MUST be written as ONE cell — NEVER as a chain of single tool calls.
+- **PLAN THE WHOLE STEP, THEN BATCH IT.** Enumerate every read/search/lookup the step needs and dispatch ALL independent ones through \`parallel(thunks)\` in one cell.
+- **WRITE REAL CODE, NOT CALL LISTS.** Loop or comprehend over file sets with \`read()\`/stdlib, branch \`if\`/\`else\` per case, post-process \`tool.<name>()\` results programmatically, and wrap EVERY risky call in try/except so ONE failure NEVER kills the batch.
+- **DISTILL IN-KERNEL.** Filter, diff, and aggregate in code before returning; return facts, NOT dumps.{{/if}}
+{{#if hostLine}}
+Host: {{hostLine}} — cells execute here. Size \`parallel(thunks)\` pools to its cores; \`tool.<name>()\` shell commands must fit this platform, even when the code you are writing targets another machine.
+{{/if}}
 
 Fields:
 
@@ -129,6 +176,7 @@ export function buildEvalPrompt(
 		throw new Error("no kernels enabled for eval prompt");
 	}
 	const spawnDefaultAgent = options.spawnDefaultAgent ?? "task";
+	const style = evalEmphasisStyle(options.modelId);
 	const context: Context = {
 		py: enabled.py,
 		js: enabled.js,
@@ -136,6 +184,11 @@ export function buildEvalPrompt(
 		jl: enabled.jl,
 		spawns: options.spawns,
 		spawnDefaultAgent,
+		styleClaude: style === "claude",
+		styleCodex: style === "codex",
+		styleKimi: style === "kimi",
+		styleDefault: style === "default",
+		hostLine: options.hostLine ?? "",
 	};
 	const examples = REUSE_CHAIN_EXAMPLES.filter((example) => enabled[example.language])
 		.map((example) => {
@@ -155,12 +208,26 @@ export function buildEvalPrompt(
 		description,
 		promptSnippet: "Run one incremental code cell in a persistent language kernel.",
 		promptGuidelines: [
-			"Use eval for incremental code execution when a persistent JS, Python, Ruby, or Julia kernel is available.",
+			BATCHING_GUIDELINES[style],
 			"Use eval reset only when a language kernel must be wiped; reset is scoped to the selected language.",
 		],
 	};
 }
 
+/**
+ * System-prompt guideline per emphasis dialect. The default dialect carries
+ * maximum emphasis so unmapped models still batch through eval; the others are
+ * tuned to what steers that family reliably.
+ */
+const BATCHING_GUIDELINES: Record<EvalEmphasisStyle, string> = {
+	default:
+		"**EVAL FIRST.** Any step needing MORE THAN ONE tool call MUST be ONE eval cell: run independent calls in parallel, wrap risky calls in try/except, and return distilled facts — NEVER a chain of single tool calls.",
+	claude:
+		"Prefer eval for any step needing more than one tool call: one cell that runs independent calls in parallel, handles per-call failures in code, and returns distilled facts.",
+	codex: "Route multi-call steps through eval: one cell per step, independent calls dispatched in parallel; fall back to direct tool calls when one call is sufficient or each result changes the next decision.",
+	kimi: "**EVAL IS YOUR SUPERPOWER — DEFAULT TO IT.** Execute EVERY multi-call step as ONE eval cell: run ALL independent calls simultaneously via parallel(thunks), handle failures per item in code, and return ONLY distilled facts.",
+};
+
 function renderTemplate(template: string, context: Context): string {
 	let index = 0;
 	const [rendered, nextIndex] = renderUntil(template, context, index, []);

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

@@ -39,6 +39,10 @@ export interface CreateEvalToolOptions {
 	readonly spawns?: boolean;
 	/** Default agent name surfaced in the agent() helper docs when spawns are enabled. */
 	readonly spawnDefaultAgent?: string;
+	/** Active model id; selects the emphasis dialect of the eval prompt. */
+	readonly modelId?: string;
+	/** Preformatted host line rendered into the prompt's host-sizing note. */
+	readonly hostLine?: string;
 }
 
 interface EvalCellInvocation {
@@ -152,6 +156,8 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 	const prompt = buildEvalPrompt(options.enabledLanguages, {
 		spawns: options.spawns ?? false,
 		...(options.spawnDefaultAgent === undefined ? {} : { spawnDefaultAgent: options.spawnDefaultAgent }),
+		...(options.modelId === undefined ? {} : { modelId: options.modelId }),
+		...(options.hostLine === undefined ? {} : { hostLine: options.hostLine }),
 	});
 	const languages = enabledLanguageList(options.enabledLanguages);
 	return {

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,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;AA4pBD,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"}
+{"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;AAkqBD,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

@@ -129,9 +129,10 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
             const toolResults = [];
             hasMoreToolCalls = false;
             if (toolCalls.length > 0) {
-                // A "length" stop means the output was cut off by the token limit, so
-                // every tool call in the message may carry truncated arguments. Fail
-                // them all instead of executing potentially borked calls.
+                // A native "length" stop means the output was cut off by the token limit,
+                // so every tool call in the message may carry truncated arguments. Text
+                // tool-call middleware finalizes its calls as "toolUse", leaving only
+                // native, unwrapped length responses for this message-wide safeguard.
                 const executedToolBatch = message.stopReason === "length"
                     ? await failToolCallsFromTruncatedMessage(toolCalls, emit)
                     : await executeToolCalls(currentContext, message, config, signal, emit);
@@ -379,6 +380,12 @@ async function readNextAssistantEvent(iterator, idleTimeoutMs, abortPromise, onI
         }, (error) => settle(() => reject(error)));
     });
 }
+function createIncompleteToolCallErrorMessage(toolName, errorMessage) {
+    if (errorMessage !== undefined) {
+        return `${errorMessage}${errorMessage.endsWith(".") ? "" : "."} Re-issue the tool call with complete arguments.`;
+    }
+    return `Tool call "${toolName}" was not executed: the response ended before the tool call was complete because it hit the output token limit. Re-issue the tool call with complete arguments.`;
+}
 /**
  * Fail all tool calls from an assistant message that was truncated by the
  * output token limit. Streamed tool-call arguments are finalized with a
@@ -397,7 +404,7 @@ async function failToolCallsFromTruncatedMessage(toolCalls, emit) {
         });
         const finalized = {
             toolCall,
-            result: createErrorToolResult(`Tool call "${toolCall.name}" was not executed: the response hit the output token limit, so its arguments may be truncated. Re-issue the tool call with complete arguments.`),
+            result: createErrorToolResult(createIncompleteToolCallErrorMessage(toolCall.name)),
             isError: true,
         };
         await emitToolExecutionEnd(finalized, emit);
@@ -572,6 +579,14 @@ export function prepareAgentToolCall(tool, toolCall) {
     };
 }
 async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
+    if (toolCall.incomplete === true) {
+        return {
+            kind: "immediate",
+            toolCall,
+            result: createErrorToolResult(createIncompleteToolCallErrorMessage(toolCall.name, toolCall.errorMessage)),
+            isError: true,
+        };
+    }
     const tool = currentContext.tools?.find((t) => t.name === toolCall.name);
     if (!tool) {
         return {