1 +import { constants, existsSync } from "node:fs";
9 +} from "node:fs/promises";
10 +import { homedir } from "node:os";
20 +import { pathToFileURL } from "node:url";
21 +import { PROMPT, snapshot, summarize } from "./context-startup.mjs";
23 +// Resolve the installed executable, not this repository's SDK dependency.
24 +export async function installedPiDist() {
25 + for (const directory of (process.env.PATH ?? "").split(delimiter)) {
26 + const candidate = resolve(directory, "pi");
28 + await access(candidate, constants.X_OK);
29 + if (!(await stat(candidate)).isFile()) continue;
33 + let directoryPath = dirname(await realpath(candidate));
36 + const manifest = JSON.parse(
37 + await readFile(join(directoryPath, "package.json"), "utf8"),
39 + if (manifest.name === "@earendil-works/pi-coding-agent")
40 + return join(directoryPath, "dist");
42 + if (error.code !== "ENOENT")
43 + throw new Error("Could not locate installed Pi");
45 + const parent = dirname(directoryPath);
46 + if (parent === directoryPath) break;
47 + directoryPath = parent;
51 + throw new Error("Could not locate installed Pi");
54 +export async function estimateSourceTokens(
57 + { skills, diagnostics },
59 + const append = await readFile(join(agentDir, "APPEND_SYSTEM.md"), "utf8");
60 + if (diagnostics.length)
62 + "Skill catalog has diagnostics; refusing a partial estimate",
64 + const tokens = (content) =>
65 + sdk.estimateTokens({ role: "user", content, timestamp: 0 });
66 + const groups = { piAgent: [], extensions: [] };
67 + let ignoredProjectSkills = 0;
68 + for (const skill of skills.filter((skill) => !skill.disableModelInvocation)) {
69 + const source = skill.sourceInfo;
71 + source?.origin === "package" ||
72 + source?.source?.startsWith("extension:")
74 + groups.extensions.push(skill);
76 + resolve(skill.filePath).startsWith(`${resolve(agentDir, "skills")}${sep}`)
78 + groups.piAgent.push(skill);
79 + } else if (source?.scope === "project") {
80 + ignoredProjectSkills++;
82 + throw new Error("Unattributed skill source; refusing a partial estimate");
85 + const parts = (items) => {
86 + const text = sdk.formatSkillsForPrompt(items);
87 + if (!text) return { shared: "", entries: "" };
88 + const start = text.indexOf(" <skill>");
89 + const end = text.lastIndexOf("</available_skills>");
90 + if (start < 0 || end <= start)
91 + throw new Error("Pi skill catalog format changed");
93 + shared: text.slice(0, start) + text.slice(end),
94 + entries: text.slice(start, end),
97 + const piAgent = parts(groups.piAgent);
98 + const extensions = parts(groups.extensions);
99 + const shared = piAgent.shared || extensions.shared;
100 + const appendix = tokens(append);
101 + const catalog = tokens(shared + piAgent.entries + extensions.entries);
104 + descriptions: groups.piAgent
105 + .map(({ name, description }) => ({
108 + tokens: tokens(description),
112 + b.description.length - a.description.length ||
113 + a.name.localeCompare(b.name),
115 + piAgent: { tokens: tokens(piAgent.entries), count: groups.piAgent.length },
117 + tokens: tokens(extensions.entries),
118 + count: groups.extensions.length,
120 + shared: tokens(shared),
121 + ignoredProjectSkills,
123 + total: appendix + catalog,
127 +export function inspectExtensionRegistrations(
128 + { extensions, runtime },
131 + const providers = [
132 + ...(runtime.pendingProviderRegistrations ?? []).map(
133 + ({ name, extensionPath }) => ({ name, path: extensionPath }),
135 + ...(runtime.pendingNativeProviderRegistrations ?? []).map(
136 + ({ provider, extensionPath }) => ({
138 + path: extensionPath,
143 + .filter((extension) => !extension.path.startsWith("<inline:"))
144 + .map((extension) => {
145 + const path = extension.path;
146 + const file = basename(path, extname(path));
149 + name: file === "index" ? basename(dirname(path)) : file,
150 + tools: [...extension.tools.keys()].sort(),
151 + hooks: [...extension.handlers.keys()].sort(),
154 + ...(previous.find((entry) => entry.path === path)?.providers ?? []),
156 + .filter((entry) => entry.path === path)
157 + .map((entry) => entry.name),
164 +export function resourceOptions(
166 + extensionFactories,
167 + { cwd, agentDir, projectTrusted, extensionPaths } = {},
169 + if (kind === "headless+1msg+no_pi_config") {
170 + // Keep the real settings and extension discovery. Remove only agent-dir text resources.
171 + const root = resolve(agentDir);
172 + const outside = (path, directory) =>
173 + !resolve(path).startsWith(`${join(root, directory)}${sep}`);
174 + const projectPrompt = (name) => {
175 + const path = join(cwd, ".pi", name);
176 + return projectTrusted && existsSync(path) ? path : "";
178 + const append = projectPrompt("APPEND_SYSTEM.md");
180 + extensionFactories,
181 + agentsFilesOverride: (base) => ({
183 + agentsFiles: base.agentsFiles.filter(
184 + (file) => dirname(resolve(file.path)) !== root,
187 + skillsOverride: (base) => ({
189 + skills: base.skills.filter((skill) =>
190 + outside(skill.filePath, "skills"),
193 + promptsOverride: (base) => ({
195 + prompts: base.prompts.filter((prompt) =>
196 + outside(prompt.filePath, "prompts"),
199 + systemPrompt: projectPrompt("SYSTEM.md"),
200 + appendSystemPrompt: append ? [append] : [],
203 + return kind === "baseline+1msg"
205 + noExtensions: true,
207 + noPromptTemplates: true,
209 + noContextFiles: true,
211 + appendSystemPrompt: [],
212 + extensionFactories,
215 + extensionFactories,
216 + ...(extensionPaths === undefined
218 + : { noExtensions: true, additionalExtensionPaths: extensionPaths }),
222 +export function observeRequests(agent, observe) {
223 + const stream = agent.streamFunction;
224 + if (typeof stream !== "function")
225 + throw new Error("Pi stream API unavailable");
226 + agent.streamFunction = (model, context, options) => {
228 + return stream(model, context, options);
232 +// Only counts and public run metadata cross the process boundary.
233 +export async function publish(path, value) {
234 + await writeFile(`${path}.tmp`, JSON.stringify(value), { mode: 0o600 });
235 + await rename(`${path}.tmp`, path);
238 +export async function runSession(options) {
239 + const { kind, cwd, agentDir, sourceAgentDir, resultPath, selection } =
241 + const baseline = kind === "baseline+1msg";
242 + process.env.PI_CODING_AGENT_DIR = agentDir;
243 + process.env.PI_OFFLINE = "1";
244 + process.env.AI_AGENT = "pi";
245 + process.env.PI_CODING_AGENT = "true";
247 + let inventory = [];
248 + let stopThemeWatcher;
249 + let stage = "installed Pi loading";
250 + let published = false;
251 + const finish = async (value) => {
252 + if (published) return;
254 + if (options.sourcesOnly) {
256 + console.error(value.error);
259 + const result = value.sources;
260 + const n = (value) => value.toLocaleString("en-US");
261 + if (options.skillDescriptions) {
262 + const entries = result.descriptions;
265 + `pi/agent: ${entries.length} visible skills, largest descriptions first`,
266 + "~tok skill (raw description only, Pi chars/4)",
268 + (entry) => `${String(entry.tokens).padStart(4)} ${entry.name}`,
271 + "Largest five descriptions:",
274 + .map((entry) => `${entry.name}: ${entry.description}`),
281 + `APPEND_SYSTEM.md: ~${n(result.appendix)} tok`,
282 + `pi/agent skills (${result.piAgent.count}): ~${n(result.piAgent.tokens)} tok`,
283 + `Extension/package skills (${result.extensions.count}): ~${n(result.extensions.tokens)} tok`,
284 + `Shared catalog instructions/wrapper: ~${n(result.shared)} tok`,
285 + `Total: ~${n(result.total)} tok (Pi chars/4; group rounding may differ)`,
286 + `Project-local skills excluded: ${result.ignoredProjectSkills}; skill bodies and prompt templates excluded.`,
290 + await publish(resultPath, value);
294 + const dist = await installedPiDist();
295 + const load = (path) => import(pathToFileURL(join(dist, path)).href);
298 + { ReadOnlyAuthStorage },
299 + { InMemoryCodingAgentModelsStore },
300 + { builtInExtensions },
302 + { initTheme, stopThemeWatcher: stopWatcher },
304 + ] = await Promise.all([
306 + load("core/auth-storage.js"),
307 + load("core/models-store.js"),
308 + load("extensions/index.js"),
309 + load("core/trust-manager.js"),
310 + load("modes/interactive/theme/theme.js"),
311 + load("core/messages.js"),
313 + stopThemeWatcher = stopWatcher;
314 + const { version } = JSON.parse(
315 + await readFile(join(dist, "../package.json"), "utf8"),
317 + stage = "project trust resolution (use normal Pi to establish trust first)";
318 + let projectTrusted = false;
321 + !trust.hasTrustRequiringProjectResources(cwd) ||
322 + new trust.ProjectTrustStore(agentDir).get(cwd);
323 + if (projectTrusted === null) {
324 + const policy = sdk.SettingsManager.create(cwd, agentDir, {
325 + projectTrusted: false,
326 + }).getDefaultProjectTrust();
327 + if (policy === "ask") throw new Error();
328 + projectTrusted = policy === "always";
331 + const settingsManager = baseline
332 + ? sdk.SettingsManager.inMemory({}, { projectTrusted: false })
333 + : sdk.SettingsManager.create(cwd, agentDir, { projectTrusted });
334 + stage = "read-only authentication/model initialization";
335 + const modelRuntime = await sdk.ModelRuntime.create({
336 + credentials: new ReadOnlyAuthStorage(join(sourceAgentDir, "auth.json")),
337 + modelsPath: baseline ? null : join(agentDir, "models.json"),
338 + modelsStore: new InMemoryCodingAgentModelsStore(),
339 + allowModelNetwork: false,
344 + let extensionErrors = 0;
346 + name: "context-measurement",
349 + pi.on("session_start", (_event, ctx) => {
350 + contextMode = ctx.mode;
353 + // Keep schemas intact, but fail closed if the reply-only request tries tools.
354 + pi.on("tool_call", () => {
359 + reason: "Context measurement permits no tool execution",
364 + stage = "resource/session initialization";
365 + runtime = await sdk.createAgentSessionRuntime(
366 + async ({ sessionManager, sessionStartEvent }) => {
367 + const services = await sdk.createAgentSessionServices({
372 + resourceLoaderOptions: {
373 + ...resourceOptions(kind, [...builtInExtensions, observer], {
377 + extensionPaths: options.extensionPaths,
379 + ...(options.inspectExtensions
381 + extensionsOverride(base) {
382 + inventory = inspectExtensionRegistrations(base);
390 + services.diagnostics.some((d) => d.type === "error") ||
391 + services.resourceLoader.getExtensions().errors.length ||
392 + settingsManager.drainErrors().length ||
393 + modelRuntime.getError()
396 + const model = selection
397 + ? modelRuntime.getModel(selection.provider, selection.model)
399 + if (selection && !model) {
401 + ? "selected model unavailable in stock Pi (no user model config imported)"
402 + : "configured model selection";
405 + const created = await sdk.createAgentSessionFromServices({
410 + thinkingLevel: selection?.thinking,
412 + return { ...created, services, diagnostics: services.diagnostics };
414 + { cwd, agentDir, sessionManager: sdk.SessionManager.inMemory(cwd) },
416 + const { session } = runtime;
417 + stage = "startup model selection";
418 + if (!session.model) throw new Error();
419 + session.extensionRunner.onError(() => {
424 + const messages = [];
425 + observeRequests(session.agent, (context) => {
427 + local = snapshot(context, sdk.estimateTokens);
429 + session.subscribe((event) => {
430 + if (event.type === "message_end" && event.message.role === "assistant")
431 + messages.push(event.message);
433 + const metadata = () => ({
437 + provider: session.model?.provider,
438 + model: session.model?.id,
439 + thinking: session.thinkingLevel,
440 + contextWindow: session.model?.contextWindow,
444 + ...(options.inspectExtensions ? { extensions: inventory } : {}),
446 + const result = () => {
447 + if (requests !== 1 || toolCalls || extensionErrors) {
450 + error: `Invalid run: ${requests} requests, ${toolCalls} tool calls, ${extensionErrors} extension errors`,
454 + const usage = summarize(
456 + .map((message) => JSON.stringify({ type: "message_end", message }))
459 + return { ...metadata(), local, ...usage, requests };
464 + "No valid single response/usage; check provider access and read-only credential validity",
468 + initTheme(settingsManager.getTheme(), false);
469 + stage = "headless startup hooks";
470 + await session.bindExtensions({
476 + if (contextMode !== "json" || hasUI || extensionErrors) throw new Error();
477 + if (options.inspectExtensions) {
478 + stage = "runtime extension inventory";
479 + inventory = inspectExtensionRegistrations(
480 + runtime.services.resourceLoader.getExtensions(),
484 + options.extensionPaths !== undefined &&
485 + JSON.stringify(inventory.map((entry) => entry.path)) !==
486 + JSON.stringify(options.extensionPaths)
488 + stage = "explicit extension set/order validation";
492 + if (kind === "headless+0msg") {
493 + if (requests || messages.length) throw new Error();
494 + stage = "skill source attribution";
495 + const sources = options.sourcesOnly
496 + ? await estimateSourceTokens(
499 + runtime.services.resourceLoader.getSkills(),
507 + ...session.agent.state,
508 + messages: convertToLlm(session.messages),
510 + sdk.estimateTokens,
515 + stage = "provider request (read-only credentials must already be valid)";
516 + await session.prompt(PROMPT);
517 + stage = "single-response/usage validation";
518 + await finish(result());
521 + await finish({ kind, error: `${stage} failed` });
522 + process.exitCode = 1;
524 + for (const cleanup of [
525 + () => runtime?.dispose(),
526 + () => stopThemeWatcher?.(),
531 + process.exitCode = 1;
539 + import.meta.url === pathToFileURL(resolve(process.argv[1])).href
541 + if (["--sources", "--skill-descriptions"].includes(process.argv[2])) {
543 + process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
545 + kind: "headless+0msg",
546 + cwd: process.cwd(),
548 + sourceAgentDir: agentDir,
550 + skillDescriptions: process.argv[2] === "--skill-descriptions",
553 + await runSession(JSON.parse(await readFile(process.argv[2], "utf8")));
555 + process.exit(process.exitCode ?? 0);