@herbertgao/pi-extensions 2026.10.1 → 2026.10.3

package/node_modules/@tifan/pi-recap/src/index.ts

@@ -1,5 +1,5 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core"
-import type { Message } from "@earendil-works/pi-ai"
+import type { AssistantMessage, Message } from "@earendil-works/pi-ai"
 import type { AutocompleteItem } from "@earendil-works/pi-tui"
 import type {
   ExtensionAPI,
@@ -35,7 +35,9 @@ import {
 } from "./tui.js"
 
 const RECAP_MAX_TOKENS = 160
-const RECAP_REQUEST_TIMEOUT_MS = 4_000
+// opencode.ai-backed models are slow enough that a 4s budget is regularly
+// exceeded even for small sessions.
+const RECAP_REQUEST_TIMEOUT_MS = 30_000
 const AWAY_RECAP_DELAY_MS = 5 * 60 * 1_000
 const RECAP_ENTRY_TYPE = "pi-recap:state"
 
@@ -252,6 +254,35 @@ function buildPrompt(messages: AgentMessage[]): Message {
   }
 }
 
+/**
+ * opencode.ai-backed providers reject requests that omit `x-opencode-session`.
+ * pi adds these headers on its own agent path, but `modelRegistry.complete()`
+ * only forwards `options.headers`, so the extension has to supply them itself.
+ * Without this, every recap against opencode/opencode-go fails with
+ * 400 MissingSessionID and `stopReason: "error"`.
+ */
+function opencodeSessionHeaders(
+  model: { provider: string; baseUrl?: string },
+  sessionId: string,
+): Record<string, string> | undefined {
+  let host: string | undefined
+  if (model.baseUrl) {
+    try {
+      host = new URL(model.baseUrl).hostname
+    } catch {
+      host = undefined
+    }
+  }
+
+  const isOpencode =
+    model.provider === "opencode" ||
+    model.provider === "opencode-go" ||
+    host === "opencode.ai"
+
+  if (!isOpencode) return undefined
+  return { "x-opencode-session": sessionId, "x-opencode-client": "pi" }
+}
+
 async function generateRecap(
   pi: ExtensionAPI,
   ctx: ExtensionContext,
@@ -270,21 +301,54 @@ async function generateRecap(
   if (options.manual) showLoadingWidget(ctx)
 
   const runId = state.runId
-  const modelAuth = await getRecapModelAuth(ctx, state.modelConfig)
-  if (runId !== state.runId || !state.sessionActive) return
+  let abortController: AbortController | undefined
 
-  if (modelAuth.status !== "ok") {
-    if (options.manual) clearWidget(ctx)
-    handleMissingRecapModel(ctx, modelAuth, options)
-    return
-  }
+  try {
+    const modelAuth = await getRecapModelAuth(ctx, state.modelConfig)
+    if (runId !== state.runId || !state.sessionActive) return
 
-  const abortController = new AbortController()
-  abortPendingGeneration(state)
-  state.abortController = abortController
+    if (modelAuth.status !== "ok") {
+      if (options.manual) clearWidget(ctx)
+      handleMissingRecapModel(ctx, modelAuth, options)
+      return
+    }
 
-  try {
-    const response = await ctx.modelRegistry.complete(
+    const sessionHeaders = opencodeSessionHeaders(
+      modelAuth.auth,
+      ctx.sessionManager.getSessionId(),
+    )
+
+    abortController = new AbortController()
+    abortPendingGeneration(state)
+    state.abortController = abortController
+
+    const registry = ctx.modelRegistry as unknown as {
+      complete?: (
+        model: unknown,
+        context: unknown,
+        completeOptions: unknown,
+      ) => Promise<AssistantMessage>
+    }
+    const completeFn =
+      typeof registry.complete === "function"
+        ? registry.complete.bind(ctx.modelRegistry)
+        : async (
+            model: unknown,
+            context: unknown,
+            completeOptions: unknown,
+          ) => {
+            const aiModule = "@oh-my-pi/pi-ai"
+            const { completeSimple } = (await import(aiModule)) as {
+              completeSimple: (
+                model: unknown,
+                context: unknown,
+                completeOptions: unknown,
+              ) => Promise<AssistantMessage>
+            }
+            return await completeSimple(model, context, completeOptions)
+          }
+
+    const response = await completeFn(
       modelAuth.auth,
       {
         systemPrompt: RECAP_SYSTEM_PROMPT,
@@ -296,6 +360,7 @@ async function generateRecap(
         cacheRetention: "none",
         timeoutMs: RECAP_REQUEST_TIMEOUT_MS,
         signal: abortController.signal,
+        ...(sessionHeaders ? { headers: sessionHeaders } : {}),
       },
     )
 
@@ -303,7 +368,14 @@ async function generateRecap(
     if (response.stopReason !== "stop") {
       if (options.manual) {
         clearWidget(ctx)
-        notifyUser(ctx, "Recap generation failed.", "error")
+        const detail = (response as { errorMessage?: string }).errorMessage
+        notifyUser(
+          ctx,
+          detail
+            ? `Recap generation failed: ${detail}`
+            : "Recap generation failed.",
+          "error",
+        )
       }
       return
     }
@@ -324,14 +396,26 @@ async function generateRecap(
     state.lastRecapCurrent = true
     clearNoModelWarning(ctx)
     showWidget(ctx, recap)
-  } catch {
+  } catch (error) {
+    // A superseded or aborted run must not report a failure in the new context.
+    // `runId` catches `agent_start`/`session_start`, which bump it before
+    // aborting; this run's own signal catches a second generation replacing it
+    // without either firing.
+    if (
+      runId !== state.runId ||
+      !state.sessionActive ||
+      abortController?.signal.aborted
+    ) {
+      return
+    }
     if (options.manual) {
       clearWidget(ctx)
-      notifyUser(ctx, "Recap generation failed.", "error")
+      const detail = error instanceof Error ? error.message : String(error)
+      notifyUser(ctx, `Recap generation failed: ${detail}`, "error")
     }
     // Automatic recaps are best-effort. Keep the previous recap on transient failures.
   } finally {
-    if (state.abortController === abortController) {
+    if (abortController && state.abortController === abortController) {
       state.abortController = undefined
     }
   }
@@ -378,7 +462,7 @@ function scheduleAwayRecap(
     state.awayTimer = undefined
     if (!state.sessionActive || !state.stale || !ctx.isIdle()) return
     state.stale = false
-    void generateRecap(pi, ctx, state, { manual: false })
+    void generateRecap(pi, ctx, state, { manual: false }).catch(() => {})
   }, AWAY_RECAP_DELAY_MS)
 }
 
@@ -533,7 +617,7 @@ export default function (pi: ExtensionAPI): void {
 
     if (showRestoredRecap(ctx, state)) return
 
-    void generateRecap(pi, ctx, state, { manual: false })
+    void generateRecap(pi, ctx, state, { manual: false }).catch(() => {})
   })
 
   pi.on("input", (event, ctx) => {

package/node_modules/@tifan/pi-recap/src/models.ts

@@ -113,6 +113,48 @@ export function resolveInitialModelConfig(): RecapModelConfig {
   }
 }
 
+async function hasModelApiKey(
+  ctx: ExtensionContext,
+  model: Model<Api>,
+): Promise<boolean> {
+  const registry = ctx.modelRegistry as unknown as {
+    getProviderAuth?: (
+      provider: string,
+    ) => Promise<{ auth?: { apiKey?: string } } | undefined>
+    getApiKeyForProvider?: (provider: string) => Promise<string | undefined>
+    getApiKey?: (model: Model<Api>) => Promise<string | undefined>
+  }
+
+  if (typeof registry.getProviderAuth === "function") {
+    try {
+      const auth = await registry.getProviderAuth(model.provider)
+      if (auth?.auth?.apiKey) return true
+    } catch {
+      // Fall through if getProviderAuth fails
+    }
+  }
+
+  if (typeof registry.getApiKeyForProvider === "function") {
+    try {
+      const apiKey = await registry.getApiKeyForProvider(model.provider)
+      if (apiKey) return true
+    } catch {
+      // Fall through
+    }
+  }
+
+  if (typeof registry.getApiKey === "function") {
+    try {
+      const apiKey = await registry.getApiKey(model)
+      if (apiKey) return true
+    } catch {
+      // Ignore
+    }
+  }
+
+  return false
+}
+
 async function getModelAuth(
   ctx: ExtensionContext,
   modelPreference: RecapModelPreference,
@@ -123,8 +165,8 @@ async function getModelAuth(
   )
   if (!model) return undefined
 
-  const auth = await ctx.modelRegistry.getProviderAuth(model.provider)
-  return auth?.auth.apiKey ? model : undefined
+  const hasAuth = await hasModelApiKey(ctx, model)
+  return hasAuth ? model : undefined
 }
 
 export async function getRecapModelAuth(
@@ -164,8 +206,8 @@ export async function getAuthenticatedTextModelPreferences(
     .filter((model) => model.input.includes("text"))
   const authenticatedModels = await Promise.all(
     models.map(async (model) => {
-      const auth = await ctx.modelRegistry.getProviderAuth(model.provider)
-      return auth?.auth.apiKey ? toModelPreference(model) : undefined
+      const hasAuth = await hasModelApiKey(ctx, model)
+      return hasAuth ? toModelPreference(model) : undefined
     }),
   )
 

package/node_modules/pi-antigravity/README.md

@@ -80,6 +80,7 @@ The provider uses the OAuth 2.0 Authorization Code flow with PKCE, so credential
 2. After you approve access, Pi exchanges the callback code for tokens and stores the provider credentials in Pi's auth store (normally `~/.pi/agent/auth.json`).
 3. Pi refreshes access tokens automatically when they expire — you shouldn't need to sign in again unless a token is revoked.
 4. Successful logins and token rotations are also kept in `~/.pi/agent/antigravity-accounts.json` with owner-only permissions so linked accounts can be switched without re-authenticating.
+5. Access is quota-backed by the signed-in Google account rather than billed per token, so Pi marks Antigravity models as subscription-backed (`(sub)` in the footer); any cost Pi shows for them is a catalog estimate.
 
 The callback listener binds only to a loopback host, so it isn't reachable from outside your machine. The auth and account files it writes to contain sensitive access and refresh tokens: **do not commit them, paste them into issues, or share their contents.**
 
@@ -114,9 +115,24 @@ Review these permissions before approving access. If your credentials expire or
 
 Model availability, entitlement, quota groups, and resets are returned by the service and can differ by account. The quota percentage shown for a model can represent a shared pool, not a private per-model allowance.
 
-The extension also registers a `generate_image` tool the model can call. Images are written inside the project directory (default `.pi/generated-images/`). Image models such as `gemini-3-pro-image` are account-dependent; `/antigravity.image` falls back to other advertised Gemini image IDs on 404.
+The extension also registers a `generate_image` tool the model can call. Images are written inside the project directory (default `.pi/generated-images/`). Image generation defaults to `gemini-3.1-flash-image`; model availability is account-dependent. Requests use the direct image endpoint, with the legacy streaming endpoint tried on HTTP 404. Existing model and endpoint fallbacks remain available.
 
-It also registers a `google_search` tool allowing models to perform real-time web search and URL analysis using Google Search Grounding over Cloud Code Assist (powered by `gemini-3-flash` with dynamic fallback). It supports optional lead agent directives (`instruction`), specific target URLs (`urls`), and deep reasoning (`thinking: true`).
+It also registers a `google_search` tool allowing models to perform real-time web search and URL analysis using Google Search Grounding over Cloud Code Assist. The default model is `gemini-3.5-flash-lite` (fallbacks: `gemini-3.1-flash-lite`, `gemini-3-flash`) and the default reply is a short evidence brief. It supports optional lead agent directives (`instruction`), specific target URLs (`urls`), and deep reasoning (`thinking: true` or `/antigravity.search --thinking`).
+
+### Native image API
+
+On Pi versions that support mixed-operation provider registration (`type: "image"` and `images` handlers), Antigravity exposes `gemini-3.1-flash-image` to codemode and `ctx.modelRegistry.generateImages()`. Older Pi versions can continue using the existing image tool and command; the native API is not available there.
+
+```js
+const model = await models.getModelOfType("image", "antigravity", "gemini-3.1-flash-image");
+const result = await models.generateImages(model, {
+  input: [{ type: "text", text: "A red square on white" }],
+});
+if (result.stopReason !== "stop") return result.errorMessage;
+for (const block of result.output) if (block.type === "image") image(block);
+```
+
+The native API returns in-memory image/text blocks and does not save files. Input image blocks are accepted without local path loading. Extensions can pass `metadata: { aspectRatio: "16:9" }` through image options. Credentials are resolved by Pi. Backend usage is not currently reported by this adapter.
 
 ## Models and routing
 
@@ -178,6 +194,10 @@ All primary environment variables start with `ANTIGRAVITY_`. The legacy `NOAGY_`
 | `ANTIGRAVITY_NO_SEARCH_TOOL` | Set to `1` to skip only the `google_search` tool, e.g. when another extension provides web search. |
 | `ANTIGRAVITY_NO_IMAGE_TOOL` | Set to `1` to skip only the `generate_image` tool. |
 
+`pi config` can disable each model-facing tool without disabling the provider. The package loads three extension resources: `src/index.ts` (provider, OAuth, and slash commands), `src/features/google-search.ts` (`google_search`), and `src/features/generate-image.ts` (`generate_image`). Turn off a feature resource there to stop registering that tool. `/antigravity.search` and `/antigravity.image` stay available from the provider extension.
+
+Environment variables still force a loaded tool off, including in scripts and headless runs. They cannot turn a resource back on after `pi config` disables it, because that file is not loaded. Either control is enough to hide the tool from the model. Run `/reload` after changing `pi config` or the environment in an active session; a new Pi process also picks the change up. A restart is not required when `/reload` succeeds.
+
 By default, the provider tries `https://daily-cloudcode-pa.googleapis.com`, then the sandbox host, then `https://cloudcode-pa.googleapis.com`. Prefer the built-in OAuth client unless you have a reason to use your own credentials.
 
 ### Latency
@@ -187,6 +207,7 @@ Provider requests reuse a keep-alive connection pool when the runtime supports i
 ## Troubleshooting
 
 - **No credentials / 401 / 403:** Run `/login antigravity` again, then check `/antigravity.doctor`.
+- **403 `VALIDATION_REQUIRED` / "Verify your account":** Open the `accounts.google.com` link in the error, in a browser signed in to the same Google account, and finish verification. Re-login alone does not clear it. `/antigravity.doctor` omits that link because it carries session parameters.
 - **Remote/headless machine — browser can't reach `localhost:51121`:** The callback binds to loopback only, so a browser on another machine can't hit it. You have two options:
   - **Paste (no extra setup):** Run `/login antigravity`, open the shown URL and complete Google sign-in in _any_ browser. When it redirects to `http://localhost:51121/oauth-callback?…` and fails to load, copy that full URL from the address bar and paste it into the prompt Pi shows. The code is single-use and expires quickly, so paste promptly.
   - **SSH tunnel (reusable):** From the machine with the browser, run `ssh -N -L 51121:127.0.0.1:51121 <user>@<server>` and keep it open, then run `/login antigravity` on the server. The redirect to `localhost:51121` tunnels through to the local callback automatically.

package/node_modules/pi-antigravity/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-antigravity",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Personal Antigravity / Cloud Code Assist provider for Pi Coding Agent",
   "author": "Rahul Arya",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "security-check": "node scripts/run-ts.mjs scripts/security-check.ts",
-    "test": "node scripts/run-ts.mjs scripts/test-sanitize-text.ts && node scripts/run-ts.mjs scripts/test-model-routing.ts && node scripts/run-ts.mjs scripts/test-model-discovery.ts && node scripts/run-ts.mjs scripts/test-usage-formatter.ts && node scripts/run-ts.mjs scripts/test-stream-sse.ts && node scripts/run-ts.mjs scripts/test-stream-header-deadline.ts && node scripts/run-ts.mjs scripts/test-http-proxy.ts && node scripts/run-ts.mjs scripts/test-oauth-fetch.ts && node scripts/run-ts.mjs scripts/test-image-gen.ts && node scripts/run-ts.mjs scripts/test-transcript-context.ts && node scripts/run-ts.mjs scripts/test-accounts.ts && node scripts/run-ts.mjs scripts/test-search.ts && node scripts/run-ts.mjs scripts/test-extra-tools-toggle.ts",
+    "test": "node scripts/run-ts.mjs scripts/test-sanitize-text.ts && node scripts/run-ts.mjs scripts/test-model-routing.ts && node scripts/run-ts.mjs scripts/test-model-discovery.ts && node scripts/run-ts.mjs scripts/test-usage-formatter.ts && node scripts/run-ts.mjs scripts/test-stream-sse.ts && node scripts/run-ts.mjs scripts/test-stream-header-deadline.ts && node scripts/run-ts.mjs scripts/test-http-proxy.ts && node scripts/run-ts.mjs scripts/test-oauth-fetch.ts && node scripts/run-ts.mjs scripts/test-image-gen.ts && node scripts/run-ts.mjs scripts/test-native-images.ts && node scripts/run-ts.mjs scripts/test-transcript-context.ts && node scripts/run-ts.mjs scripts/test-accounts.ts && node scripts/run-ts.mjs scripts/test-search.ts && node scripts/run-ts.mjs scripts/test-extra-tools-toggle.ts && node scripts/run-ts.mjs scripts/test-provider-registration.ts",
     "smoke:tools": "node scripts/run-ts.mjs scripts/smoke-tool-schema.ts",
     "smoke:models": "node scripts/run-ts.mjs scripts/smoke-all-models.mjs",
     "audit": "yarn npm audit --environment production --recursive && yarn npm audit --severity high --all --recursive",
@@ -47,7 +47,9 @@
   },
   "pi": {
     "extensions": [
-      "./src/index.ts"
+      "./src/index.ts",
+      "./src/features/google-search.ts",
+      "./src/features/generate-image.ts"
     ]
   },
   "peerDependencies": {

package/node_modules/pi-antigravity/src/diagnostics/diagnostics.ts

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { redactSecrets } from "../utils/security.js";
+import { redactSecrets, stripValidationUrls } from "../utils/security.js";
 
 export type DiagnosticsSnapshot = {
   status?: number;
@@ -60,7 +60,8 @@ export function setLastEndpoint(endpoint: string | undefined): void {
   currentBag().endpoint = endpoint;
 }
 export function setLastError(error: string | undefined): void {
-  currentBag().error = error === undefined ? undefined : redactSecrets(error).slice(0, 800);
+  currentBag().error =
+    error === undefined ? undefined : stripValidationUrls(redactSecrets(error)).slice(0, 800);
 }
 export function setLastProjectId(projectId: string | undefined): void {
   currentBag().projectId = projectId;

package/node_modules/pi-antigravity/src/features/generate-image.ts

@@ -0,0 +1,72 @@
+/**
+ * Optional model-facing image tool.
+ * Disable this extension resource in `pi config` to keep the Antigravity provider
+ * and `/antigravity.image` without registering `generate_image`.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { StringEnum, Type } from "@earendil-works/pi-ai";
+import {
+  DEFAULT_IMAGE_MODEL,
+  generateAntigravityImage,
+  IMAGE_ASPECT_RATIOS,
+} from "../image/index.js";
+import { isExtraToolEnabled } from "../utils/index.js";
+
+export default function (pi: ExtensionAPI): void {
+  if (!isExtraToolEnabled("IMAGE")) return;
+  pi.registerTool({
+    name: "generate_image",
+    label: "Generate image",
+    description:
+      "Generate an image via Antigravity using the signed-in Google account. Saves under .pi/generated-images/ unless path is set.",
+    promptSnippet: "Generate images via Antigravity OAuth (Gemini image models)",
+    promptGuidelines: [
+      "Use generate_image when the user asks to create, draw, or generate an image.",
+    ],
+    parameters: Type.Object({
+      prompt: Type.String({ description: "Image description." }),
+      aspectRatio: Type.Optional(StringEnum(IMAGE_ASPECT_RATIOS)),
+      model: Type.Optional(
+        Type.String({
+          description: `Image model id. Default: ${DEFAULT_IMAGE_MODEL}.`,
+        }),
+      ),
+      path: Type.Optional(
+        Type.String({
+          description: "Project-relative file or directory to save the image.",
+        }),
+      ),
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const apiKey = await ctx.modelRegistry.getApiKeyForProvider("antigravity");
+      if (!apiKey) {
+        throw new Error("No Antigravity credentials. Run /login antigravity first.");
+      }
+      onUpdate?.({ content: [{ type: "text", text: "Generating image…" }], details: {} });
+      const result = await generateAntigravityImage({
+        apiKey,
+        cwd: ctx.cwd,
+        prompt: params.prompt,
+        aspectRatio: params.aspectRatio,
+        model: params.model,
+        path: params.path,
+        signal,
+      });
+      const notes = result.text.join(" ").trim();
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Saved image to ${result.savedPaths.join(", ")}${notes ? `. ${notes}` : ""}`,
+          },
+          ...result.images.map((image) => ({
+            type: "image" as const,
+            data: image.data,
+            mimeType: image.mimeType,
+          })),
+        ],
+        details: { model: result.model, savedPaths: result.savedPaths },
+      };
+    },
+  });
+}

package/node_modules/pi-antigravity/src/features/google-search.ts

@@ -0,0 +1,71 @@
+/**
+ * Optional model-facing search tool.
+ * Disable this extension resource in `pi config` to keep the Antigravity provider
+ * and `/antigravity.search` without registering `google_search`.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "@earendil-works/pi-ai";
+import { executeAntigravitySearch } from "../search/index.js";
+import { isExtraToolEnabled, redactSecrets } from "../utils/index.js";
+
+export default function (pi: ExtensionAPI): void {
+  if (!isExtraToolEnabled("SEARCH")) return;
+  pi.registerTool({
+    name: "google_search",
+    label: "Google Search",
+    description:
+      "Search the web using Google Search via Antigravity Grounding. Returns a compact evidence brief with source citations. Use this whenever current, real-time information or web research is needed.",
+    promptSnippet: "Real-time Google Search grounding via Antigravity",
+    promptGuidelines: [
+      "Use google_search when you need real-time, up-to-date web information, latest news, documentation, or fact checking.",
+      "Pass specific URLs into the urls array if you want the search engine to fetch and analyze specific pages.",
+      "Set instruction to provide special research directives from the lead agent (e.g. focus on issues, compare benchmarks, restrict time range).",
+    ],
+    parameters: Type.Object({
+      query: Type.String({ description: "Search query or question." }),
+      instruction: Type.Optional(
+        Type.String({
+          description:
+            "Specific directive or focus from the lead agent (e.g., '重点关注英文社区近七天的讨论', 'focus on GitHub issues and benchmarks', 'ignore marketing announcements').",
+        }),
+      ),
+      urls: Type.Optional(
+        Type.Array(Type.String(), {
+          description: "Optional specific URLs to fetch and analyze alongside the search.",
+        }),
+      ),
+      thinking: Type.Optional(
+        Type.Boolean({
+          description: "Enable deeper thinking for complex analysis (default: false).",
+        }),
+      ),
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const apiKey = await ctx.modelRegistry.getApiKeyForProvider("antigravity");
+      if (!apiKey) {
+        throw new Error("No Antigravity credentials. Run /login antigravity first.");
+      }
+      onUpdate?.({
+        content: [{ type: "text", text: `Searching Google for: "${params.query}"…` }],
+        details: {},
+      });
+      try {
+        const result = await executeAntigravitySearch({
+          apiKey,
+          query: params.query,
+          instruction: params.instruction,
+          urls: params.urls,
+          thinking: params.thinking,
+          signal,
+        });
+        return {
+          content: [{ type: "text", text: result }],
+          details: {},
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        throw new Error(redactSecrets(msg), { cause: error });
+      }
+    },
+  });
+}