import { mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile, } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join, resolve } from "node:path"; import { createAssistantMessageEventStream, type FauxResponseStep, fauxAssistantMessage, fauxProvider, fauxToolCall, getCurrentSystemPrompt, getCurrentTools, type JsonObject, } from "@earendil-works/pi-ai"; import { AssistantMessageComponent, createCodemodeExtension, initTheme, SessionManager, Theme, } from "@earendil-works/pi-coding-agent"; import { Box, stripTerminalSequences, TuiMainScreen, visibleWidth, } from "@earendil-works/pi-tui"; import xterm from "@xterm/headless"; import { afterEach, describe, expect, it } from "vitest"; import { createPiSession, type PiSession, } from "../../../test/fixture/create-pi-session.ts"; import { LiveTaskPreview } from "../live.ts"; import { type Progress, runTask, type TaskResult } from "../runtime.ts"; let fixture: PiSession | undefined; afterEach(async () => { await fixture?.dispose(); fixture = undefined; }); function previewTui(): TuiMainScreen { const noop = () => {}; const tui = new TuiMainScreen({ start: noop, stop: noop, drainInput: async () => {}, write: noop, columns: 120, rows: 40, kittyProtocolActive: false, moveBy: noop, hideCursor: noop, showCursor: noop, clearLine: noop, clearFromCursor: noop, clearScreen: noop, setTitle: noop, setProgress: noop, setProgramStatus: noop, }); tui.stop(); return tui; } function call(args: JsonObject) { return fauxAssistantMessage(fauxToolCall("pipi", args, { id: "task" })); } function submit(output: JsonObject) { return fauxAssistantMessage( fauxToolCall("pipi_output", { output }, { id: "submit" }), ); } async function setup( responses: NonNullable[0]["responses"]>, ) { fixture = await createPiSession({ extensionPaths: [resolve("extensions/pipi/index.ts")], responses, env: { PI_PIPI_DEBUG: "0" }, userSettings: { defaultTools: ["read", "pipi"], retry: { enabled: false }, cacheWarming: "off", }, }); expect(fixture.errors).toEqual([]); return fixture; } function result(f: PiSession): TaskResult { const message = f.session.messages.findLast( (message) => message.role === "toolResult" && message.toolName === "pipi", ); if (message?.role !== "toolResult") throw new Error("Missing pipi result"); return JSON.parse( message.content .filter((part) => part.type === "text") .map((part) => part.text) .join(""), ) as TaskResult; } it.each(["provider", "https://models.example/v1"])( "runs exact slash-containing model identities for %s and rejects substitutes", async (provider) => { const f = await setup([]); const id = "org/worker"; const faux = fauxProvider({ provider, models: [{ id }] }); faux.setResponses([fauxAssistantMessage("Resolved exact identity")]); const ctx = f.session.extensionRunner.createToolContext( "model-reference", undefined, ); ctx.modelRegistry.registerProvider(faux.provider); const invoke = (model: string) => runTask( ctx, { prompt: "Reply", model, noExtensions: true, noSkills: true, noContextFiles: true, }, { tools: [], availableTools: [], extensions: [], prompt: {} }, { modelTiers: {}, providerModelTiers: {} }, 14_400_000, ); const value = await invoke(`${provider}/${id}`); expect(value.outcome).toBe("completed"); expect(value.effective.model).toBe(`${provider}/${id}`); expect(value.output).toMatchObject({ provider, model: id, content: [{ type: "text", text: "Resolved exact identity" }], }); for (const ref of [ id, `${provider}/org/work`, `${provider}/${id}:high`, `${provider.toUpperCase()}/${id}`, `/${provider}/${id}`, ]) { await expect(invoke(ref)).resolves.toMatchObject({ outcome: "error", diagnostics: [ ref.startsWith("/") ? "pipi: model must be provider/model" : `pipi: model unavailable: ${ref}`, ], turns: 0, }); } await expect(invoke("worker")).resolves.toMatchObject({ outcome: "error", diagnostics: ["pipi: model must be provider/model"], turns: 0, }); }, ); it("classifies child-hidden, inactive and missing tools after startup", async () => { const directory = await mkdtemp(join(tmpdir(), "pipi-tool-visibility-")); const extension = join(directory, "visibility.ts"); try { await writeFile( extension, `export default pi => { const tool = name => ({name, label:name, description:name, parameters:{type:"object",properties:{}}, async execute(){return {content:[],details:{}}}}); pi.registerTool(tool("hidden_probe")); pi.registerTool(tool("inactive_probe")); pi.on("session_start", (_event, ctx) => { if (!ctx.sessionManager.getHeader()?.parentSession) return; pi.registerTool({...tool("hidden_probe"), exposure:"hidden"}); pi.setActiveTools(pi.getActiveTools().filter(name => name !== "inactive_probe")); }); }`, ); fixture = await createPiSession({ extensionPaths: [resolve("extensions/pipi/index.ts"), extension], sessionManager: SessionManager.create( directory, join(directory, "sessions"), ), userSettings: { defaultTools: ["read", "pipi", "hidden_probe", "inactive_probe"], retry: { enabled: false }, cacheWarming: "off", }, env: { PI_PIPI_DEBUG: "0" }, }); const f = fixture; for (const tools of [ undefined, ["+read"], ["hidden_probe"], ["+hidden_probe"], ["inactive_probe", "missing_probe"], ]) { f.setResponses([ call({ prompt: "Inspect visibility", ...(tools ? { tools } : {}) }), fauxAssistantMessage("child"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Delegate"); const value = result(f); expect(value.outcome).toBe("completed"); expect(value.effective.tools).not.toContain("hidden_probe"); expect(value.effective.tools).not.toContain("inactive_probe"); const explicitHidden = tools?.some((name) => name.endsWith("hidden_probe"), ); if (!tools || tools[0]?.startsWith("+")) { expect(value.diagnostics.join("\n")).toContain("inactive_probe"); } if (explicitHidden) { expect(value.effective.excludedTools ?? []).not.toContain( "hidden_probe", ); expect(value.diagnostics.join("\n")).toMatch(/hidden.*hidden_probe/); } else if (!tools || tools[0] === "+read") { expect(value.effective.excludedTools).toEqual(["hidden_probe"]); expect(value.diagnostics.join("\n")).not.toContain("hidden_probe"); } else { expect(value.diagnostics.join("\n")).toMatch( /inactive.*inactive_probe/, ); expect(value.diagnostics.join("\n")).toMatch( /unavailable.*missing_probe/, ); } } expect(f.errors).toEqual([]); } finally { await fixture?.dispose(); fixture = undefined; await rm(directory, { recursive: true, force: true }); } }); describe("native pipi child task", () => { it("loads and binds a named child, returns native assistant output and leaves child usage in the child ledger", async () => { const f = await setup([ call({ prompt: "Inspect one thing", tools: ["read"], noExtensions: true, }), fauxAssistantMessage("child answer"), fauxAssistantMessage("parent done"), ]); await f.session.prompt("Delegate the task"); expect(f.errors).toEqual([]); const value = result(f); expect(value.outcome).toBe("completed"); expect(value.output).toMatchObject({ role: "assistant", content: [{ type: "text", text: "child answer" }], }); expect(value.sessionId).toBeTruthy(); expect(value.sessionFile).toBeTruthy(); expect(value.turns).toBe(1); const transcript = await readFile(value.sessionFile as string, "utf8"); expect(transcript).toContain("child answer"); expect( SessionManager.open(value.sessionFile as string).getSessionName(), ).toBe("PiPi · task · Inspect one thing"); expect(value.usage.totalTokens).toBeGreaterThan(0); const tool = f.session.messages.find( (message) => message.role === "toolResult" && message.toolName === "pipi", ); if (tool?.role !== "toolResult") throw new Error("Missing pipi tool result"); expect(tool.usage).toBeUndefined(); const parentTokens = f.session.messages .filter((message) => message.role === "assistant") .reduce((sum, message) => sum + message.usage.totalTokens, 0); expect(f.session.getSessionStats().tokens.total).toBe(parentTokens); }); it("validates output, reminds once and terminates through the native submission tool", async () => { const schema = { $defs: { integer: { type: "integer" } }, type: "object", properties: { answer: { $ref: "#/$defs/integer" } }, required: ["answer"], additionalProperties: false, }; const f = await setup([ call({ prompt: "Return 42", tools: [], noExtensions: true, outputSchema: schema, }), fauxAssistantMessage( fauxToolCall( "pipi_output", { output: { answer: "invalid" } }, { id: "invalid-ref" }, ), ), submit({ answer: 42 }), fauxAssistantMessage("parent done"), ]); await f.session.prompt("Delegate"); const value = result(f); expect(value.outcome).toBe("completed"); expect(value.output).toEqual({ answer: 42 }); expect(value.turns).toBe(2); }); it("fails after the one reminder rather than accepting ordinary prose", async () => { const f = await setup([ call({ prompt: "Return structured", tools: [], noExtensions: true, outputSchema: { type: "string" }, }), fauxAssistantMessage("first"), fauxAssistantMessage("second"), fauxAssistantMessage("parent done"), ]); await f.session.prompt("Delegate"); expect(result(f)).toMatchObject({ outcome: "failed", output: null, turns: 2, }); }); }); async function preset( f: PiSession, name: string, config: unknown, body?: string, ) { const directory = join(f.agentDir, "pipi", "agents", name); await mkdir(directory, { recursive: true }); await writeFile(join(directory, "config.json"), JSON.stringify(config)); if (body !== undefined) await writeFile(join(directory, "instructions.md"), body); } describe("output settlement, resume and native usage", () => { it("excludes resumed and forked history, resets old output submissions and uses current preset", async () => { const f = await setup([]); await preset(f, "counter", { description: "Count evidence", tools: [], noExtensions: true, outputSchema: { type: "integer" }, }); f.setResponses([ call({ prompt: "First", agent: "counter" }), { ...fauxAssistantMessage( fauxToolCall("pipi_output", { output: 7 }, { id: "first" }), ), }, fauxAssistantMessage("parent"), ]); await f.session.prompt("First task"); const first = result(f); expect(first).toMatchObject({ outcome: "completed", output: 7, turns: 1, usage: expect.objectContaining({ totalTokens: expect.any(Number) }), }); const file = first.sessionFile as string; f.setResponses([ call({ prompt: "Continue without submitting", agent: "counter", sessionId: file, }), fauxAssistantMessage("one"), fauxAssistantMessage("two"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Continue task"); expect(result(f)).toMatchObject({ outcome: "failed", output: null, sessionId: first.sessionId, usage: expect.objectContaining({ totalTokens: expect.any(Number) }), }); const resumed = result(f); const resumedEntries = (await readFile(file, "utf8")) .trim() .split("\n") .map((line) => JSON.parse(line)); const newMessages = resumedEntries .filter((entry) => entry.message?.role === "assistant") .slice(-2); expect(resumed.usage.totalTokens).toBe( newMessages.reduce( (sum, entry) => sum + entry.message.usage.totalTokens, 0, ), ); await preset(f, "counter", { description: "Now ordinary output", tools: [], noExtensions: true, }); f.setResponses([ call({ prompt: "Fork with current config", agent: "counter", sessionId: file, fork: true, }), fauxAssistantMessage("fork answer"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Fork task"); const fork = result(f); expect(fork.outcome).toBe("completed"); expect(fork.sessionId).not.toBe(first.sessionId); expect(fork.usage.totalTokens).toBeGreaterThan(0); const forkEntries = (await readFile(fork.sessionFile as string, "utf8")) .trim() .split("\n") .map((line) => JSON.parse(line)); const forkAssistant = forkEntries .filter((entry) => entry.message?.role === "assistant") .at(-1).message; expect(fork.usage).toEqual({ ...forkAssistant.usage, cost: { ...forkAssistant.usage.cost, totalFromProvider: false }, }); expect(fork.output).toMatchObject({ role: "assistant", content: [{ text: "fork answer" }], }); }); it("returns forked billed work once and keeps new legacy work estimated", async () => { const f = await setup([]); f.setResponses([ call({ prompt: "Create fork baseline", tools: [] }), fauxAssistantMessage("baseline"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Create baseline"); const baseline = result(f); expect(baseline.usage.cost.totalFromProvider).toBe(false); const provider = f.session.modelRuntime.getRegisteredProviderConfig("faux"); if (!provider?.streamSimple) throw new Error("Missing faux stream"); const streamSimple = provider.streamSimple; f.session.modelRuntime.registerProvider("faux", { ...provider, streamSimple(model, context, options) { const source = streamSimple(model, context, options); const output = createAssistantMessageEventStream(); void (async () => { for await (const event of source) { if (event.type !== "done") { output.push(event); continue; } const message = { ...event.message, usage: { ...event.message.usage, cost: { ...event.message.usage.cost, total: 0.123, totalFromProvider: true, }, }, }; output.push({ ...event, message }); output.end(message); } })(); return output; }, }); f.setResponses([ call({ prompt: "Fork billed work", tools: [], sessionId: baseline.sessionFile as string, fork: true, }), fauxAssistantMessage("billed fork"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Fork billed work"); const billed = result(f); const childEntries = (await readFile(billed.sessionFile as string, "utf8")) .trim() .split("\n") .map((line) => JSON.parse(line)); const childUsage = childEntries .filter((entry) => entry.message?.role === "assistant") .at(-1).message.usage; expect(billed.usage).toEqual(childUsage); expect( SessionManager.open(billed.sessionFile as string).getSessionName(), ).toBe("PiPi · task · Fork billed work"); expect(billed.usage.cost).toMatchObject({ total: 0.123, totalFromProvider: true, }); const parentTool = f.session.sessionManager .getEntries() .findLast( (entry) => entry.type === "message" && entry.message.role === "toolResult" && entry.message.toolName === "pipi", ); if ( parentTool?.type !== "message" || parentTool.message.role !== "toolResult" ) throw new Error("Missing persisted pipi tool result"); expect(parentTool.message.usage).toBeUndefined(); f.session.modelRuntime.registerProvider("faux", provider); f.setResponses([ call({ prompt: "Fork legacy work", tools: [], sessionId: baseline.sessionFile as string, fork: true, }), fauxAssistantMessage("legacy fork"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Fork legacy work"); expect(result(f).usage.cost.totalFromProvider).toBe(false); }); it("keeps last valid output across invalid submission then error; never declares success merely for valid JSON", async () => { const f = await setup([]); const extension = join(f.cwd, "settle.ts"); await writeFile( extension, `export default pi => {pi.registerTool({name:"keep_running",label:"Continue",description:"Continue task",parameters:{type:"object",properties:{}},async execute(){return {content:[],details:{}}}})}`, ); f.setResponses([ call({ prompt: "Complete", tools: ["keep_running"], extensions: [extension], noExtensions: true, outputSchema: { type: "integer" }, }), fauxAssistantMessage([ fauxToolCall("pipi_output", { output: 1 }, { id: "valid-one" }), fauxToolCall("pipi_output", { output: 2 }, { id: "valid-two" }), fauxToolCall("pipi_output", { output: "invalid" }, { id: "invalid" }), fauxToolCall("keep_running", {}, { id: "continue" }), ]), fauxAssistantMessage("", { stopReason: "error", errorMessage: "scripted child error", }), fauxAssistantMessage("parent"), ]); await f.session.prompt("Delegate"); const value = result(f); expect(value.outcome).toBe("error"); expect(value.output).toBe(2); const entries = (await readFile(value.sessionFile as string, "utf8")) .trim() .split("\n") .map((line) => JSON.parse(line)); expect( entries.some( (entry) => entry.message?.toolCallId === "invalid" && entry.message.isError, ), ).toBe(true); expect( entries.some((entry) => entry.customType === "pipi_output_reminder"), ).toBe(false); }); it("null explicitly disables preset schema and scalar/array outputs use native wrapped validation", async () => { const f = await setup([]); await preset(f, "preset", { description: "Array response", tools: [], noExtensions: true, outputSchema: { type: "array", items: { type: "integer" } }, }); f.setResponses([ call({ agent: "preset", prompt: "Array" }), fauxAssistantMessage( fauxToolCall("pipi_output", { output: [1, 2, 3] }, { id: "array" }), ), fauxAssistantMessage("parent"), ]); await f.session.prompt("Array task"); expect(result(f).output).toEqual([1, 2, 3]); f.setResponses([ call({ agent: "preset", prompt: "Ordinary", outputSchema: null }), fauxAssistantMessage("ordinary answer"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Disable schema"); expect(result(f).output).toMatchObject({ role: "assistant", content: [{ text: "ordinary answer" }], }); }); it("propagates caller cancellation through recursive children without an output reminder", async () => { const f = await setup([]); let started!: () => void; const running = new Promise((resolve) => { started = resolve; }); let childSignal: AbortSignal | undefined; const wait: FauxResponseStep = async (_context, options) => { childSignal = options?.signal; started(); await new Promise((resolve) => { if (options?.signal?.aborted) resolve(); else options?.signal?.addEventListener("abort", () => resolve(), { once: true, }); }); return fauxAssistantMessage("", { stopReason: "aborted" }); }; f.setResponses([ call({ prompt: "Child delegates", tools: ["pipi"], outputSchema: { type: "integer" }, }), call({ prompt: "Grandchild waits", tools: [], outputSchema: { type: "integer" }, }), wait, ]); const pending = f.session.prompt("Delegate recursively"); await running; await f.session.abort(); await pending; expect(childSignal?.aborted).toBe(true); const files = await readdir(join(f.agentDir, "sessions"), { recursive: true, }); const transcripts = await Promise.all( files .filter((file) => file.endsWith(".jsonl")) .map((file) => readFile(join(f.agentDir, "sessions", file), "utf8")), ); expect( transcripts.some((text) => text.includes('"stopReason":"aborted"')), ).toBe(true); expect( transcripts.some((text) => text.includes('"customType":"pipi_output_reminder"'), ), ).toBe(false); }); it("aborts the child at the call deadline without a parent abort and preserves its session", async () => { const f = await setup([]); let childSignal: AbortSignal | undefined; const wait: FauxResponseStep = async (_context, options) => { childSignal = options?.signal; await new Promise((resolve) => { if (options?.signal?.aborted) resolve(); else options?.signal?.addEventListener("abort", () => resolve(), { once: true, }); }); return fauxAssistantMessage("", { stopReason: "aborted" }); }; f.setResponses([ call({ prompt: "Bounded child", timeoutMs: 300, tools: [], outputSchema: { type: "integer" }, }), wait, fauxAssistantMessage("parent"), ]); const started = Date.now(); await f.session.prompt("Delegate with deadline"); const value = result(f); expect(value.outcome).toBe("aborted"); expect(childSignal?.aborted).toBe(true); expect(value.diagnostics.join("\n")).toContain("deadline"); expect(value.sessionId).toBeTruthy(); expect(value.sessionFile).toBeTruthy(); expect(Date.now() - started).toBeLessThan(15_000); }); it("returns bounded when the deadline fires while the child is wedged in a tool", async () => { const directory = await mkdtemp(join(tmpdir(), "pipi-deadline-wedge-")); const extension = join(directory, "wedged.ts"); await writeFile( extension, `export default pi => { pi.registerTool({ name: "wedged_probe", label: "wedged_probe", description: "never resolves and ignores abort", parameters: { type: "object", properties: {} }, async execute() { await new Promise(() => {}); }, }); };`, ); try { const f = await setup([]); f.setResponses([ call({ prompt: "Wedge", timeoutMs: 300, tools: ["wedged_probe"], extensions: [extension], }), fauxAssistantMessage(fauxToolCall("wedged_probe", {}, { id: "wedge" })), fauxAssistantMessage("parent"), ]); await f.session.prompt("Delegate into wedge"); const value = result(f); expect(value.outcome).toBe("aborted"); expect(value.diagnostics.join("\n")).toContain("deadline"); expect(value.sessionFile).toBeTruthy(); expect(value.durationMs).toBeLessThan(20_000); } finally { await rm(directory, { recursive: true, force: true }); } }); }); describe("discovery, native capabilities and prompt controls", () => { it("preserves PFUI-backed inherited sections while applying child overrides and output guidance", async () => { fixture = await createPiSession({ extensionPaths: [ resolve("extensions/pfui/index.ts"), resolve("extensions/pipi/index.ts"), ], extensionFactories: [ (pi) => { pi.on("before_agent_start", (event) => { event.systemPromptOptions.sections["parent_only_marker"] = "parent-only marker"; }); }, ], responses: [], env: { PI_PIPI_DEBUG: "0" }, userSettings: { defaultTools: ["read", "write", "pipi"], retry: { enabled: false }, cacheWarming: "off", }, }); const f = fixture; expect(f.errors).toEqual([]); await preset( f, "pfui-reviewer", { description: "Review with PFUI", outputSchema: { type: "integer" }, }, "preset instruction marker", ); let parentPrompt = "", childPrompt = ""; f.setResponses([ (context) => { parentPrompt = getCurrentSystemPrompt(context.messages); return call({ agent: "pfui-reviewer", prompt: "Return integer", tools: ["read"], sections: { pipi_inherited_probe: "call section marker", tools: "explicit accessor override marker", }, extensions: [resolve("extensions/pfui/index.ts")], }); }, (context) => { childPrompt = getCurrentSystemPrompt(context.messages); return fauxAssistantMessage( fauxToolCall("pipi_output", { output: 17 }, { id: "pfui-submit" }), ); }, fauxAssistantMessage("parent done"), ]); await f.session.prompt("Delegate through PFUI"); const value = result(f); expect(value.outcome).toBe("completed"); expect(parentPrompt).toContain("parent-only marker"); expect(childPrompt).toContain("parent-only marker"); expect(childPrompt).toContain("call section marker"); expect(childPrompt).toContain("explicit accessor override marker"); expect(childPrompt).toContain("preset instruction marker"); expect(childPrompt).toContain(""); expect( value.diagnostics.filter((item) => item.startsWith("Child extension failed:"), ), ).toEqual([]); f.setResponses([ (context) => { parentPrompt = getCurrentSystemPrompt(context.messages); return call({ agent: "pfui-reviewer", prompt: "Keep inherited sections", tools: ["read"], extensions: [resolve("extensions/pfui/index.ts")], }); }, (context) => { childPrompt = getCurrentSystemPrompt(context.messages); return fauxAssistantMessage( fauxToolCall( "pipi_output", { output: 23 }, { id: "inherited-submit" }, ), ); }, fauxAssistantMessage("parent done"), ]); await f.session.prompt("Delegate without section overrides"); const inherited = result(f); expect(inherited.outcome).toBe("completed"); expect(inherited.output).toBe(23); expect(inherited.diagnostics).toEqual([]); expect(parentPrompt).toContain("- write:"); const inheritedTools = parentPrompt.match( /\n[\s\S]*?\n<\/tools>/, )?.[0]; expect(inheritedTools).toBeDefined(); expect(childPrompt).toContain(inheritedTools); expect(childPrompt).toContain("parent-only marker"); expect(childPrompt).toContain("preset instruction marker"); expect(childPrompt).toContain(""); }); it("retains actual child extension errors in diagnostics", async () => { const f = await setup([]); const path = join(f.cwd, "throwing-extension.ts"); await writeFile( path, `export default pi => pi.on("before_agent_start", () => { throw new Error("fixture extension sentinel") });`, ); f.setResponses([ call({ prompt: "Continue", extensions: [path], tools: [] }), fauxAssistantMessage("child answer"), fauxAssistantMessage("parent done"), ]); await f.session.prompt("Delegate with failing extension"); const value = result(f); expect(value.outcome).toBe("completed"); expect(value.diagnostics).toContain( `Child extension failed: ${path} (before_agent_start): fixture extension sentinel`, ); }); it("discovers descriptions without reading instructions, resolves current preset and loads ordinary dynamic extension with flags", async () => { const f = await setup([]); await preset( f, "reviewer", { description: "Review evidence", tools: ["read", "+evidence"], noExtensions: true, flags: { evidence: true }, sections: { pipi_agent: "call replaces preset" }, }, "preset instructions", ); await preset(f, "broken", { description: "Missing valid types", tools: 42, }); const root = join(f.agentDir, "pipi", "dynamic", "evidence"); await mkdir(root, { recursive: true }); const path = join(root, "index.ts"); await writeFile( path, `export default pi=>{pi.registerFlag("evidence",{type:"boolean",description:"Enable evidence"});pi.registerTool({name:"evidence",label:"Evidence",description:"Return evidence",parameters:{type:"object",properties:{}},async execute(){return {content:[{type:"text",text:String(pi.getFlag("evidence"))}],details:{}}}})}`, ); let parentPrompt = "", childPrompt = ""; f.setResponses([ (context) => { parentPrompt = getCurrentSystemPrompt(context.messages); return call({ prompt: "Inspect", agent: "reviewer", extensions: [path], tools: ["read", "+evidence", "-read"], sections: { pipi_agent: "replacement instructions" }, }); }, (context) => { childPrompt = getCurrentSystemPrompt(context.messages); expect( getCurrentTools(context.messages).map((tool) => tool.name), ).toEqual(["evidence"]); return fauxAssistantMessage( fauxToolCall("evidence", {}, { id: "probe" }), ); }, fauxAssistantMessage("evidence inspected"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Use reusable agent"); const value = result(f); expect(value.outcome).toBe("completed"); expect(parentPrompt).toContain("Review evidence"); expect(parentPrompt).not.toContain("preset instructions"); expect(parentPrompt).toContain("evidence/index.ts"); expect(childPrompt).toContain("replacement instructions"); expect(childPrompt).not.toContain("preset instructions"); expect(value.diagnostics).toContain( 'Preset "broken" unavailable: invalid config.json', ); expect(value.effective.tools).toEqual(["evidence"]); const transcript = await readFile(value.sessionFile as string, "utf8"); const entries = transcript .trim() .split("\n") .map((line) => JSON.parse(line)); expect( entries.some( (entry) => entry.message?.toolName === "evidence" && entry.message.content[0].text === "true", ), ).toBe(true); }); it("uses native fresh resource instructions and protects output section with forced prompts", async () => { const f = await setup([]); await writeFile(join(f.cwd, "AGENTS.md"), "Project instruction evidence"); let system = ""; f.setResponses([ call({ prompt: "Forced", tools: [], forceSystemPrompt: "Forced task instruction", outputSchema: { type: "integer" }, noExtensions: true, }), (context) => { system = getCurrentSystemPrompt(context.messages); return fauxAssistantMessage( fauxToolCall("pipi_output", { output: 3 }, { id: "forced" }), ); }, fauxAssistantMessage("parent"), ]); await f.session.prompt("Delegate"); expect(result(f)).toMatchObject({ outcome: "completed", output: 3 }); expect(system).toContain("Forced task instruction"); expect(system).toContain(""); }); it("rejects unknown preset instead of silently running a fresh generic child", async () => { const f = await setup([ call({ prompt: "Do something", agent: "does-not-exist" }), fauxAssistantMessage("parent"), ]); await f.session.prompt("Delegate"); const tool = f.session.messages.find( (message) => message.role === "toolResult" && message.toolName === "pipi", ); expect(tool).toMatchObject({ isError: true }); expect(f.providerState.callCount).toBe(2); }); }); describe("independent native calls", () => { it("keeps schema submission state local across concurrent tool calls", async () => { const f = await setup([]); let active = 0; let ready!: () => void; const barrier = new Promise((resolve) => { ready = resolve; }); const respond = (answer: number): FauxResponseStep => async () => { active++; if (active === 2) ready(); await barrier; return fauxAssistantMessage( fauxToolCall( "pipi_output", { output: answer }, { id: "output-" + answer }, ), ); }; f.setResponses([ fauxAssistantMessage([ fauxToolCall( "pipi", { prompt: "One", tools: [], outputSchema: { type: "integer" } }, { id: "one" }, ), fauxToolCall( "pipi", { prompt: "Two", tools: [], outputSchema: { type: "integer" } }, { id: "two" }, ), ]), respond(1), respond(2), fauxAssistantMessage("parent"), ]); await f.session.prompt("Delegate concurrently"); const results = f.session.messages .filter( (message) => message.role === "toolResult" && message.toolName === "pipi", ) .map((message) => { if (message.role !== "toolResult") throw new Error("Unexpected message"); return JSON.parse( message.content .filter((part) => part.type === "text") .map((part) => part.text) .join(""), ) as TaskResult; }); expect(active).toBe(2); expect(results.map((value) => value.output).sort()).toEqual([1, 2]); expect(new Set(results.map((value) => value.sessionId)).size).toBe(2); expect(results.every((value) => value.outcome === "completed")).toBe(true); }); it("leaves persisted descendant usage in the descendant session", async () => { const f = await setup([ call({ prompt: "Outer task", tools: ["pipi"] }), call({ prompt: "Inner task", tools: [] }), fauxAssistantMessage("grandchild result"), fauxAssistantMessage("child result"), fauxAssistantMessage("parent result"), ]); await f.session.prompt("Delegate recursively"); const outer = result(f); expect(outer.outcome).toBe("completed"); const entries = (await readFile(outer.sessionFile as string, "utf8")) .trim() .split("\n") .map((line) => JSON.parse(line)); const messages = entries .filter((entry) => entry.message) .map((entry) => entry.message); const nested = messages.find( (message) => message.role === "toolResult" && message.toolName === "pipi", ); expect(nested.usage).toBeUndefined(); const assistantTokens = messages .filter((message) => message.role === "assistant") .reduce((sum, message) => sum + message.usage.totalTokens, 0); expect(outer.usage.totalTokens).toBe(assistantTokens); }); it("rediscovers cwd instructions and skill resources; custom and appended prompts retain native loader context", async () => { const f = await setup([]); const workspace = join(f.cwd, "other"); const skill = join(f.agentDir, "skills", "inspect"); await mkdir(workspace, { recursive: true }); await mkdir(skill, { recursive: true }); await writeFile(join(workspace, "AGENTS.md"), "Child workspace marker"); await writeFile( join(skill, "SKILL.md"), "---\nname: inspect\ndescription: Inspect deterministic evidence.\n---\nSkill body read on demand", ); let system = ""; f.setResponses([ call({ prompt: "Inspect", cwd: workspace, tools: ["read"], customPrompt: "Custom prefix marker", appendSystemPrompt: "Append marker", sections: { assignment: "Section marker" }, }), (context) => { system = getCurrentSystemPrompt(context.messages); return fauxAssistantMessage("child"); }, fauxAssistantMessage("parent"), ]); await f.session.prompt("Delegate into another cwd"); expect(result(f)).toMatchObject({ outcome: "completed", effective: { cwd: workspace }, }); expect(system).toContain("Custom prefix marker"); expect(system).toContain("Append marker"); expect(system).toContain("Section marker"); expect(system).toContain("Child workspace marker"); expect(system).toContain(join(skill, "SKILL.md")); expect(system).not.toContain("Skill body read on demand"); }); }); it("loads additive resources and applies native call-local selectors", async () => { const f = await setup([]); const path = join(f.cwd, "resource.ts"); await writeFile( path, `export default pi=>{pi.registerTool({name:"resource_probe",label:"Resource",description:"Resource evidence",parameters:{type:"object",properties:{}},async execute(){return {content:[],details:{}}}})}`, ); f.setResponses([ call({ prompt: "Include", extensions: [path], noExtensions: true }), fauxAssistantMessage("included"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Include resource"); expect(result(f).effective.tools).toContain("resource_probe"); for (const selector of ["-" + path, "!" + join(f.cwd, "*.ts")]) { f.setResponses([ call({ prompt: "Exclude", extensions: [path, selector], noExtensions: true, }), fauxAssistantMessage("excluded"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Exclude resource"); expect(result(f)).toMatchObject({ outcome: "completed" }); expect(result(f).effective.tools).not.toContain("resource_probe"); } }); it("exposes the stable structured envelope through native scripted parent tool calls", async () => { fixture = await createPiSession({ extensionPaths: [resolve("extensions/pipi/index.ts")], extensionFactories: [createCodemodeExtension()], env: { PI_PIPI_DEBUG: "0" }, userSettings: { defaultTools: ["codemode", "pipi"], retry: { enabled: false }, cacheWarming: "off", }, responses: [ fauxAssistantMessage( fauxToolCall( "codemode", { code: 'const result = await tools.pipi({ prompt: "Child", tools: [] }); text({ outcome: result.outcome, sessionId: result.sessionId, role: result.output.role });', }, { id: "script" }, ), ), fauxAssistantMessage("child answer"), fauxAssistantMessage("parent answer"), ], }); expect(fixture.errors).toEqual([]); await fixture.session.prompt("Delegate from a script"); const tool = fixture.session.messages.find( (message) => message.role === "toolResult" && message.toolName === "codemode", ); expect(tool).toMatchObject({ isError: false }); if (tool?.role !== "toolResult") throw new Error("Missing scripted tool result"); expect(tool.content).toEqual( expect.arrayContaining([ expect.objectContaining({ type: "text", text: expect.stringContaining('"outcome":"completed"'), }), ]), ); expect(tool.usage).toBeUndefined(); }); it("includes new auxiliary, summary and nested tool usage while excluding historical entries", async () => { const f = await setup([]); const { newUsage, emptyUsage } = await import("../runtime.ts"); const manager = SessionManager.inMemory(f.cwd); const usage = (tokens: number, totalFromProvider?: boolean) => ({ ...emptyUsage(), input: tokens, totalTokens: tokens, cost: { ...emptyUsage().cost, total: tokens / 100, ...(totalFromProvider === undefined ? {} : { totalFromProvider }), }, }); manager.appendMessage({ ...fauxAssistantMessage("old"), usage: usage(100, false), }); const before = new Set(manager.getEntries().map((entry) => entry.id)); manager.appendUsage("test", "faux", "faux-model", usage(3, true)); manager.appendCompaction( "compact", null, 0, undefined, false, usage(5, true), ); manager.branchWithSummary(null, "summary", undefined, false, usage(7, true)); manager.appendMessage({ role: "toolResult", toolCallId: "nested", toolName: "nested", content: [], isError: false, timestamp: Date.now(), usage: usage(11, true), }); manager.appendMessage({ ...fauxAssistantMessage("new"), usage: usage(13, true), }); expect(newUsage(manager.getEntries(), before)).toMatchObject({ totalTokens: 39, cost: { total: 0.39, totalFromProvider: true }, }); const mixed = SessionManager.inMemory(f.cwd); const mixedBefore = new Set(mixed.getEntries().map((entry) => entry.id)); mixed.appendUsage("test", "faux", "faux-model", usage(1, true)); mixed.appendUsage("test", "faux", "faux-model", usage(2)); expect(newUsage(mixed.getEntries(), mixedBefore).cost).toMatchObject({ total: 0.03, totalFromProvider: false, }); const zero = SessionManager.inMemory(f.cwd); const zeroBefore = new Set(zero.getEntries().map((entry) => entry.id)); zero.appendUsage("test", "faux", "faux-model", usage(0, true)); expect(newUsage(zero.getEntries(), zeroBefore).cost).toMatchObject({ total: 0, totalFromProvider: true, }); }); it("lets call tiers override preset models and combines additive preset/call resource lists", async () => { const f = await setup([]); await writeFile( join(f.agentDir, "settings.json"), JSON.stringify({ pipi: { modelTiers: { tiny: { model: "faux/faux-model" } } }, retry: { enabled: false }, cacheWarming: "off", }), ); const paths = [join(f.cwd, "first.ts"), join(f.cwd, "second.ts")] as const; for (const [index, path] of paths.entries()) await writeFile( path, `export default pi=>{pi.registerTool({name:"resource_${index}",label:"Resource",description:"Resource",parameters:{type:"object",properties:{}},async execute(){return {content:[],details:{}}}})}`, ); await preset(f, "configured", { description: "Configured task", model: "missing/preset-model", extensions: [paths[0]], noExtensions: true, }); f.setResponses([ call({ prompt: "Override model tier", agent: "configured", tier: "tiny", extensions: [paths[1]], }), fauxAssistantMessage("child"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Delegate"); expect(result(f)).toMatchObject({ outcome: "completed", effective: { model: "faux/faux-model" }, }); expect(result(f).effective.tools).toEqual( expect.arrayContaining(["resource_0", "resource_1"]), ); }); it("inherits the PiPi outer background for native and fallback tool previews", async () => { initTheme("dark", false); const f = await setup([]); const tui = previewTui(); const theme = new Theme( { text: "#dddddd", muted: "#888888", thinkingXhigh: "#dddddd", } as ConstructorParameters[0], { selectedBg: "#000000", toolPendingBg: "#112233", toolSuccessBg: "#223344", toolErrorBg: "#334455", } as ConstructorParameters[1], "truecolor", ); try { for (const toolName of ["read", "edit", "unregistered_probe"]) { for (const [state, color] of [ ["toolPendingBg", 0x112233], ["toolSuccessBg", 0x223344], ["toolErrorBg", 0x334455], ] as const) { for (const expanded of [false, true]) { const preview = new LiveTaskPreview( () => tui, () => true, ).configure(expanded, theme); try { preview.update( { type: "tool_execution_start", toolCallId: "background", toolName, args: { path: "native-preview.txt" }, }, f.session, ); if (state !== "toolPendingBg") preview.update( { type: "tool_execution_end", toolCallId: "background", toolName, result: { content: [ { type: "text", text: "Native output preserved" }, ], details: toolName === "edit" ? { diff: "+1 Native output preserved" } : {}, }, isError: state === "toolErrorBg", }, f.session, ); const box = new Box(1, 0, (line) => theme.bg(state, line)); box.addChild(preview); const lines = box.render(80); expect(lines.map(stripTerminalSequences).join("\n")).toContain( "native-preview.txt", ); if (expanded && state !== "toolPendingBg") expect(lines.map(stripTerminalSequences).join("\n")).toContain( "Native output preserved", ); const terminal = new xterm.Terminal({ cols: 81, rows: lines.length + 1, allowProposedApi: true, }); try { await new Promise((resolve) => terminal.write(lines.join("\r\n"), resolve), ); for (let row = 0; row < lines.length; row++) for (let column = 0; column < 80; column++) { expect( terminal.buffer.active .getLine(row) ?.getCell(column) ?.getBgColor(), `${toolName} ${state} expanded=${expanded} row=${row} column=${column}`, ).toBe(color); } } finally { terminal.dispose(); } } finally { preview.dispose(); } } } } } finally { tui.stop(); } }); it("renders real child assistant and custom tool activity through native SDK components", async () => { initTheme("dark", false); const f = await setup([]); const workspace = join(f.cwd, "native-preview"); await mkdir(workspace); const extension = join(f.cwd, "native-probe.ts"); await writeFile( extension, `import { Text } from "@earendil-works/pi-tui"; export default pi => { pi.registerMarkdownTransformer(markdown => markdown.replace("TRANSFORM_TOKEN", "TRANSFORMED_NATIVE")); pi.registerTool({ name: "native_probe", label: "Probe", description: "Render child activity", parameters: {type:"object",properties:{marker:{type:"string"},broken:{type:"boolean"}}}, async execute(_id, _args, _signal, onUpdate) { onUpdate?.({content:[{type:"text",text:"partial child output"}],details:{label:"PARTIAL_NATIVE"}}); return {content:[{type:"text",text:"final child output"}],details:{label:"FINAL_NATIVE"}}; }, renderCall(args, _theme, ctx) { if(args.broken) return {render(){throw new Error("Broken child render");}, invalidate(){throw new Error("Broken child invalidate");}}; return new Text("CHILD_CALL " + ctx.cwd + (args.marker ?? ""), 0, 0); }, renderResult(result, options) { return new Text(result.details.label + (options.expanded ? " EXPANDED" : " COMPACT"), 0, 0); } }); };`, ); const message = fauxAssistantMessage([ { type: "thinking", thinking: "PRIVATE_THINKING" }, { type: "text", text: "**Native heading**\n\n```ts\nconst value = 42;\n```\n\nTRANSFORM_TOKEN\nFINAL_ASSISTANT_LINE\u001b]52;c;unsafe-payload\u0007", }, ]); f.setResponses([ fauxAssistantMessage( fauxToolCall( "native_probe", { marker: "\u001b]52;c;tool-payload\u0007\u001b[2J VISIBLE_TOOL_TEXT" }, { id: "native-call" }, ), ), message, ]); const tui = previewTui(); let hideThinking = true; const preview = new LiveTaskPreview( () => tui, () => hideThinking, ); const theme = new Theme( { text: "#dddddd", muted: "#888888", thinkingXhigh: "#dddddd", } as ConstructorParameters[0], { selectedBg: "#000000" } as ConstructorParameters[1], "truecolor", ); const observed: Record = {}; const text = () => preview.render(120).map(stripTerminalSequences).join("\n"); try { const value = await runTask( f.session.extensionRunner.createToolContext("native-preview", undefined), { prompt: "Inspect native child rendering", cwd: workspace, tools: ["native_probe"], extensions: [extension], noExtensions: true, }, { tools: [], availableTools: [], extensions: [], prompt: {} }, { modelTiers: {}, providerModelTiers: {} }, 14_400_000, undefined, undefined, (event, child) => { if (event.type === "tool_execution_start") { // Replay an explicit overlap ordering against the real child's renderers. const overlap = new LiveTaskPreview( () => tui, () => true, ).configure(true, theme); const content = () => overlap.render(120).map(stripTerminalSequences).join("\n"); try { overlap.update( { ...event, toolCallId: "overlap-a", args: { marker: " ACTIVE_A" }, }, child, ); expect(content()).toContain("ACTIVE_A"); overlap.update( { ...event, toolCallId: "overlap-b", args: { marker: " ACTIVE_B" }, }, child, ); expect(content()).toContain("ACTIVE_B"); overlap.update( { type: "tool_execution_update", toolName: event.toolName, toolCallId: "overlap-a", args: {}, partialResult: { content: [], details: { label: "A_UPDATING" }, }, }, child, ); expect(content()).toContain("ACTIVE_A"); expect(content()).toContain("A_UPDATING"); overlap.update( { type: "tool_execution_end", toolName: event.toolName, toolCallId: "overlap-b", result: { content: [], details: { label: "B_DONE" } }, isError: false, }, child, ); expect(content()).toContain("ACTIVE_A"); expect(content()).toContain("A_UPDATING"); expect(content()).not.toContain("B_DONE"); overlap.update( { type: "tool_execution_end", toolName: event.toolName, toolCallId: "overlap-a", result: { content: [], details: { label: "A_DONE" } }, isError: false, }, child, ); expect(content()).toContain("A_DONE"); overlap.update( { ...event, toolCallId: "abandoned", args: { marker: " ABANDONED" }, }, child, ); expect(content()).toContain("ABANDONED"); overlap.dispose(); expect(content()).not.toContain("ABANDONED"); } finally { overlap.dispose(); } } if (!preview.update(event, child)) return; preview.configure(false, theme, { keyHint: () => "alt+e expand", }); expect(preview.render(120).length).toBe(3); expect(stripTerminalSequences(preview.render(120).at(-1) ?? "")).toBe( "alt+e expand", ); const bytes = preview.render(120).join(""); expect(bytes).not.toContain("\u001b]52;"); expect(bytes).not.toContain("\u001b[2J"); if (event.type.startsWith("tool_execution_")) { observed[event.type] = text(); preview.configure(true, theme); observed[event.type + "_expanded"] = text(); } if ( event.type === "message_end" && event.message.role === "assistant" && event.message.content.some( (part) => part.type === "text" && part.text.includes("Native heading"), ) ) { preview.configure(true, theme); preview.update( { type: "message_start", message: fauxAssistantMessage("") }, child, ); expect(text()).toContain("Native heading"); expect(text()).not.toContain("PRIVATE_THINKING"); hideThinking = false; expect(text()).toContain("Native heading"); expect(text()).toContain("PRIVATE_THINKING"); hideThinking = true; expect(text()).toContain("Native heading"); expect(text()).not.toContain("PRIVATE_THINKING"); preview.update(event, child); } if (event.type === "tool_execution_end") { preview.update( { type: "message_start", message: fauxAssistantMessage("") }, child, ); expect(text()).toContain("FINAL_NATIVE"); preview.update( { type: "message_end", message: fauxAssistantMessage(fauxToolCall("native_probe", {})), }, child, ); expect(text()).toContain("FINAL_NATIVE"); } }, ); expect( value.outcome, JSON.stringify({ diagnostics: value.diagnostics, output: value.output }), ).toBe("completed"); expect(observed["tool_execution_start"]).toContain( "CHILD_CALL " + workspace, ); expect(observed["tool_execution_start"]).toContain("VISIBLE_TOOL_TEXT"); expect(observed["tool_execution_start"]).not.toContain("tool-payload"); expect(observed["tool_execution_update"]).toContain( "PARTIAL_NATIVE COMPACT", ); expect(observed["tool_execution_update_expanded"]).toContain( "PARTIAL_NATIVE EXPANDED", ); expect(observed["tool_execution_end_expanded"]).toContain( "FINAL_NATIVE EXPANDED", ); preview.configure(false, theme); expect(text()).not.toContain("PRIVATE_THINKING"); expect(preview.render(120).length).toBeLessThanOrEqual(3); preview.configure(true, theme); expect(text()).toContain("Native heading"); expect(text()).not.toContain("**Native heading**"); expect(text()).toContain("const value = 42;"); expect(text()).toContain("FINAL_ASSISTANT_LINE"); expect(text()).toContain("TRANSFORMED_NATIVE"); expect(text()).not.toContain("unsafe-payload"); expect(text()).not.toContain("CHILD_CALL"); expect(preview.render(120).join("")).not.toContain("\u001b]133;"); for (const width of [1, 2, 8, 40]) expect( preview.render(width).every((line) => visibleWidth(line) <= width), ).toBe(true); hideThinking = false; expect(text()).toContain("PRIVATE_THINKING"); const native = new AssistantMessageComponent( message, false, undefined, undefined, 0, [(markdown) => markdown.replace("TRANSFORM_TOKEN", "TRANSFORMED_NATIVE")], ); const nativeText = native .render(120) .map(stripTerminalSequences) .join("\n"); expect(text().trim()).toBe(nativeText.trim()); f.setResponses([ fauxAssistantMessage( fauxToolCall("native_probe", { broken: true }, { id: "broken-call" }), ), fauxAssistantMessage( fauxToolCall( "native_probe", { broken: true }, { id: "broken-invalidate" }, ), ), fauxAssistantMessage("Recovered native answer"), ]); let fallbackCount = 0; const recovered = await runTask( f.session.extensionRunner.createToolContext("broken-preview", undefined), { prompt: "Check broken child renderer", tools: ["native_probe"], extensions: [extension], noExtensions: true, }, { tools: [], availableTools: [], extensions: [], prompt: {} }, { modelTiers: {}, providerModelTiers: {} }, 14_400_000, undefined, undefined, (event, child) => { preview.update(event, child); if (event.type === "tool_execution_start") { if (event.toolCallId === "broken-invalidate") preview.invalidate(); if (text().includes("Preview unavailable")) fallbackCount++; } }, ); expect(fallbackCount).toBe(2); expect(recovered.outcome).toBe("completed"); expect(text()).toContain("Recovered native answer"); expect(f.errors).toEqual([]); } finally { preview.dispose(); tui.stop(); } preview.configure(true, theme); expect(text()).not.toContain("FINAL_ASSISTANT_LINE"); }); it("keeps a stable hint on registered renderer errors without task details", async () => { initTheme("dark", false); const f = await setup([]); const render = f.session.getToolDefinition("pipi")?.renderResult; if (!render) throw new Error("Missing pipi result renderer"); const theme = new Theme( { text: "#dddddd", muted: "#888888", thinkingXhigh: "#dddddd", error: "#c84949", } as ConstructorParameters[0], { selectedBg: "#000000" } as ConstructorParameters[1], "truecolor", ); const error = { content: [ { type: "text" as const, text: "Detailed failure\u001b]52;c;unsafe-error-payload\u0007\u001b[2J\u0000\n" + "x".repeat(6100) + "END_BEYOND_6000", }, ], details: undefined, }; for (const expanded of [false, true]) { const context: Parameters[3] = { args: { prompt: "Inspect error" }, toolCallId: "renderer-error", invalidate: () => {}, lastComponent: undefined, state: {}, cwd: f.cwd, executionStarted: true, argsComplete: true, isPartial: false, expanded, showImages: false, isError: true, durationMs: undefined, outputPad: 0, keyText: () => "", keyHint: (_key: string, description: string) => description, }; const view = render(error, { expanded, isPartial: false }, theme, context); const rows = view.render(120); const plain = rows.map(stripTerminalSequences).join("\n"); if (expanded) { expect(plain).toContain("Detailed failure"); expect(plain).toContain("END_BEYOND_6000"); expect(rows.join("\n")).toContain( (theme.fg("error", "Detailed failure").split("Detailed failure")[0] ?? "") + "Detailed failure", ); } else { expect(rows).toHaveLength(3); expect(plain).not.toContain("Detailed failure"); expect(stripTerminalSequences(rows[2] ?? "")).toBe("to expand"); } expect(plain).not.toContain("unsafe-error-payload"); expect(rows.join("\n")).not.toContain("\u001b[2J"); expect(rows.join("\n")).not.toContain("\u0000"); for (const width of [1, 2, 8, 80]) expect( view.render(width).every((line) => visibleWidth(line) <= width), ).toBe(true); } }); it("streams child tool name and bounded args only in human details, then replaces them with the answer", async () => { const f = await setup([]); const path = join(f.cwd, "evidence.txt"); await writeFile(path, "child evidence"); f.setResponses([ call({ prompt: "Read evidence", tools: ["read"], noExtensions: true }), fauxAssistantMessage(fauxToolCall("read", { path }, { id: "child-read" })), fauxAssistantMessage("fresh child answer"), fauxAssistantMessage("parent"), ]); const updates: Progress[] = []; const unsubscribe = f.session.subscribe((event) => { if (event.type !== "tool_execution_update" || event.toolName !== "pipi") return; expect(event.partialResult.content).toEqual([]); const details = event.partialResult.details as { progress: Progress }; updates.push(details.progress); }); try { await f.session.prompt("Delegate"); } finally { unsubscribe(); } expect(f.errors).toEqual([]); expect(result(f).outcome).toBe("completed"); const tool = updates.find((update) => update.tool?.name === "read"); expect(tool?.phase).toBe("tool"); expect(JSON.parse(tool?.tool?.args ?? "null")).toEqual({ path }); expect(tool?.tool?.args.length).toBeLessThanOrEqual(6000); const answer = updates.findLast((update) => update.phase === "answering"); expect(answer?.preview).toBe("fresh child answer"); expect(answer?.tool).toBeUndefined(); expect(f.session.getToolDefinition("pipi")?.label).toBe("π²"); }); it("bounds model-facing final content while retaining full native structured output and no intermediate traffic", async () => { const text = "evidence ".repeat(15000); const f = await setup([ call({ prompt: "Large answer", tools: [] }), fauxAssistantMessage(text), fauxAssistantMessage("parent"), ]); const updates: unknown[] = []; const unsubscribe = f.session.subscribe((event) => { if (event.type === "tool_execution_update" && event.toolName === "pipi") updates.push(event.partialResult.content); }); try { await f.session.prompt("Delegate"); } finally { unsubscribe(); } const tool = f.session.messages.find( (message) => message.role === "toolResult" && message.toolName === "pipi", ); if (tool?.role !== "toolResult") throw new Error("Missing pipi result"); const content = tool.content .filter((part) => part.type === "text") .map((part) => part.text) .join(""); expect(content.length).toBeLessThan(55000); expect(tool.details).toMatchObject({ result: { outcome: "completed", output: { role: "assistant", content: [{ type: "text", text }] }, }, }); expect(updates.length).toBeGreaterThan(0); expect( updates.every((update) => Array.isArray(update) && update.length === 0), ).toBe(true); }); it("inherits effective prompt controls recursively without leaking parent output submission requirements", async () => { const f = await setup([ call({ prompt: "Outer", tools: ["pipi"], forceSystemPrompt: "Forced inherited marker", outputSchema: { type: "integer" }, }), fauxAssistantMessage( fauxToolCall("pipi", { prompt: "Inner ordinary task" }, { id: "inner" }), ), (context) => { expect( getCurrentTools(context.messages).map((tool) => tool.name), ).not.toContain("pipi_output"); const prompt = getCurrentSystemPrompt(context.messages); expect(prompt).toContain("Forced inherited marker"); expect(prompt).not.toContain(""); return fauxAssistantMessage("inner ordinary answer"); }, fauxAssistantMessage( fauxToolCall("pipi_output", { output: 99 }, { id: "outer-output" }), ), fauxAssistantMessage("parent"), ]); await f.session.prompt("Delegate recursively with a forced prompt"); expect(result(f)).toMatchObject({ outcome: "completed", output: 99, turns: 2, }); }); it("continues in saved child cwd when caller omits cwd", async () => { const f = await setup([]); const cwd = join(f.cwd, "other-workspace"); await mkdir(cwd); f.setResponses([ call({ prompt: "First", cwd, tools: [], noExtensions: true }), fauxAssistantMessage("first"), fauxAssistantMessage("parent"), ]); await f.session.prompt("First task"); const first = result(f); expect(first.effective.cwd).toBe(cwd); f.setResponses([ call({ prompt: "Continue", sessionId: first.sessionId, tools: [], noExtensions: true, }), fauxAssistantMessage("second"), fauxAssistantMessage("parent"), ]); await f.session.prompt("Continue task"); expect(result(f)).toMatchObject({ outcome: "completed", sessionId: first.sessionId, effective: { cwd }, }); }); it.each(["project", "cli"] as const)( "preserves %s hook-only guard across child cwd changes", async (source) => { const root = await mkdtemp(join(tmpdir(), "pipi-guard-")); const originalCwd = process.cwd(); const originalArgs = process.argv; try { const parent = join(root, "parent"), target = join(root, "target"); await mkdir(parent); await mkdir(target); const directory = source === "project" ? join(parent, ".pi", "extensions") : parent; await mkdir(directory, { recursive: true }); const guard = join(directory, "guard.ts"); const body = (message: string) => `export default pi => { pi.on("tool_call", event => event.toolName === "write" ? {block:true,reason:${JSON.stringify(message)}} : undefined); };`; await writeFile(guard, body("original-guard")); await writeFile(join(target, "guard.ts"), body("wrong-guard")); process.chdir(parent); if (source === "cli") process.argv = [...originalArgs, "-e", "./guard.ts"]; fixture = await createPiSession({ cwd: parent, projectTrusted: true, extensionPaths: [ resolve(originalCwd, "extensions/pipi/index.ts"), guard, ], userSettings: { defaultTools: ["pipi", "write"], retry: { enabled: false }, cacheWarming: "off", }, env: { PI_PIPI_DEBUG: "0" }, responses: [ call({ prompt: "Attempt write", cwd: target, tools: ["write"] }), fauxAssistantMessage( fauxToolCall("write", { path: "evidence.txt", content: "should not write", }), ), fauxAssistantMessage("guard prevented write"), fauxAssistantMessage("parent"), ], }); await fixture.session.prompt("Delegate"); const value = result(fixture); expect(value.outcome).toBe("completed"); const transcript = await readFile(value.sessionFile as string, "utf8"); expect(transcript).toContain("original-guard"); expect(transcript).not.toContain("wrong-guard"); await expect(stat(join(target, "evidence.txt"))).rejects.toMatchObject({ code: "ENOENT", }); } finally { process.argv = originalArgs; process.chdir(originalCwd); await fixture?.dispose(); fixture = undefined; await rm(root, { recursive: true, force: true }); } }, ); it("inherits parent-only runtime authentication without persisting credentials", async () => { const f = await setup([]); await f.session.modelRuntime.setRuntimeApiKey( "faux", "parent-runtime-fixture", ); let observed: string | undefined; f.setResponses([ call({ prompt: "Use inherited auth", tools: [], noExtensions: true }), (_context, options) => { observed = options?.apiKey; return fauxAssistantMessage("authenticated child"); }, fauxAssistantMessage("parent"), ]); await f.session.prompt("Delegate"); expect(result(f).outcome).toBe("completed"); expect(observed).toBe("parent-runtime-fixture"); const stored = await readFile(join(f.agentDir, "auth.json"), "utf8").catch( (error: NodeJS.ErrnoException) => { if (error.code === "ENOENT") return "{}"; throw error; }, ); expect(JSON.parse(stored)).toEqual({}); });