gloomberb 0.9.9 → 0.10.0

package/src/plugins/builtin/ai/pi/models-store.ts

@@ -0,0 +1,141 @@
+import type { Api, Model, ModelsStore, ModelsStoreEntry } from "@earendil-works/pi-ai";
+import { join } from "node:path";
+import { LockedJsonFile } from "./file-store";
+
+const MODELS_FILE_VERSION = 1;
+const PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
+
+interface ModelsFile {
+  version: typeof MODELS_FILE_VERSION;
+  providers: Record<string, ModelsStoreEntry>;
+}
+
+function assertProviderId(providerId: string): void {
+  if (!PROVIDER_ID_PATTERN.test(providerId)) throw new Error(`Invalid AI provider id: ${providerId}`);
+}
+
+function isFiniteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+  return !!value
+    && typeof value === "object"
+    && !Array.isArray(value)
+    && Object.values(value).every((entry) => typeof entry === "string");
+}
+
+function isCost(value: unknown): boolean {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value as Record<string, unknown>;
+  if (!["input", "output", "cacheRead", "cacheWrite"].every((key) => isFiniteNumber(candidate[key]))) return false;
+  return candidate.tiers === undefined
+    || (Array.isArray(candidate.tiers) && candidate.tiers.every((tier) => {
+      if (!tier || typeof tier !== "object" || Array.isArray(tier)) return false;
+      const record = tier as Record<string, unknown>;
+      return ["input", "output", "cacheRead", "cacheWrite", "inputTokensAbove"]
+        .every((key) => isFiniteNumber(record[key]));
+    }));
+}
+
+function isModel(value: unknown): value is Model<Api> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const model = value as Record<string, unknown>;
+  return typeof model.id === "string"
+    && typeof model.name === "string"
+    && typeof model.api === "string"
+    && typeof model.provider === "string"
+    && typeof model.baseUrl === "string"
+    && typeof model.reasoning === "boolean"
+    && Array.isArray(model.input)
+    && model.input.every((input) => input === "text" || input === "image")
+    && isCost(model.cost)
+    && isFiniteNumber(model.contextWindow)
+    && isFiniteNumber(model.maxTokens)
+    && (model.headers === undefined || isStringRecord(model.headers));
+}
+
+function validateEntry(value: unknown, providerId?: string): ModelsStoreEntry {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("The cached AI model entry is invalid.");
+  }
+  const candidate = value as { models?: unknown; lastModified?: unknown; checkedAt?: unknown };
+  if (!Array.isArray(candidate.models) || !candidate.models.every(isModel)) {
+    throw new Error("The cached AI model entry contains invalid models.");
+  }
+  if (providerId && candidate.models.some((model) => model.provider !== providerId)) {
+    throw new Error(`The cached model provider does not match ${providerId}.`);
+  }
+  if (candidate.lastModified !== undefined && !isFiniteNumber(candidate.lastModified)) {
+    throw new Error("The cached AI model last-modified timestamp is invalid.");
+  }
+  if (candidate.checkedAt !== undefined && !isFiniteNumber(candidate.checkedAt)) {
+    throw new Error("The cached AI model check timestamp is invalid.");
+  }
+  return structuredClone(candidate) as ModelsStoreEntry;
+}
+
+function validateModelsFile(value: unknown): ModelsFile {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("The AI model cache is not an object.");
+  }
+  const candidate = value as { version?: unknown; providers?: unknown };
+  if (candidate.version !== MODELS_FILE_VERSION) {
+    throw new Error(`Unsupported AI model cache version: ${String(candidate.version)}`);
+  }
+  if (!candidate.providers || typeof candidate.providers !== "object" || Array.isArray(candidate.providers)) {
+    throw new Error("The AI model cache does not contain a providers object.");
+  }
+
+  const providers: Record<string, ModelsStoreEntry> = Object.create(null) as Record<string, ModelsStoreEntry>;
+  for (const [providerId, entry] of Object.entries(candidate.providers)) {
+    assertProviderId(providerId);
+    providers[providerId] = validateEntry(entry, providerId);
+  }
+  return { version: MODELS_FILE_VERSION, providers };
+}
+
+function createModelsFile(): ModelsFile {
+  return {
+    version: MODELS_FILE_VERSION,
+    providers: Object.create(null) as Record<string, ModelsStoreEntry>,
+  };
+}
+
+export function resolvePiModelsPath(dataDir: string): string {
+  return join(dataDir, "ai", "models.json");
+}
+
+export class PiFileModelsStore implements ModelsStore {
+  readonly path: string;
+  private readonly file: LockedJsonFile<ModelsFile>;
+
+  constructor(dataDir: string) {
+    this.path = resolvePiModelsPath(dataDir);
+    this.file = new LockedJsonFile(this.path, {
+      create: createModelsFile,
+      validate: validateModelsFile,
+    });
+  }
+
+  async read(providerId: string): Promise<ModelsStoreEntry | undefined> {
+    assertProviderId(providerId);
+    const entry = (await this.file.read()).providers[providerId];
+    return entry ? structuredClone(entry) : undefined;
+  }
+
+  async write(providerId: string, entry: ModelsStoreEntry): Promise<void> {
+    assertProviderId(providerId);
+    const validated = validateEntry(entry, providerId);
+    await this.file.update((file) => {
+      file.providers[providerId] = structuredClone(validated);
+    });
+  }
+
+  async delete(providerId: string): Promise<void> {
+    assertProviderId(providerId);
+    await this.file.update((file) => {
+      delete file.providers[providerId];
+    });
+  }
+}

package/src/plugins/builtin/ai/pi/providers.ts

@@ -0,0 +1,68 @@
+import {
+  createModels,
+  type AuthContext,
+  type CredentialStore,
+  type ModelsStore,
+  type MutableModels,
+  type Provider,
+} from "@earendil-works/pi-ai";
+import { registerBunOAuthFlows } from "@earendil-works/pi-ai/bun-oauth";
+import { anthropicProvider } from "@earendil-works/pi-ai/providers/anthropic";
+import { githubCopilotProvider } from "@earendil-works/pi-ai/providers/github-copilot";
+import { googleProvider } from "@earendil-works/pi-ai/providers/google";
+import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
+import { openaiProvider } from "@earendil-works/pi-ai/providers/openai";
+import { openrouterProvider } from "@earendil-works/pi-ai/providers/openrouter";
+import { xaiProvider } from "@earendil-works/pi-ai/providers/xai";
+import { AI_PROVIDER_IDS, type AiProviderId } from "../providers";
+
+export type PiProviderFactory = () => Provider;
+
+/**
+ * Provider-specific imports keep Pi's other catalogs out of Gloomberb builds.
+ * This is the complete application AI provider catalog.
+ */
+const FACTORIES_BY_PROVIDER_ID = {
+  anthropic: anthropicProvider,
+  "openai-codex": openaiCodexProvider,
+  openai: openaiProvider,
+  google: googleProvider,
+  "github-copilot": githubCopilotProvider,
+  xai: xaiProvider,
+  openrouter: openrouterProvider,
+} as const satisfies Readonly<Record<AiProviderId, PiProviderFactory>>;
+
+export const GLOOMBERB_PI_PROVIDER_IDS: readonly AiProviderId[] = AI_PROVIDER_IDS;
+
+export const GLOOMBERB_PI_PROVIDER_FACTORIES: readonly PiProviderFactory[] =
+  GLOOMBERB_PI_PROVIDER_IDS.map((providerId) => FACTORIES_BY_PROVIDER_ID[providerId]);
+
+let oauthFlowsRegistered = false;
+
+export function registerPiOAuthFlows(): void {
+  if (oauthFlowsRegistered) return;
+  // Static registration is required by `bun build --compile`; Pi's default
+  // variable dynamic imports cannot be discovered by the standalone bundler.
+  registerBunOAuthFlows();
+  oauthFlowsRegistered = true;
+}
+
+export interface CreateGloomberbPiModelsOptions {
+  credentials: CredentialStore;
+  modelsStore?: ModelsStore;
+  authContext?: AuthContext;
+  providerFactories?: readonly PiProviderFactory[];
+}
+
+export function createGloomberbPiModels(options: CreateGloomberbPiModelsOptions): MutableModels {
+  registerPiOAuthFlows();
+  const models = createModels({
+    credentials: options.credentials,
+    modelsStore: options.modelsStore,
+    authContext: options.authContext,
+  });
+  for (const createProvider of options.providerFactories ?? GLOOMBERB_PI_PROVIDER_FACTORIES) {
+    models.setProvider(createProvider());
+  }
+  return models;
+}

package/src/plugins/builtin/ai/pi/runtime.test.ts

@@ -0,0 +1,240 @@
+import { describe, expect, test } from "bun:test";
+import {
+  InMemoryCredentialStore,
+  Type,
+  createModels,
+  createProvider,
+  fauxAssistantMessage,
+  fauxProvider,
+  fauxToolCall,
+} from "@earendil-works/pi-ai";
+import {
+  PiAiRuntime,
+  PiRunCancelledError,
+  PiRuntimeError,
+} from "./runtime";
+
+function createFauxRuntime(options: { tokensPerSecond?: number } = {}) {
+  const faux = fauxProvider({
+    provider: "anthropic",
+    models: [
+      { id: "claude-fable-5", name: "Fable" },
+      { id: "claude-opus-4-8", name: "Opus" },
+    ],
+    tokensPerSecond: options.tokensPerSecond,
+  });
+  const models = createModels({ credentials: new InMemoryCredentialStore() });
+  models.setProvider(faux.provider);
+  return { faux, runtime: new PiAiRuntime({ models }) };
+}
+
+describe("PiAiRuntime", () => {
+  test("exposes a serializable canonical connected catalog", async () => {
+    const { runtime } = createFauxRuntime();
+    const catalog = await runtime.getCatalog();
+
+    expect(catalog.providers).toHaveLength(1);
+    expect(catalog.providers[0]).toMatchObject({
+      id: "anthropic",
+      label: "Claude",
+      connection: {
+        state: "connected",
+        type: "api_key",
+        origin: "external",
+        disconnectable: false,
+      },
+    });
+    expect(catalog.providers[0]).not.toHaveProperty("uiId");
+    expect(catalog.providers[0]?.models.map((model) => model.id)).toEqual([
+      "claude-fable-5",
+      "claude-opus-4-8",
+    ]);
+  });
+
+  test("uses the provider default for a blank model and streams cumulative text", async () => {
+    const { faux, runtime } = createFauxRuntime();
+    let requestedModel = "";
+    faux.setResponses([
+      (context, _options, _state, model) => {
+        requestedModel = model.id;
+        expect(context.messages.at(-1)).toMatchObject({ role: "user", content: "hello" });
+        return fauxAssistantMessage("world");
+      },
+    ]);
+    const chunks: string[] = [];
+
+    const result = await runtime.runText({
+      providerId: "anthropic",
+      modelId: "",
+      prompt: "hello",
+      onChunk: (chunk) => chunks.push(chunk),
+    }).done;
+
+    expect(requestedModel).toBe("claude-opus-4-8");
+    expect(result).toBe("world");
+    expect(chunks.at(-1)).toBe("world");
+  });
+
+  test("rejects legacy provider aliases at the Pi runtime boundary", async () => {
+    const { runtime } = createFauxRuntime();
+
+    await expect(runtime.getProviderSummary("claude"))
+      .rejects.toMatchObject({ code: "provider_not_found" });
+  });
+
+  test("rejects an injected legacy provider instead of publishing a mismatched canonical entry", async () => {
+    const legacy = fauxProvider({
+      provider: "claude",
+      models: [{ id: "claude-opus-4-8", name: "Opus" }],
+    });
+    const models = createModels({ credentials: new InMemoryCredentialStore() });
+    models.setProvider(legacy.provider);
+    const runtime = new PiAiRuntime({ models });
+
+    await expect(runtime.getCatalog()).rejects.toMatchObject({
+      code: "provider_not_found",
+      message: "Unsupported AI provider: claude",
+    });
+  });
+
+  test("bridges OAuth events and prompts without returning credentials", async () => {
+    const credentials = new InMemoryCredentialStore();
+    const faux = fauxProvider({ provider: "anthropic", models: [{ id: "claude-opus-4-8" }] });
+    const provider = createProvider({
+      id: "anthropic",
+      name: "Anthropic",
+      auth: {
+        oauth: {
+          name: "Claude Pro/Max",
+          login: async (interaction) => {
+            interaction.notify({ type: "auth_url", url: "https://example.test/login" });
+            const code = await interaction.prompt({ type: "text", message: "Paste code" });
+            return { type: "oauth", access: `access-${code}`, refresh: "refresh-secret", expires: Date.now() + 60_000 };
+          },
+          refresh: async (credential) => credential,
+          toAuth: async (credential) => ({ apiKey: credential.access }),
+        },
+      },
+      models: faux.models,
+      api: { stream: faux.provider.stream, streamSimple: faux.provider.streamSimple },
+    });
+    const models = createModels({ credentials });
+    models.setProvider(provider);
+    const runtime = new PiAiRuntime({ models });
+    const events: unknown[] = [];
+    const prompts: unknown[] = [];
+
+    const connected = await runtime.login(
+      { providerId: "anthropic", type: "oauth" },
+      {
+        notify: (event) => events.push(event),
+        prompt: async (prompt) => {
+          prompts.push(prompt);
+          return "login-code";
+        },
+      },
+    );
+
+    expect(events).toEqual([{ type: "auth_url", url: "https://example.test/login" }]);
+    expect(prompts).toEqual([{ type: "text", message: "Paste code" }]);
+    expect(connected.connection).toEqual({
+      state: "connected",
+      type: "oauth",
+      source: "OAuth",
+      origin: "stored",
+      disconnectable: true,
+    });
+    expect(JSON.stringify(connected)).not.toContain("login-code");
+    expect((await runtime.logout("anthropic")).connection).toEqual({ state: "not_connected" });
+  });
+
+  test("does not report an expired OAuth credential as connected when refresh fails", async () => {
+    const credentials = new InMemoryCredentialStore();
+    await credentials.modify("anthropic", async () => ({
+      type: "oauth",
+      access: "expired-access",
+      refresh: "expired-refresh",
+      expires: Date.now() - 1,
+    }));
+    const faux = fauxProvider({ provider: "anthropic", models: [{ id: "claude-opus-4-8" }] });
+    const provider = createProvider({
+      id: "anthropic",
+      name: "Anthropic",
+      auth: {
+        oauth: {
+          name: "Claude Pro/Max",
+          login: async () => { throw new Error("unused"); },
+          refresh: async () => { throw new Error("refresh rejected"); },
+          toAuth: async (credential) => ({ apiKey: credential.access }),
+        },
+      },
+      models: faux.models,
+      api: { stream: faux.provider.stream, streamSimple: faux.provider.streamSimple },
+    });
+    const models = createModels({ credentials });
+    models.setProvider(provider);
+    const runtime = new PiAiRuntime({ models });
+
+    expect((await runtime.getProviderSummary("anthropic")).connection).toMatchObject({
+      state: "error",
+      message: expect.stringContaining("OAuth refresh failed"),
+    });
+    await expect(runtime.resolveModel({ providerId: "anthropic" }))
+      .rejects.toMatchObject({ code: "provider_not_configured" });
+  });
+
+  test("normalizes provider failures and cancellation", async () => {
+    const failed = createFauxRuntime();
+    failed.faux.setResponses([
+      fauxAssistantMessage([], {
+        stopReason: "error",
+        errorMessage: "Authorization: Bearer super-secret-token",
+      }),
+    ]);
+    const failure = failed.runtime.runText({ providerId: "anthropic", prompt: "fail" }).done;
+    await expect(failure).rejects.toBeInstanceOf(PiRuntimeError);
+    await expect(failure).rejects.not.toThrow("super-secret-token");
+
+    const slow = createFauxRuntime({ tokensPerSecond: 0.01 });
+    slow.faux.setResponses([fauxAssistantMessage("This response should be cancelled.")]);
+    const run = slow.runtime.runText({ providerId: "anthropic", prompt: "cancel" });
+    run.cancel();
+    await expect(run.done).rejects.toBeInstanceOf(PiRunCancelledError);
+  });
+
+  test("runs typed tools through pi-agent-core and returns the final agent response", async () => {
+    const { faux, runtime } = createFauxRuntime();
+    faux.setResponses([
+      fauxAssistantMessage(fauxToolCall("remote_control", { request: "schema" }), { stopReason: "toolUse" }),
+      fauxAssistantMessage("Remote schema loaded."),
+    ]);
+    const toolCalls: unknown[] = [];
+    const chunks: string[] = [];
+
+    const run = runtime.runAgent({
+      providerId: "anthropic",
+      prompt: "Inspect the app",
+      tools: [{
+        name: "remote_control",
+        label: "Gloomberb remote control",
+        description: "Send a request to the running Gloomberb app.",
+        parameters: Type.Object({ request: Type.String() }),
+        execute: async (_toolCallId, params) => {
+          const request = (params as { request: string }).request;
+          toolCalls.push({ request });
+          return {
+            content: [{ type: "text", text: '{"actions":[]}' }],
+            details: { request },
+          };
+        },
+      }],
+      onChunk: (chunk) => chunks.push(chunk),
+    });
+
+    const result = await run.done;
+    expect(toolCalls).toEqual([{ request: "schema" }]);
+    expect(result.text).toBe("Remote schema loaded.");
+    expect(chunks.at(-1)).toBe("Remote schema loaded.");
+    expect(result.messages.some((message) => message.role === "toolResult")).toBe(true);
+  });
+});