repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by bugabinga

fix: modernize Pi extension API usage

0caafa04702871845da1149a54d091411d4f8b07

Oliver Jan Krylow <oliver@bugabinga.net> ·

unsigned

Browse filesCompare with HEAD

Changed files (24)

CHANGELOG.md

Modified
2 2 # Changelog
4 4 ## Unreleased
6 +- Modernize extensions for Pi 0.84 API changes around agent sessions, provider headers, auth, and RPC message updates
6 7 - Fix The System README artifact path docs to show plural directories
7 8 - Make `/system init` deterministic with confirmation; it creates schema v3 config, plural artifact directories, and core files directly
8 9 - Fix exact `/system` subcommands such as `doctor` and `book` so autocomplete does not consume Enter

extensions/angel/index.ts

Modified
14 14 import * as fs from "node:fs/promises";
15 15 import * as path from "node:path";
16 -import type { Api, Model } from "@earendil-works/pi-ai";
16 +import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
17 17 import { complete } from "@earendil-works/pi-ai/compat";
18 18 import type {
19 19 ExtensionAPI,
441 441 async function consult(
442 442 binding: Binding,
443 443 packet: ContextPacket,
444 - auth: { apiKey?: string; headers?: Record<string, string> },
444 + auth: { apiKey?: string; headers?: ProviderHeaders },
445 445 signal?: AbortSignal,
446 446 ): Promise<AngelResult> {
447 447 const res = await complete(

extensions/btw/index.ts

Modified
650 650 const { session } = await createAgentSession({
651 651 sessionManager: SessionManager.inMemory(),
652 652 model: ctx.model,
653 - modelRegistry: ctx.modelRegistry as AgentSession["modelRegistry"],
654 653 thinkingLevel: pi.getThinkingLevel() as SessionThinkingLevel,
655 654 tools: [...SIDE_TOOLS],
656 655 resourceLoader: createBtwResourceLoader(ctx),
856 855 const { session } = await createAgentSession({
857 856 sessionManager: SessionManager.inMemory(),
858 857 model,
859 - modelRegistry: ctx.modelRegistry as AgentSession["modelRegistry"],
860 858 thinkingLevel: "off",
861 859 tools: [],
862 860 resourceLoader: createBtwResourceLoader(ctx, [BTW_SUMMARY_PROMPT]),

extensions/devil/index.ts

Modified
31 31 import { tmpdir } from "node:os";
32 32 import { join } from "node:path";
33 33 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
34 -import type { Api, Model } from "@earendil-works/pi-ai";
34 +import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
35 35 import { complete } from "@earendil-works/pi-ai/compat";
36 36 import type {
37 37 ExtensionAPI,
213 213 defenderModel: AnyModel;
214 214 ctx: ExtensionContext;
215 215 apiKey?: string;
216 - headers?: Record<string, string>;
216 + headers?: ProviderHeaders;
217 217 devilThinkingLevel: ThinkingLevel;
218 218 defenderThinkingLevel: ThinkingLevel;
219 219 synthesisThinkingLevel: ThinkingLevel;
533 533 agentDir,
534 534 model: opts.model,
535 535 thinkingLevel: opts.thinkingLevel,
536 - modelRegistry: opts.ctx.modelRegistry,
537 536 resourceLoader: loader,
538 537 sessionManager: fork.manager,
539 538 settingsManager,
726 725 roundsData: string[],
727 726 model: AnyModel,
728 727 apiKey: string | undefined,
729 - headers: Record<string, string> | undefined,
728 + headers: ProviderHeaders | undefined,
730 729 signal: AbortSignal | undefined,
731 730 thinkingLevel: ThinkingLevel,
732 731 roleTimeoutMs: number,

extensions/goal/index.ts

Modified
2029 2029 const { session } = await createAgentSession({
2030 2030 cwd: ctx.cwd,
2032 - modelRegistry: ctx.modelRegistry,
2033 2032 resourceLoader: loader,
2034 2033 sessionManager: SessionManager.inMemory(ctx.cwd),
2035 2034 tools: ["read", "grep", "find", "ls", "bash"],
2312 2311 const { session } = await createAgentSession({
2313 2312 cwd: ctx.cwd,
2315 - modelRegistry: ctx.modelRegistry,
2316 2314 resourceLoader: loader,
2317 2315 sessionManager: SessionManager.inMemory(ctx.cwd),
2318 2316 tools: ["read", "grep", "find", "ls", "bash"],

extensions/llmiterate/__tests__/fake-rpc-child.mjs

Modified
49 49 if (mode === "hang" && msg.type === "prompt") {
50 50 send({
51 51 type: "message_update",
52 - message: {
53 - role: "assistant",
54 - content: [{ type: "text", text: "streaming forever" }],
52 + assistantMessageEvent: {
53 + type: "text_delta",
54 + contentIndex: 0,
55 + delta: "streaming forever",
57 58 return;
60 61 if (msg.type === "prompt") {
61 62 send({
62 63 type: "message_update",
63 - message: {
64 - role: "assistant",
65 - content: [{ type: "text", text: "streaming" }],
64 + assistantMessageEvent: {
65 + type: "text_delta",
66 + contentIndex: 0,
67 + delta: "streaming",
68 70 send({ type: "tool_execution_start", toolName: "edit" });

extensions/llmiterate/__tests__/rpc-full.test.ts

Modified
67 67 const first = events[0];
68 68 expect(first.type).toBe("message_update");
69 69 if (first.type === "message_update") {
70 - const content = first.message?.content;
71 - expect(Array.isArray(content) ? content[0]?.text : undefined).toBe(
72 - "streaming",
73 - );
70 + expect(first.assistantMessageEvent).toEqual({
71 + type: "text_delta",
72 + contentIndex: 0,
73 + delta: "streaming",
74 + });

extensions/llmiterate/index.ts

Modified
31 31 } from "./state";
32 32 import type {
33 33 LlmiterateRun,
34 + RpcAssistantMessageEvent,
34 35 RpcEvent,
35 36 RpcMessage,
36 37 RpcTextPart,
591 592 switch (event.type) {
592 593 case "message_update":
594 + this.updateAssistantDelta(run, event.assistantMessageEvent);
595 + break;
593 596 case "message_end":
594 597 if (event.message?.role === "assistant")
595 598 this.updateAssistantText(run, event.message);
676 679 this.touchRun(run);
682 + private updateAssistantDelta(
683 + run: LlmiterateRun,
684 + event: RpcAssistantMessageEvent | undefined,
685 + ): void {
686 + if (event?.type !== "text_delta" || typeof event.delta !== "string") return;
687 + run.assistantText += event.delta;
688 + this.touchRun(run);
679 691 private updateToolText(run: LlmiterateRun, text: string): void {
680 692 run.toolText = text;
681 693 this.touchRun(run);

extensions/llmiterate/types.ts

Modified
35 35 content?: string | RpcTextPart[];
38 +export interface RpcAssistantMessageEvent {
39 + type?: string;
40 + contentIndex?: unknown;
41 + delta?: unknown;
42 + content?: unknown;
38 45 export type RpcEvent =
39 - | { type: "message_update" | "message_end"; message?: RpcMessage }
46 + | {
47 + type: "message_update";
48 + assistantMessageEvent?: RpcAssistantMessageEvent;
49 + }
50 + | { type: "message_end"; message?: RpcMessage }
40 51 | { type: "tool_execution_start"; toolName?: unknown }
42 53 type: "tool_execution_end";

extensions/overkill/__tests__/optimizer.test.ts

Modified
56 56 agentDir: "/agent",
57 57 model: frozen,
58 58 targetModel: { provider: "test", id: "frozen" },
59 - modelRegistry: { find() {} },
60 - } as never,
59 + },
62 61 DefaultResourceLoader: Loader,
63 62 SettingsManager: { inMemory: (value: unknown) => value },

extensions/overkill/__tests__/rollouts.test.ts

Modified
54 54 id: "frozen",
55 55 thinkingLevelMap: { high: "high" },
57 -const modelRegistry = { find: () => resolvedModel };
59 58 function targetSession(events: unknown[] = []) {
60 59 const listeners = new Set<(event: any) => void>();
131 130 candidatePath: snapshot,
132 131 model: frozenModel,
133 132 targetModel: resolvedModel,
134 - modelRegistry,
135 - } as never,
133 + },
137 135 DefaultResourceLoader: Loader,
138 136 SettingsManager: { inMemory: (value: unknown) => value },
161 159 expect.objectContaining({
162 160 cwd: "/project",
163 161 model: resolvedModel,
164 - modelRegistry,
165 162 thinkingLevel: "high",
166 163 tools: ["read", "grep", "find", "ls"],
167 164 sessionManager: { kind: "in-memory", cwd: "/project" },

extensions/overkill/index.ts

Modified
562 562 candidatePath: join(options.directory, "baseline-snapshot.md"),
563 563 model: manifest.model,
564 564 targetModel: options.targetModel,
565 - modelRegistry: ctx.modelRegistry,
567 566 acceptanceSeam?.targetSdk ?? defaultTargetSdk,
852 851 agentDir: getAgentDir(),
853 852 model: manifest.model,
854 853 targetModel: options.targetModel,
855 - modelRegistry: ctx.modelRegistry,
857 855 acceptanceSeam?.optimizerSdk ?? defaultOptimizerSdk,
982 980 model: manifest.model,
983 981 targetModel: options.targetModel,
984 - modelRegistry: ctx.modelRegistry,
986 983 acceptanceSeam?.targetSdk ?? defaultTargetSdk,
1420 1417 agentDir: getAgentDir(),
1421 1418 model: manifest.model,
1422 1419 targetModel: options.targetModel,
1423 - modelRegistry: ctx.modelRegistry,
1425 1421 installedAftermathAcceptanceSeam()?.structuredOutputSdk,
1609 1605 agentDir: getAgentDir(),
1610 1606 model: manifest.model,
1611 1607 targetModel: options.targetModel,
1612 - modelRegistry: ctx.modelRegistry,
1614 1609 installedAftermathAcceptanceSeam()?.structuredOutputSdk,

extensions/overkill/lib/aftermath-mining.ts

Modified
300 300 agentDir: string;
301 301 model: { thinking: string };
302 302 targetModel: unknown;
303 - modelRegistry: unknown;
305 304 sdk: StructuredOutputSdkSeam = defaultStructuredOutputSdk,
306 305 ): Promise<MiningSession> {
323 322 cwd: options.cwd,
324 323 agentDir: options.agentDir,
325 324 model: options.targetModel as never,
326 - modelRegistry: options.modelRegistry as never,
327 325 thinkingLevel: options.model.thinking as never,
328 326 tools: ["structured_output"],
329 327 customTools: [miningOutput],

extensions/overkill/lib/aftermath-scoring.ts

Modified
122 122 agentDir: string;
123 123 model: { thinking: string };
124 124 targetModel: unknown;
125 - modelRegistry: unknown;
127 126 sdk: StructuredOutputSdkSeam = defaultStructuredOutputSdk,
128 127 ): Promise<RubricJudgeSession> {
145 144 cwd: options.cwd,
146 145 agentDir: options.agentDir,
147 146 model: options.targetModel as never,
148 - modelRegistry: options.modelRegistry as never,
149 147 thinkingLevel: options.model.thinking as never,
150 148 tools: ["structured_output"],
151 149 customTools: [rubricOutput],

extensions/overkill/lib/optimizer.ts

Modified
98 98 agentDir: string;
99 99 model: FrozenModel;
100 100 targetModel: unknown;
101 - modelRegistry: unknown;
103 102 sdk: OptimizerSdkSeam = defaultOptimizerSdk,
104 103 ): Promise<OptimizerSession> {
121 120 cwd: options.cwd,
122 121 agentDir: options.agentDir,
123 122 model: options.targetModel,
124 - modelRegistry: options.modelRegistry,
125 123 thinkingLevel: options.model.thinking,
126 124 tools: ["structured_output"],
127 125 customTools: [structuredOutput],

extensions/overkill/lib/rollouts.ts

Modified
225 225 candidatePath: string;
226 226 model: FrozenModel;
227 227 targetModel: unknown;
228 - modelRegistry: unknown;
230 229 sdk: TargetSdkSeam,
231 230 ): Promise<TargetSession> {
270 269 cwd: options.cwd,
271 270 agentDir: options.agentDir,
272 271 model: options.targetModel,
273 - modelRegistry: options.modelRegistry,
274 272 thinkingLevel: options.model.thinking,
275 273 tools: [...READ_ONLY_TOOLS],
276 274 sessionManager: sdk.SessionManager.inMemory(options.cwd),

extensions/pulse/index.ts

Modified
8 8 import { createHash } from "node:crypto";
9 9 import * as fs from "node:fs";
10 10 import * as path from "node:path";
11 +import type { ProviderHeaders } from "@earendil-works/pi-ai";
11 12 import {
12 13 complete as piComplete,
13 14 getModel as piGetModel,
354 355 docs: LoadedPulseDoc[],
355 356 recentMessages: unknown[],
356 357 model: { provider: string; id: string },
357 - auth: { apiKey?: string; headers?: Record<string, string> },
358 + auth: { apiKey?: string; headers?: ProviderHeaders },
358 359 ): Promise<PulseUpdate[]> {
359 360 const conversation = serializeConversation(
360 361 convertToLlm(recentMessages as any),

extensions/quota/index.ts

Modified
484 484 return ctx.model?.provider?.toLowerCase();
487 - async function codexAccountId(
488 - ctx: ExtensionContext,
489 - ): Promise<string | undefined> {
487 + async function codexAccountId(): Promise<string | undefined> {
491 - const cred = ctx.modelRegistry.authStorage.get("openai-codex") as any;
489 + const pi = (await import("@earendil-works/pi-coding-agent")) as any;
490 + const cred = pi.readStoredCredential?.("openai-codex") as any;
492 491 if (typeof cred?.accountId === "string") return cred.accountId;
493 492 } catch {}
531 530 if (key === "openai-codex") {
532 531 const apiKey = await ctx.modelRegistry.getApiKeyForProvider(key);
533 - const accountId = await codexAccountId(ctx);
532 + const accountId = await codexAccountId();
534 533 return apiKey && accountId
535 534 ? keepCached("OpenAI Codex", async () =>
536 535 parseCodex(await fetchCodex(apiKey, accountId)),

extensions/tldr/index.ts

Modified
1 -import type { Model, UserMessage } from "@earendil-works/pi-ai";
1 +import type {
2 + Model,
3 + ProviderHeaders,
4 + UserMessage,
5 +} from "@earendil-works/pi-ai";
2 6 import { complete } from "@earendil-works/pi-ai/compat";
3 7 import {
4 8 type ExtensionAPI,
50 54 type TldrAuth = {
51 55 model: Model<any>;
52 56 apiKey?: string;
53 - headers?: Record<string, string>;
57 + headers?: ProviderHeaders;
56 60 type TldrEngineOptions = {

extensions/ultra/__tests__/drivers.test.ts

Modified
43 43 DefaultResourceLoader: FakeLoader as any,
44 44 getAgentDir: () => "/agent",
45 45 cwd: "/work",
46 - modelRegistry: { id: "registry" },
49 48 const sessionManager = { id: "fresh-inmemory" };
75 74 const opts = createAgentSession.mock.calls[0][0] as Record<string, unknown>;
76 75 expect(opts.cwd).toBe("/work");
77 76 expect(opts.model).toEqual({ id: "m" });
78 - expect(opts.modelRegistry).toEqual({ id: "registry" });
77 + expect(opts).not.toHaveProperty("modelRegistry");
79 78 expect(opts.resourceLoader).toBeInstanceOf(FakeLoader);
80 79 expect(opts.thinkingLevel).toBe("low");
81 80 expect(opts.sessionManager).toBe(sessionManager); // fresh inMemory, NOT a branch fork (#2)
101 100 DefaultResourceLoader: FakeLoader as any,
102 101 getAgentDir: () => "/agent",
103 102 cwd: "/work",
104 - modelRegistry: {},
105 103 loadExtensions: true,
107 105 await factory({
159 157 systemPrompt: "SYS",
160 158 messages: [{ role: "user", content: "hi" }],
161 159 apiKey: "sk-123",
162 - headers: { "x-h": "1" },
160 + headers: { "x-delete": null, "x-h": "1" },
163 161 signal,
177 175 expect(options.apiKey).toBe("sk-123"); // #4 auth threaded
178 - expect(options.headers).toEqual({ "x-h": "1" });
176 + expect(options.headers).toEqual({ "x-delete": null, "x-h": "1" });
179 177 expect(options.signal).toBe(signal);
180 178 expect(options.cacheRetention).toBe("none");

extensions/ultra/__tests__/runner.test.ts

Modified
59 59 resolveAuth: vi.fn(async () => ({
60 60 ok: true,
61 61 apiKey: "KEY",
62 - headers: { "x-h": "1" },
62 + headers: { "x-delete": null, "x-h": "1" },
64 64 ...over,
233 233 // {apiKey, headers} threaded into the completeFn request
234 234 const req = completeFn.mock.calls[0][0];
235 235 expect(req.apiKey).toBe("KEY");
236 - expect(req.headers).toEqual({ "x-h": "1" });
236 + expect(req.headers).toEqual({ "x-delete": null, "x-h": "1" });
237 237 expect(req.model).toEqual({ id: "default-model" });
238 238 expect(req.messages[0]).toEqual({ role: "user", content: "do X" });

extensions/ultra/drivers.ts

Modified
11 11 // or hitting a model is the deferred Task-10 live gate.
13 13 // SDK shapes verified against the in-repo reference call sites:
14 -// - createAgentSession resolves to `{ session }` (goal/index.ts:1952).
14 +// - createAgentSession resolves to `{ session }` and accepts `modelRuntime`, not legacy `modelRegistry`.
15 15 // - DefaultResourceLoader options incl. `noPromptTemplates` (resource-loader.d.ts:37).
16 16 // - complete(model, {systemPrompt, messages:[{role,content:[{type:"text",text}],timestamp}]},
17 17 // {apiKey, headers, signal, cacheRetention}) → {stopReason?, errorMessage?, content:[{type,text}]}
18 18 // (angel/index.ts:471, devil/index.ts:731, goal/index.ts:2108).
19 19 // - modelRegistry.find(provider, id) / getApiKeyAndHeaders(model) (goal/index.ts:1752, :2081).
21 +import type { ProviderHeaders } from "@earendil-works/pi-ai";
21 22 import type {
22 23 CompleteFn,
23 24 ResolveAuth,
41 42 ) => { reload(): Promise<void> };
42 43 getAgentDir: () => string;
43 44 cwd: string;
44 - modelRegistry: unknown;
45 45 /** When true, sub-agents load host extensions (their tools become grantable).
46 46 * Omitted/false ⇒ isolated (`noExtensions: true`), today's behaviour. */
47 47 loadExtensions?: boolean;
75 75 const { session } = await deps.createAgentSession({
76 76 cwd: deps.cwd,
77 77 model,
78 - modelRegistry: deps.modelRegistry,
79 78 resourceLoader,
80 79 thinkingLevel,
81 80 sessionManager, // the fresh inMemory manager (#2 — never a parent-branch fork)
127 126 options: {
128 127 apiKey?: string;
129 - headers?: Record<string, string>;
128 + headers?: ProviderHeaders;
130 129 signal?: AbortSignal;
131 130 cacheRetention?: string;

extensions/ultra/index.ts

Modified
137 137 DefaultResourceLoader as unknown as SessionFactoryDeps["DefaultResourceLoader"],
138 138 getAgentDir,
139 139 cwd: ctx.cwd,
140 - modelRegistry: ctx.modelRegistry,
141 140 loadExtensions: cfg.subagentExtensions === "all",
143 142 resolveModel: makeResolveModel({

extensions/ultra/runner.ts

Modified
29 29 // `{ type:"text_delta", delta }`; a terminating tool's structured payload is
30 30 // on `tool_execution_end.result.details` (read by progress.ts's mapper).
32 +import type { ProviderHeaders } from "@earendil-works/pi-ai";
32 33 import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
33 34 import {
34 35 type AgentControls,
71 72 export interface ResolvedAuth {
72 73 ok?: boolean;
73 74 apiKey?: string;
74 - headers?: Record<string, string>;
75 + headers?: ProviderHeaders;
75 76 error?: string;
87 88 systemPrompt?: string;
88 89 messages: CompleteMessage[];
89 90 apiKey?: string;
90 - headers?: Record<string, string>;
91 + headers?: ProviderHeaders;
91 92 signal?: AbortSignal;