gloomberb 0.9.9 → 0.10.0

package/src/plugins/builtin/ai/runner.ts

@@ -1,4 +1,14 @@
-import type { AiProvider } from "./providers";
+import {
+  aiProviderFromRuntime,
+  isAiProviderId,
+  migrateLegacyAiProviderId,
+  setDetectedProviders,
+  type AiProvider,
+  type AiProviderId,
+  type AiProviderStatus,
+} from "./providers";
+import type { AiAgentHistoryMessage } from "./agent-history";
+import { withDeadline } from "../../../utils/async-deadline";
 
 export class AiRunCancelledError extends Error {
   constructor() {
@@ -12,108 +22,301 @@ export interface AiRunController {
   cancel: () => void;
 }
 
+export interface AiConversationMessage {
+  role: "user" | "assistant";
+  content: string;
+}
+
+export type AiRunOutputMode = "plain" | "structured" | "screener";
+export type AiRuntimeConnectionState = "connected" | "not_connected" | "error";
+export type AiRuntimeAuthType = "oauth" | "api_key";
+export type AiCredentialOrigin = "stored" | "external";
+
+export type AiAuthProgressEvent =
+  | {
+      type: "info";
+      message: string;
+      links?: readonly { url: string; label?: string }[];
+    }
+  | {
+      type: "auth_url";
+      url: string;
+      instructions?: string;
+    }
+  | {
+      type: "device_code";
+      userCode: string;
+      verificationUri: string;
+      intervalSeconds?: number;
+      expiresInSeconds?: number;
+    }
+  | {
+      type: "progress";
+      message: string;
+    };
+
+export interface AiRuntimeModel {
+  id: string;
+  providerId: AiProviderId;
+  label: string;
+  available: boolean;
+}
+
+export interface AiRuntimeAuthMethod {
+  type: AiRuntimeAuthType;
+  label: string;
+  /**
+   * True only when the current renderer-neutral host can complete this method
+   * without exposing a credential in an unmasked field.
+   */
+  canLogin: boolean;
+}
+
+export interface AiRuntimeAccount {
+  providerId: AiProviderId;
+  providerLabel: string;
+  connectionState: AiRuntimeConnectionState;
+  connectionLabel: string;
+  credentialSource?: string;
+  credentialOrigin?: AiCredentialOrigin;
+  authMethods: AiRuntimeAuthMethod[];
+  canLogin: boolean;
+  canDisconnect: boolean;
+  loginType?: AiRuntimeAuthType;
+}
+
+export interface AiRuntimeProvider {
+  providerId: AiProviderId;
+  label: string;
+  status: AiProviderStatus;
+  unavailableReason?: string;
+  outputModes: AiRunOutputMode[];
+  defaultModelId?: string;
+}
+
+export interface AiRuntimeCatalog {
+  providers: AiRuntimeProvider[];
+  accounts: AiRuntimeAccount[];
+  models: AiRuntimeModel[];
+}
+
 export interface AiRunHost {
   run(options: {
-    provider: AiProvider;
+    providerId: AiProviderId;
     prompt: string;
-    cwd?: string;
+    messages?: AiConversationMessage[];
+    agentMessages?: AiAgentHistoryMessage[];
+    modelId?: string;
     onChunk?: (output: string) => void;
+    onAgentMessages?: (messages: AiAgentHistoryMessage[]) => void;
+    outputMode?: AiRunOutputMode;
   }): AiRunController;
+  checkStatus?(providerId: AiProviderId): Promise<AiProviderStatusResult>;
+  getCatalog?(): Promise<AiRuntimeCatalog>;
+  connect?(
+    providerId: AiProviderId,
+    authType?: AiRuntimeAuthType,
+    onAuthEvent?: (event: AiAuthProgressEvent) => void,
+  ): Promise<AiRuntimeCatalog>;
+  disconnect?(providerId: AiProviderId): Promise<AiRuntimeCatalog>;
+}
+
+export interface AiProviderStatusResult {
+  available: boolean;
+  authenticated: boolean;
+  /** True when the provider exists but credential validation failed unexpectedly. */
+  inconclusive?: boolean;
+  message: string | null;
 }
 
+type CatalogListener = () => void;
+
 let configuredHost: AiRunHost | null = null;
+let runtimeCatalog: AiRuntimeCatalog = { providers: [], accounts: [], models: [] };
+const catalogListeners = new Set<CatalogListener>();
+
+function canonicalProviderId(providerId: string): AiProviderId {
+  const canonicalId = migrateLegacyAiProviderId(providerId);
+  if (!isAiProviderId(canonicalId)) {
+    throw new Error(`Unknown AI provider: ${providerId}`);
+  }
+  return canonicalId;
+}
+
+function cloneCatalog(catalog: AiRuntimeCatalog): AiRuntimeCatalog {
+  return {
+    providers: catalog.providers.map((provider) => ({
+      ...provider,
+      outputModes: [...provider.outputModes],
+    })),
+    accounts: catalog.accounts.map((account) => ({
+      ...account,
+      authMethods: account.authMethods.map((method) => ({ ...method })),
+    })),
+    models: catalog.models.map((model) => ({ ...model })),
+  };
+}
+
+function publishCatalog(catalog: AiRuntimeCatalog): void {
+  runtimeCatalog = cloneCatalog(catalog);
+  setDetectedProviders(runtimeCatalog.providers.map(aiProviderFromRuntime));
+  for (const listener of [...catalogListeners]) listener();
+}
 
 export function setAiRunHost(host: AiRunHost | null): void {
   configuredHost = host;
 }
 
-export function isAiRunCancelled(error: unknown): boolean {
-  return error instanceof AiRunCancelledError;
+export async function installAiRunHost(
+  host: AiRunHost,
+  options: {
+    catalogTimeoutMs: number;
+    timeoutMessage: string;
+    onCatalogError?: (error: unknown) => void;
+  },
+): Promise<AiRuntimeCatalog> {
+  setAiRunHost(host);
+  const emptyCatalog: AiRuntimeCatalog = { providers: [], accounts: [], models: [] };
+  const catalog = await withDeadline(
+    Promise.resolve().then(() => host.getCatalog?.() ?? emptyCatalog),
+    options.catalogTimeoutMs,
+    options.timeoutMessage,
+  ).catch((error) => {
+    try {
+      options.onCatalogError?.(error);
+    } catch {
+      // Logging must not turn optional provider discovery into a startup failure.
+    }
+    return emptyCatalog;
+  });
+  setAiRuntimeCatalog(catalog);
+  return getAiRuntimeCatalog();
 }
 
-function runWithBun({
-  provider,
-  prompt,
-  cwd = typeof process !== "undefined" ? process.cwd() : ".",
-  onChunk,
-}: {
-  provider: AiProvider;
-  prompt: string;
-  cwd?: string;
-  onChunk?: (output: string) => void;
-}): AiRunController {
-  type BunSubprocess = ReturnType<typeof Bun.spawn>;
-  if (typeof Bun === "undefined" || typeof Bun.spawn !== "function") {
-    return {
-      done: Promise.reject(new Error("AI execution requires a native Bun host.")),
-      cancel: () => {},
-    };
-  }
+export function setAiRuntimeCatalog(catalog: AiRuntimeCatalog): void {
+  publishCatalog(catalog);
+}
 
-  let cancelled = false;
-  let processRef: BunSubprocess | null = null;
-
-  const done = (async () => {
-    const proc = Bun.spawn([provider.command, ...provider.buildArgs(prompt)], {
-      cwd,
-      stdin: "ignore",
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    processRef = proc;
-
-    const stderrPromise = new Response(proc.stderr).text().catch(() => "");
-    const stdoutReader = proc.stdout.getReader();
-    const decoder = new TextDecoder();
-    let fullOutput = "";
-
-    while (true) {
-      const { done: streamDone, value } = await stdoutReader.read();
-      if (streamDone) break;
-      if (cancelled) throw new AiRunCancelledError();
-      fullOutput += decoder.decode(value, { stream: true });
-      onChunk?.(fullOutput);
-    }
+/**
+ * Stable snapshot for useSyncExternalStore. A new reference is published only
+ * when set/connect/disconnect replaces the catalog.
+ */
+export function getAiRuntimeCatalogSnapshot(): AiRuntimeCatalog {
+  return runtimeCatalog;
+}
 
-    const exitCode = await proc.exited;
-    const stderr = (await stderrPromise).trim();
+export function subscribeAiRuntimeCatalog(listener: CatalogListener): () => void {
+  catalogListeners.add(listener);
+  return () => {
+    catalogListeners.delete(listener);
+  };
+}
 
-    if (cancelled) throw new AiRunCancelledError();
-    if (exitCode !== 0) {
-      throw new Error(stderr || fullOutput.trim() || `${provider.name} exited with status ${exitCode}.`);
-    }
+/** Defensive copy for imperative consumers. */
+export function getAiRuntimeCatalog(): AiRuntimeCatalog {
+  return cloneCatalog(runtimeCatalog);
+}
 
-    const finalOutput = fullOutput.trim();
-    if (!finalOutput) {
-      throw new Error(stderr || `${provider.name} returned an empty response.`);
-    }
+export async function refreshAiRuntimeCatalog(): Promise<AiRuntimeCatalog> {
+  if (!configuredHost?.getCatalog) return getAiRuntimeCatalog();
+  publishCatalog(await configuredHost.getCatalog());
+  return getAiRuntimeCatalog();
+}
+
+export async function connectAiRuntimeProvider(
+  providerId: string,
+  authType?: AiRuntimeAuthType,
+  onAuthEvent?: (event: AiAuthProgressEvent) => void,
+): Promise<AiRuntimeCatalog> {
+  if (!configuredHost?.connect) {
+    throw new Error("In-app AI account connections are unavailable in this renderer.");
+  }
+  const canonicalId = canonicalProviderId(providerId);
+  publishCatalog(await configuredHost.connect(canonicalId, authType, onAuthEvent));
+  return getAiRuntimeCatalog();
+}
+
+export async function disconnectAiRuntimeProvider(providerId: string): Promise<AiRuntimeCatalog> {
+  if (!configuredHost?.disconnect) {
+    throw new Error("In-app AI account disconnection is unavailable in this renderer.");
+  }
+  publishCatalog(await configuredHost.disconnect(canonicalProviderId(providerId)));
+  return getAiRuntimeCatalog();
+}
+
+export function isAiRunCancelled(error: unknown): boolean {
+  return error instanceof AiRunCancelledError;
+}
 
-    return finalOutput;
-  })();
+export async function checkAiProviderStatus(
+  provider: AiProvider | AiProviderId,
+): Promise<AiProviderStatusResult> {
+  const providerId = canonicalProviderId(typeof provider === "string" ? provider : provider.id);
+  if (configuredHost?.checkStatus) return configuredHost.checkStatus(providerId);
 
+  const account = runtimeCatalog.accounts.find((candidate) => candidate.providerId === providerId);
+  if (account?.connectionState === "connected") {
+    return { available: true, authenticated: true, message: null };
+  }
+  if (account?.connectionState === "error") {
+    return {
+      available: false,
+      authenticated: false,
+      inconclusive: true,
+      message: account.connectionLabel,
+    };
+  }
   return {
-    done,
-    cancel: () => {
-      cancelled = true;
-      try {
-        processRef?.kill();
-      } catch {
-        // ignore cleanup failures
-      }
-    },
+    available: false,
+    authenticated: false,
+    message: account?.connectionLabel ?? "AI provider is not connected.",
   };
 }
 
 export function runAiPrompt({
-  provider,
+  providerId,
   prompt,
-  cwd,
+  messages,
+  agentMessages,
+  modelId,
   onChunk,
+  onAgentMessages,
+  outputMode,
 }: {
-  provider: AiProvider;
+  providerId: string;
   prompt: string;
-  cwd?: string;
+  messages?: AiConversationMessage[];
+  agentMessages?: AiAgentHistoryMessage[];
+  modelId?: string;
   onChunk?: (output: string) => void;
+  onAgentMessages?: (messages: AiAgentHistoryMessage[]) => void;
+  outputMode?: AiRunOutputMode;
 }): AiRunController {
-  return (configuredHost ?? { run: runWithBun }).run({ provider, prompt, cwd, onChunk });
+  if (!configuredHost) {
+    return {
+      done: Promise.reject(new Error("The native AI runtime is unavailable in this renderer.")),
+      cancel: () => {},
+    };
+  }
+
+  let canonicalId: AiProviderId;
+  try {
+    canonicalId = canonicalProviderId(providerId);
+  } catch (error) {
+    return {
+      done: Promise.reject(error),
+      cancel: () => {},
+    };
+  }
+
+  return configuredHost.run({
+    providerId: canonicalId,
+    prompt,
+    messages,
+    agentMessages,
+    modelId,
+    onChunk,
+    onAgentMessages,
+    outputMode,
+  });
 }

package/src/plugins/builtin/ai/screener/contract.test.ts

@@ -1,75 +1,44 @@
 import { describe, expect, test } from "bun:test";
-import { buildGloomberbCliInstructions, resolveGloomberbCliCommand } from "../gloomberb-cli";
 import {
   buildScreenerPrompt,
-  mergeScreenerResults,
+  getScreenerPromptSignature,
+  matchesScreenerPromptSignature,
   parseScreenerResponse,
 } from "./contract";
-import type { AiProvider } from "../providers";
-
-const TEST_PROVIDER: AiProvider = {
-  id: "claude",
-  name: "Claude",
-  command: "claude",
-  available: true,
-  buildArgs: () => [],
-};
 
 describe("AI screener helpers", () => {
-  test("prefers the installed gloomberb command when it exists", () => {
-    const command = resolveGloomberbCliCommand({
-      cwd: "/tmp/project",
-      hasCommand: (value) => value === "gloomberb",
-      fileExists: () => true,
-    });
-
-    expect(command).toEqual({
-      argv: ["gloomberb"],
-      display: "gloomberb",
-      mode: "installed",
-    });
-  });
-
-  test("falls back to bun source mode while developing locally", () => {
-    const command = resolveGloomberbCliCommand({
-      cwd: "/tmp/project",
-      hasCommand: () => false,
-      fileExists: (path) => path === "/tmp/project/src/index.tsx",
-    });
-
-    expect(command).toEqual({
-      argv: ["bun", "/tmp/project/src/index.tsx"],
-      display: "bun /tmp/project/src/index.tsx",
-      mode: "bun-source",
-    });
-    expect(buildGloomberbCliInstructions(command)).toContain("Inspect a portfolio or watchlist with: bun /tmp/project/src/index.tsx portfolio [name]");
+  test("includes the model override in run identity", () => {
+    expect(getScreenerPromptSignature("quality", "codex", "gpt-a"))
+      .not.toBe(getScreenerPromptSignature("quality", "codex", "gpt-b"));
+    expect(getScreenerPromptSignature("quality", "codex", ""))
+      .toBe(getScreenerPromptSignature("quality", "codex", null));
+    expect(matchesScreenerPromptSignature(
+      JSON.stringify(["codex", "quality"]),
+      "quality",
+      "codex",
+      null,
+    )).toBe(true);
+    expect(matchesScreenerPromptSignature(
+      JSON.stringify(["codex", "quality"]),
+      "quality",
+      "codex",
+      "gpt-custom",
+    )).toBe(false);
   });
 
-  test("builds a screener prompt with the current date and prior results", () => {
+  test("builds a fresh screener prompt with the current date", () => {
     const prompt = buildScreenerPrompt({
       currentDate: "2026-04-01",
       prompt: "Find profitable serial acquirers.",
-      provider: TEST_PROVIDER,
-      cliInstructions: [
-        "Useful commands: gloomberb help",
-        "Inspect a ticker with: gloomberb ticker <symbol>",
-      ],
-      previousResults: [
-        {
-          symbol: "CSU",
-          exchange: "TSX",
-          reason: "Recurring software roll-up.",
-          resolvedName: "Constellation Software",
-        },
-      ],
-      includePreviousResults: true,
     });
 
     expect(prompt).toContain("Today is 2026-04-01.");
-    expect(prompt).toContain("You are running in the Claude CLI.");
-    expect(prompt).toContain("Useful commands: gloomberb help");
-    expect(prompt).toContain("CSU (TSX): Recurring software roll-up.");
-    expect(prompt).toContain("Return raw JSON only.");
+    expect(prompt).toContain("Use the available Gloomberb data tools");
+    expect(prompt).toContain("Submit the final structured screener result");
+    expect(prompt).not.toContain("already found");
+    expect(prompt).not.toContain("Prefer new names");
+    expect(prompt).not.toContain("CLI");
+    expect(prompt).not.toContain("raw JSON");
   });
 
   test("parses fenced JSON responses and normalizes ticker fields", () => {
@@ -98,20 +67,4 @@ describe("AI screener helpers", () => {
     });
   });
 
-  test("merges reruns by updating duplicates and appending new symbols", () => {
-    const merged = mergeScreenerResults(
-      [
-        { symbol: "AAPL", exchange: "NASDAQ", reason: "Old reason", resolvedName: "Apple Inc." },
-      ],
-      [
-        { symbol: "AAPL", exchange: "NASDAQ", reason: "Updated reason", resolvedName: "Apple Inc." },
-        { symbol: "MSFT", exchange: "NASDAQ", reason: "New result", resolvedName: "Microsoft Corp." },
-      ],
-    );
-
-    expect(merged).toEqual([
-      { symbol: "AAPL", exchange: "NASDAQ", reason: "Updated reason", resolvedName: "Apple Inc." },
-      { symbol: "MSFT", exchange: "NASDAQ", reason: "New result", resolvedName: "Microsoft Corp." },
-    ]);
-  });
 });

package/src/plugins/builtin/ai/screener/contract.ts

@@ -1,4 +1,3 @@
-import type { AiProvider } from "../providers";
 import { truncateWithEllipsis } from "../../../../utils/text-wrap";
 
 interface ScreenerCandidate {
@@ -57,49 +56,39 @@ export function deriveScreenerTitle(prompt: string): string {
   return truncateWithEllipsis(normalized || "New Screener", 22);
 }
 
-export function getScreenerPromptSignature(prompt: string, providerId: string): string {
-  return JSON.stringify([providerId.trim(), prompt.trim()]);
+export function getScreenerPromptSignature(prompt: string, providerId: string, modelId?: string | null): string {
+  return JSON.stringify([providerId.trim(), modelId?.trim() || null, prompt.trim()]);
+}
+
+export function matchesScreenerPromptSignature(
+  signature: string | null,
+  prompt: string,
+  providerId: string,
+  modelId?: string | null,
+): boolean {
+  if (signature === getScreenerPromptSignature(prompt, providerId, modelId)) return true;
+  return !modelId?.trim() && signature === JSON.stringify([providerId.trim(), prompt.trim()]);
 }
 
 export function buildScreenerPrompt({
   currentDate,
   prompt,
-  provider,
-  cliInstructions,
-  previousResults,
-  includePreviousResults,
 }: {
   currentDate: string;
   prompt: string;
-  provider: AiProvider;
-  cliInstructions: string[];
-  previousResults: ValidatedScreenerResult[];
-  includePreviousResults: boolean;
 }): string {
   const lines = [
     `Today is ${currentDate}.`,
-    `You are running in the ${provider.name} CLI.`,
     "",
     "Find public-market tickers that match this screening prompt:",
     prompt.trim(),
     "",
-    "You may use the local Gloomberb CLI to validate companies before returning them:",
-    ...cliInstructions.map((instruction) => `- ${instruction}`),
+    "Use the available Gloomberb data tools to validate every company before submitting it.",
     "",
   ];
 
-  if (includePreviousResults && previousResults.length > 0) {
-    lines.push("These tickers were already found for this exact screener. Prefer new names if you can validate them:");
-    for (const result of previousResults) {
-      lines.push(`- ${result.symbol} (${result.exchange}): ${result.reason}`);
-    }
-    lines.push("");
-  }
-
   lines.push(
-    "Return raw JSON only. Do not wrap it in markdown or add commentary.",
-    "Schema:",
-    '{ "title": "optional short title", "summary": "optional one-line summary", "tickers": [{ "symbol": "AAPL", "exchange": "NASDAQ", "reason": "concise reason" }] }',
+    "Submit the final structured screener result with an optional short title, an optional one-line summary, and the validated tickers.",
     "Rules:",
     "- Return at most 25 unique ticker candidates.",
     "- Use uppercase symbols.",
@@ -145,30 +134,3 @@ export function parseScreenerResponse(raw: string): ParsedScreenerResponse {
     tickers,
   };
 }
-
-export function mergeScreenerResults(
-  previous: ValidatedScreenerResult[],
-  next: ValidatedScreenerResult[],
-): ValidatedScreenerResult[] {
-  const nextBySymbol = new Map(next.map((result) => [result.symbol, result] as const));
-  const merged: ValidatedScreenerResult[] = [];
-
-  for (const result of previous) {
-    const replacement = nextBySymbol.get(result.symbol);
-    if (replacement) {
-      merged.push(replacement);
-      nextBySymbol.delete(result.symbol);
-      continue;
-    }
-    merged.push(result);
-  }
-
-  for (const result of next) {
-    if (nextBySymbol.has(result.symbol)) {
-      merged.push(result);
-      nextBySymbol.delete(result.symbol);
-    }
-  }
-
-  return merged;
-}