@tt-a1i/openpi 0.4.0 → 0.6.0

package/bin/openpi.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+import { resolve } from "node:path";
+import { createJiti } from "jiti";
+
+function printHelp() {
+  console.log(`OpenPI Web Workbench
+
+Usage:
+  openpi web [workspace]
+  openpi [workspace]          Alias for openpi web [workspace]
+
+Options:
+  --port <number>              Bind a specific loopback port (development)
+  --no-open                    Do not open a browser (development)
+
+Starts an isolated local Web runtime. Browser conversations and session changes
+never enter an interactive terminal Pi session.`);
+}
+
+const args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+  printHelp();
+  process.exit(0);
+}
+const command = args[0] === "web" ? args.slice(1) : args;
+const noOpen = command.includes("--no-open");
+const noWorkspace = command.includes("--no-workspace");
+const portIndex = command.indexOf("--port");
+const portText = portIndex >= 0 ? command[portIndex + 1] : undefined;
+const workspaceArgs = [];
+for (let index = 0; index < command.length; index++) {
+  const value = command[index];
+  if (value === "--no-open") continue;
+  if (value === "--no-workspace") continue;
+  if (value === "--port") {
+    index++;
+    continue;
+  }
+  workspaceArgs.push(value);
+}
+const configuredPort = portText ?? process.env.OPENPI_WEB_PORT;
+const port = configuredPort === undefined ? undefined : Number(configuredPort);
+if (portIndex >= 0 && (!portText || portText.startsWith("--"))) {
+  console.error("--port requires a value");
+  process.exit(1);
+}
+if (port !== undefined && (!Number.isInteger(port) || port < 0 || port > 65535)) {
+  console.error("--port must be an integer between 0 and 65535");
+  process.exit(1);
+}
+if (workspaceArgs.length > 1) {
+  console.error("Usage: openpi web [workspace]");
+  process.exit(1);
+}
+if (noWorkspace && workspaceArgs.length > 0) {
+  console.error("--no-workspace cannot be combined with a workspace");
+  process.exit(1);
+}
+
+let host;
+let runtime;
+let stopping;
+const stop = () => {
+  stopping ??= host?.stop() ?? runtime?.dispose() ?? Promise.resolve();
+  return stopping;
+};
+
+try {
+  const bootstrap = createJiti(import.meta.url);
+  const { missingPiCodingAgentDiagnostic, resolveStandaloneJitiAliases } =
+    await bootstrap.import("../web/host/pi-coding-agent-entry.ts");
+  const aliases = resolveStandaloneJitiAliases({
+    fromUrl: import.meta.url,
+  });
+  if (!aliases["@earendil-works/pi-coding-agent"]) {
+    console.error(missingPiCodingAgentDiagnostic());
+    process.exit(1);
+  }
+  const jiti = createJiti(import.meta.url, { alias: aliases });
+  const [browserModule, hostModule, runtimeModule, statusModule, traceModule] =
+    await Promise.all([
+      jiti.import("../web/host/browser-launcher.ts"),
+      jiti.import("../web/host/web-host.ts"),
+      jiti.import("../web/runtime/pi-runtime.ts"),
+      jiti.import("../web/host/terminal-status.ts"),
+      jiti.import("../web/trace.ts"),
+    ]);
+  const { openBrowser } = browserModule;
+  const { WebHost } = hostModule;
+  const { PiWebRuntime } = runtimeModule;
+  const { formatWebReadyScreen } = statusModule;
+  const { traceWeb } = traceModule;
+  runtime = noWorkspace
+    ? await PiWebRuntime.createWithoutWorkspace()
+    : await PiWebRuntime.create(resolve(workspaceArgs[0] ?? process.cwd()));
+  host = new WebHost({
+    runtime,
+    ...(port === undefined ? {} : { port }),
+    ...(process.env.OPENPI_WEB_TOKEN
+      ? { token: process.env.OPENPI_WEB_TOKEN }
+      : {}),
+    ...(process.env.OPENPI_WEB_ALLOWED_ORIGIN
+      ? { allowedOrigins: [process.env.OPENPI_WEB_ALLOWED_ORIGIN] }
+      : {}),
+  });
+  await host.start();
+  const onStopSignal = () => {
+    void stop().then(
+      () => process.exit(0),
+      (error) => {
+        console.error(
+          `Failed to stop OpenPI Web Workbench: ${error instanceof Error ? error.message : String(error)}`,
+        );
+        process.exit(1);
+      },
+    );
+  };
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.once(signal, onStopSignal);
+  }
+  traceWeb("web_started", {
+    ...(runtime.workspaceSelected === true ? { cwd: runtime.cwd } : {}),
+    origin: host.origin,
+  });
+  const opened = noOpen ? false : await openBrowser(host.url);
+  if (noWorkspace) {
+    console.log(
+      formatWebReadyScreen({
+        origin: host.origin,
+        url: host.url,
+        opened,
+      }),
+    );
+  } else {
+    console.log(`OpenPI Web Workbench is running at ${host.origin}`);
+    if (!opened) console.log(`Open this URL in a browser: ${host.url}`);
+  }
+} catch (error) {
+  let cleanupError;
+  try {
+    await stop();
+  } catch (caught) {
+    cleanupError = caught;
+  }
+  console.error(
+    `Failed to start OpenPI Web Workbench: ${error instanceof Error ? error.message : String(error)}`,
+  );
+  if (cleanupError) {
+    console.error(
+      `Failed to clean up OpenPI Web Workbench: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`,
+    );
+  }
+  process.exit(1);
+}

package/extensions/ai-providers/LICENSE.upstream

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+Copyright (c) 2025-2026 Can Bölük
+Copyright (c) 2026 Stencil Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/extensions/ai-providers/README.md

@@ -0,0 +1,59 @@
+# OAuth model providers
+
+This extension registers two opt-in model providers backed by account OAuth:
+
+- `google-antigravity` uses Google Cloud Code Assist and supports ordinary Pi
+  tool calls.
+- `cursor` uses Cursor AgentService and is experimental, chat-only support.
+  It does not advertise or execute Cursor-native coding tools. If the server
+  requests one, the request fails explicitly instead of bypassing Pi's tool and
+  permission lifecycle.
+
+After installing OpenPI, restart Pi or run `/reload`, then authenticate and
+select a model:
+
+```text
+/login google-antigravity
+/login cursor
+/model
+```
+
+For source-checkout testing, follow the repository's
+[development runtime provenance procedure](../../README.md#开发运行时区分-npm-与当前源码).
+Remove any previously installed OpenPI source, install the checkout, and verify
+that `pi list` reports this checkout as the only OpenPI source before reloading
+Pi. Do not mix an installed OpenPI package with an explicitly loaded checkout
+extension, because that does not prove which source owns the runtime behavior.
+
+```sh
+pi list
+OLD_OPENPI_SOURCE=/absolute/path/to/old/openpi
+pi remove "$OLD_OPENPI_SOURCE"
+pi install "$PWD"
+pi list
+```
+
+The model catalog is refreshed from the authenticated account and persisted by
+Pi. A failed refresh retains the last successful account catalog; Antigravity
+also has a validated static baseline, while Cursor keeps the server-side `Auto`
+route as its baseline. No provider is contacted until it is selected.
+
+Pi's interactive clipboard flow inserts an image's local path into the editor.
+When Cursor is selected, a supported PNG/JPEG/GIF/WebP path at the start of an
+interactive prompt is converted into an actual image attachment (up to 10 MiB)
+before the request is sent. The absolute path is not exposed to the model.
+
+The provider also adds an explicit chat-only rule so the normal Pi coding
+system prompt cannot cause Cursor to attempt unavailable read or shell tools.
+
+Cursor's token delta describes generated output only, so the provider does not
+publish it as complete context usage. Pi 0.84.3+ can estimate an all-Cursor
+history and trigger threshold compaction without provider usage. Older Pi hosts
+retain the correct unknown-usage state but cannot automatically threshold-
+compact a session with no usage-backed response. Project-wide Pi baseline
+tracking is kept in [#328](https://github.com/openpi-dev/openpi/issues/328).
+
+Cursor model discovery and chat use HTTP/2. They honor `PI_PROXY_CURSOR`, then
+`PI_PROXY`, the standard `HTTPS_PROXY`/`HTTP_PROXY` variables, and `ALL_PROXY`;
+`NO_PROXY` bypass rules apply. The proxy must support HTTP CONNECT and preserve
+HTTP/2 ALPN negotiation to Cursor.

package/extensions/ai-providers/antigravity/credentials.ts

@@ -0,0 +1,52 @@
+/**
+ * Credential codec for the Antigravity provider.
+ *
+ * pi persists whatever object `login` returns into auth.json and hands it back
+ * to `refreshToken`/`getApiKey` verbatim, so the Antigravity-specific extras
+ * (projectId, email) ride along as additional fields. `getApiKey` then packs
+ * everything the stream needs into the single `apiKey` string pi threads into
+ * `SimpleStreamOptions.apiKey`.
+ */
+
+import type { OAuthCredentials } from "@earendil-works/pi-ai/compat";
+
+/** Stored credential shape: pi's OAuth fields plus Antigravity extras. */
+export interface AntigravityCredentials extends OAuthCredentials {
+  /** Cloud Code Assist project resolved during login provisioning. */
+  projectId?: string;
+  /** Google account email, best-effort display metadata. */
+  email?: string;
+}
+
+/** What the stream function needs, packed into the apiKey string. */
+export interface AntigravityApiKeyPayload {
+  token: string;
+  projectId?: string;
+}
+
+export function encodeApiKey(credentials: AntigravityCredentials): string {
+  const payload: AntigravityApiKeyPayload = {
+    token: credentials.access,
+    projectId: credentials.projectId,
+  };
+  return JSON.stringify(payload);
+}
+
+export function decodeApiKey(raw: string): AntigravityApiKeyPayload {
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object" && "token" in parsed) {
+      const token = parsed.token;
+      if (typeof token === "string") {
+        const projectId =
+          "projectId" in parsed && typeof parsed.projectId === "string"
+            ? parsed.projectId
+            : undefined;
+        return { token, projectId };
+      }
+    }
+  } catch {
+    // Not JSON: tolerate a bare access token (e.g. hand-written auth.json).
+  }
+  return { token: raw };
+}

package/extensions/ai-providers/antigravity/discovery.ts

@@ -0,0 +1,130 @@
+/**
+ * Antigravity model discovery.
+ *
+ * `POST /v1internal:fetchAvailableModels` returns a map of wire model id to
+ * metadata (reference: omp packages/catalog/src/discovery/antigravity.ts).
+ * Static models are the provider baseline. Network/protocol failures throw so
+ * createProvider can retain the last successfully persisted dynamic catalog.
+ */
+
+import type { RefreshModelsContext } from "@earendil-works/pi-ai";
+import { Type, type Static } from "typebox";
+import { Value } from "typebox/value";
+import { ensureAntigravityVersion, getAntigravityUserAgent } from "./oauth.ts";
+import {
+  ANTIGRAVITY_API_URL,
+  type AntigravityProviderModel,
+} from "./models.ts";
+import {
+  collapseAntigravityModels,
+  type AntigravityModelDefinition,
+} from "./routing.ts";
+
+const DISCOVERY_ENDPOINTS = [
+  "https://daily-cloudcode-pa.googleapis.com",
+  "https://daily-cloudcode-pa.sandbox.googleapis.com",
+] as const;
+const FETCH_AVAILABLE_MODELS_PATH = "/v1internal:fetchAvailableModels";
+
+// Reference: omp ANTIGRAVITY_DISCOVERY_DENYLIST.
+const DISCOVERY_DENYLIST: Record<string, true> = {
+  chat_20706: true,
+  chat_23310: true,
+  "gemini-2.5-pro": true,
+};
+
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+const DEFAULT_MAX_TOKENS = 64_000;
+
+const DiscoveryModelSchema = Type.Object({
+  displayName: Type.Optional(Type.String()),
+  supportsImages: Type.Optional(Type.Boolean()),
+  supportsThinking: Type.Optional(Type.Boolean()),
+  maxTokens: Type.Optional(Type.Number()),
+  maxOutputTokens: Type.Optional(Type.Number()),
+  isInternal: Type.Optional(Type.Boolean()),
+});
+
+const DiscoveryResponseSchema = Type.Object({
+  models: Type.Optional(Type.Record(Type.String(), DiscoveryModelSchema)),
+});
+
+type DiscoveryResponse = Static<typeof DiscoveryResponseSchema>;
+
+type DiscoveredModel = AntigravityProviderModel & AntigravityModelDefinition;
+
+function positiveNumber(value: number | undefined, fallback: number): number {
+  return value !== undefined && Number.isFinite(value) && value > 0
+    ? value
+    : fallback;
+}
+
+function toModelDefinition(
+  id: string,
+  meta: Static<typeof DiscoveryModelSchema>,
+): DiscoveredModel {
+  const advertisedMaxTokens = positiveNumber(
+    meta.maxOutputTokens,
+    DEFAULT_MAX_TOKENS,
+  );
+  return {
+    id,
+    name: meta.displayName ?? id,
+    api: "antigravity-cloudcode",
+    provider: "google-antigravity",
+    baseUrl: ANTIGRAVITY_API_URL,
+    reasoning: meta.supportsThinking === true,
+    input: meta.supportsImages === true ? ["text", "image"] : ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: positiveNumber(meta.maxTokens, DEFAULT_CONTEXT_WINDOW),
+    maxTokens: id.toLowerCase().includes("claude")
+      ? Math.min(advertisedMaxTokens, DEFAULT_MAX_TOKENS)
+      : advertisedMaxTokens,
+  };
+}
+
+export async function fetchAntigravityModels(
+  context: RefreshModelsContext,
+): Promise<DiscoveredModel[]> {
+  if (!context.allowNetwork) return [];
+  context.signal.throwIfAborted();
+  const credential = context.credential;
+  if (!credential || credential.type !== "oauth") return [];
+  await ensureAntigravityVersion(context.signal);
+
+  for (const endpoint of DISCOVERY_ENDPOINTS) {
+    if (context.signal.aborted) break;
+    try {
+      const response = await fetch(
+        `${endpoint}${FETCH_AVAILABLE_MODELS_PATH}`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${credential.access}`,
+            "Content-Type": "application/json",
+            "User-Agent": getAntigravityUserAgent(),
+          },
+          body: "{}",
+          signal: context.signal,
+        },
+      );
+      if (!response.ok) continue;
+      const parsed = Value.Parse(
+        DiscoveryResponseSchema,
+        await response.json(),
+      ) as DiscoveryResponse;
+      if (!parsed.models) continue;
+      const discovered = Object.entries(parsed.models)
+        .filter(
+          ([id, meta]) =>
+            !Object.hasOwn(DISCOVERY_DENYLIST, id) && meta.isInternal !== true,
+        )
+        .map(([id, meta]) => toModelDefinition(id, meta));
+      return collapseAntigravityModels(discovered);
+    } catch {
+      // Try the next endpoint; total failure must preserve the stored catalog.
+    }
+  }
+  context.signal.throwIfAborted();
+  throw new Error("Antigravity model discovery failed on all endpoints");
+}