gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/ai/runner-selector.tsx

@@ -1,153 +0,0 @@
-import { useCallback, useEffect, useRef, type ReactNode, type RefObject } from "react";
-import { Box, Text, type InputRenderable } from "../../../ui";
-import { Button } from "../../../components";
-import { ChoiceDialog } from "../../../components/ui/choice-dialog";
-import { useDialog, type PromptContext } from "../../../ui/dialog";
-import { colors } from "../../../theme/colors";
-import { getAiProviderUnavailableLabel, type AiProvider } from "./providers";
-import {
-  AI_AUTO_MODEL_VALUE,
-  getAiModelSelectionOptions,
-  isAiProviderReady,
-  normalizeAiModelId,
-} from "./runner-selection";
-import { useAiRuntimeCatalog } from "./use-runtime-providers";
-
-export function AiRunnerSelector({
-  providers,
-  providerId,
-  modelId,
-  description,
-  modelHint = "Choose from the Pi model catalog.",
-  onProviderChange,
-  onModelChange,
-  modelFocused,
-  onModelFocusRequest,
-  onModelBlur,
-}: {
-  providers: AiProvider[];
-  providerId: string;
-  modelId: string;
-  description?: ReactNode;
-  modelHint?: string;
-  onProviderChange: (providerId: string) => void;
-  onModelChange: (modelId: string) => void;
-  modelInputRef?: RefObject<InputRenderable | null>;
-  modelFocused?: boolean;
-  onModelFocusRequest?: () => void;
-  onModelBlur?: (modelId: string) => void;
-}) {
-  const dialog = useDialog();
-  const catalog = useAiRuntimeCatalog();
-  const openingRef = useRef<"provider" | "model" | null>(null);
-  const wasModelFocusedRef = useRef(false);
-  const selectedProvider = providers.find((provider) => provider.id === providerId) ?? providers[0] ?? null;
-  const modelOptions = getAiModelSelectionOptions(providerId, modelId, catalog);
-  const normalizedModelId = normalizeAiModelId(modelId);
-  const selectedModel = modelOptions.find((option) => (
-    option.value === (normalizedModelId ?? AI_AUTO_MODEL_VALUE)
-  )) ?? modelOptions[0];
-
-  const openProviderPicker = useCallback(async () => {
-    if (openingRef.current || providers.length === 0) return;
-    openingRef.current = "provider";
-    try {
-      const selected = await dialog.prompt<string>({
-        content: (context: PromptContext<string>) => (
-          <ChoiceDialog
-            {...context}
-            title="Choose AI provider"
-            choices={providers.map((provider) => ({
-              id: provider.id,
-              label: isAiProviderReady(provider)
-                ? provider.name
-                : `${provider.name} · ${getAiProviderUnavailableLabel(provider)}`,
-              description: isAiProviderReady(provider)
-                ? `${provider.name} is connected and ready.`
-                : provider.unavailableReason,
-            }))}
-            selectedChoiceId={selectedProvider?.id}
-          />
-        ),
-      });
-      if (selected) onProviderChange(selected);
-    } finally {
-      openingRef.current = null;
-    }
-  }, [dialog, onProviderChange, providers, selectedProvider?.id]);
-
-  const openModelPicker = useCallback(async () => {
-    if (openingRef.current || !selectedProvider) return;
-    openingRef.current = "model";
-    try {
-      const selected = await dialog.prompt<string>({
-        content: (context: PromptContext<string>) => (
-          <ChoiceDialog
-            {...context}
-            title={`Choose ${selectedProvider.name} model`}
-            choices={modelOptions.map((option) => ({
-              id: option.value,
-              label: option.label,
-              description: option.description,
-            }))}
-            selectedChoiceId={normalizedModelId ?? AI_AUTO_MODEL_VALUE}
-          />
-        ),
-      });
-      const nextModelId = selected === AI_AUTO_MODEL_VALUE
-        ? ""
-        : selected || modelId;
-      if (selected) onModelChange(nextModelId);
-      onModelBlur?.(nextModelId);
-    } finally {
-      openingRef.current = null;
-    }
-  }, [
-    dialog,
-    modelId,
-    modelOptions,
-    normalizedModelId,
-    onModelBlur,
-    onModelChange,
-    selectedProvider,
-  ]);
-
-  useEffect(() => {
-    const becameFocused = !!modelFocused && !wasModelFocusedRef.current;
-    wasModelFocusedRef.current = !!modelFocused;
-    if (becameFocused) void openModelPicker();
-  }, [modelFocused, openModelPicker]);
-
-  return (
-    <Box flexDirection="column" gap={1}>
-      <Box flexDirection="column">
-        <Text fg={colors.textDim}>Provider</Text>
-        <Button
-          label={selectedProvider
-            ? isAiProviderReady(selectedProvider)
-              ? selectedProvider.name
-              : `${selectedProvider.name} · ${getAiProviderUnavailableLabel(selectedProvider)}`
-            : "Choose provider"}
-          variant="secondary"
-          onPress={() => {
-            void openProviderPicker();
-          }}
-        />
-      </Box>
-      {description}
-      <Box flexDirection="column">
-        <Text fg={colors.textDim}>Model</Text>
-        <Button
-          label={selectedModel?.label ?? "Auto · provider default"}
-          variant="secondary"
-          active={!!modelFocused}
-          onPress={() => {
-            onModelFocusRequest?.();
-            void openModelPicker();
-          }}
-        />
-        <Text fg={colors.textMuted}>{modelHint}</Text>
-      </Box>
-    </Box>
-  );
-}

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

@@ -1,198 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import {
-  connectAiRuntimeProvider,
-  disconnectAiRuntimeProvider,
-  getAiRuntimeCatalog,
-  getAiRuntimeCatalogSnapshot,
-  installAiRunHost,
-  runAiPrompt,
-  setAiRunHost,
-  setAiRuntimeCatalog,
-  subscribeAiRuntimeCatalog,
-  type AiRunHost,
-  type AiRuntimeCatalog,
-} from "./runner";
-
-function catalog(connectionState: "connected" | "not_connected"): AiRuntimeCatalog {
-  const connected = connectionState === "connected";
-  return {
-    providers: [{
-      providerId: "openai-codex",
-      label: "OpenAI (ChatGPT)",
-      status: connected ? "ready" : "not_authenticated",
-      ...(!connected ? { unavailableReason: "Not connected." } : {}),
-      outputModes: ["plain", "structured", "screener"],
-      defaultModelId: "gpt-5.6-sol",
-    }],
-    accounts: [{
-      providerId: "openai-codex",
-      providerLabel: "OpenAI (ChatGPT)",
-      connectionState,
-      connectionLabel: connected ? "Connected with OAuth" : "Not connected.",
-      ...(connected
-        ? { credentialSource: "OAuth", credentialOrigin: "stored" as const }
-        : {}),
-      authMethods: [{ type: "oauth", label: "ChatGPT Plus/Pro", canLogin: true }],
-      canLogin: true,
-      canDisconnect: connected,
-      loginType: "oauth",
-    }],
-    models: [{
-      id: "gpt-5.6-sol",
-      providerId: "openai-codex",
-      label: "GPT-5.6 Sol",
-      available: connected,
-    }],
-  };
-}
-
-afterEach(() => {
-  setAiRunHost(null);
-  setAiRuntimeCatalog({ providers: [], accounts: [], models: [] });
-});
-
-describe("AI runtime catalog", () => {
-  test("publishes stable snapshots for set, connect, and disconnect", async () => {
-    const connected = catalog("connected");
-    const disconnected = catalog("not_connected");
-    const snapshots: AiRuntimeCatalog[] = [];
-    const authEvents: unknown[] = [];
-    const unsubscribe = subscribeAiRuntimeCatalog(() => {
-      snapshots.push(getAiRuntimeCatalogSnapshot());
-    });
-    setAiRunHost({
-      run: () => ({ done: Promise.resolve("unused"), cancel() {} }),
-      connect: async (_providerId, _authType, onAuthEvent) => {
-        onAuthEvent?.({
-          type: "device_code",
-          userCode: "ABCD-EFGH",
-          verificationUri: "https://github.com/login/device",
-        });
-        return connected;
-      },
-      disconnect: async () => disconnected,
-    });
-
-    const initialSnapshot = getAiRuntimeCatalogSnapshot();
-    setAiRuntimeCatalog(disconnected);
-    const setSnapshot = getAiRuntimeCatalogSnapshot();
-    expect(setSnapshot).not.toBe(initialSnapshot);
-    expect(getAiRuntimeCatalogSnapshot()).toBe(setSnapshot);
-
-    await connectAiRuntimeProvider("codex", undefined, (event) => {
-      authEvents.push(event);
-    });
-    const connectSnapshot = getAiRuntimeCatalogSnapshot();
-    expect(connectSnapshot.accounts[0]?.connectionState).toBe("connected");
-    expect(connectSnapshot).not.toBe(setSnapshot);
-    expect(authEvents).toEqual([{
-      type: "device_code",
-      userCode: "ABCD-EFGH",
-      verificationUri: "https://github.com/login/device",
-    }]);
-
-    await disconnectAiRuntimeProvider("openai-codex");
-    expect(getAiRuntimeCatalogSnapshot().accounts[0]?.connectionState).toBe("not_connected");
-    expect(snapshots).toHaveLength(3);
-
-    unsubscribe();
-    setAiRuntimeCatalog(connected);
-    expect(snapshots).toHaveLength(3);
-  });
-
-  test("returns a defensive imperative copy including nested auth methods", () => {
-    setAiRuntimeCatalog(catalog("connected"));
-    const copy = getAiRuntimeCatalog();
-    copy.providers[0]!.outputModes.length = 0;
-    copy.accounts[0]!.authMethods[0]!.label = "mutated";
-
-    expect(getAiRuntimeCatalogSnapshot().providers[0]?.outputModes).toEqual([
-      "plain",
-      "structured",
-      "screener",
-    ]);
-    expect(getAiRuntimeCatalogSnapshot().accounts[0]?.authMethods[0]?.label)
-      .toBe("ChatGPT Plus/Pro");
-  });
-});
-
-describe("AI runner", () => {
-  test("installs the run host before best-effort catalog discovery settles", async () => {
-    const catalogErrors: unknown[] = [];
-    const installation = installAiRunHost({
-      run: () => ({ done: Promise.resolve("available"), cancel() {} }),
-      getCatalog: () => new Promise(() => {}),
-    }, {
-      catalogTimeoutMs: 5,
-      timeoutMessage: "AI discovery timed out",
-      onCatalogError: (error) => catalogErrors.push(error),
-    });
-
-    await expect(runAiPrompt({
-      providerId: "anthropic",
-      prompt: "hello",
-    }).done).resolves.toBe("available");
-    await expect(installation).resolves.toEqual({ providers: [], accounts: [], models: [] });
-    expect(catalogErrors).toHaveLength(1);
-    expect(catalogErrors[0]).toMatchObject({ message: "AI discovery timed out" });
-  });
-
-  test("delegates canonical provider id, model, and structured history to the native host", async () => {
-    type RunOptions = Parameters<AiRunHost["run"]>[0];
-    const received: RunOptions[] = [];
-    let cancelled = false;
-    setAiRunHost({
-      run(options) {
-        received.push(options);
-        return {
-          done: Promise.resolve("host output"),
-          cancel: () => { cancelled = true; },
-        };
-      },
-    });
-
-    const run = runAiPrompt({
-      // Legacy values are accepted only at this migration boundary.
-      providerId: "codex",
-      prompt: "Current request",
-      messages: [
-        { role: "user", content: "Earlier request" },
-        { role: "assistant", content: "Earlier response" },
-      ],
-      modelId: "gpt-5.6-sol",
-      outputMode: "structured",
-    });
-    run.cancel();
-
-    expect(await run.done).toBe("host output");
-    expect(received).toEqual([{
-      providerId: "openai-codex",
-      prompt: "Current request",
-      messages: [
-        { role: "user", content: "Earlier request" },
-        { role: "assistant", content: "Earlier response" },
-      ],
-      agentMessages: undefined,
-      modelId: "gpt-5.6-sol",
-      onChunk: undefined,
-      onAgentMessages: undefined,
-      outputMode: "structured",
-    }]);
-    expect(cancelled).toBe(true);
-  });
-
-  test("fails clearly when the native runtime is unavailable or provider id is unknown", async () => {
-    await expect(runAiPrompt({
-      providerId: "anthropic",
-      prompt: "hello",
-    }).done).rejects.toThrow("native AI runtime is unavailable");
-
-    setAiRunHost({
-      run: () => ({ done: Promise.resolve("unused"), cancel() {} }),
-    });
-    await expect(runAiPrompt({
-      providerId: "opencode",
-      prompt: "hello",
-    }).done).rejects.toThrow("Unknown AI provider: opencode");
-  });
-});

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

@@ -1,316 +0,0 @@
-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() {
-    super("AI run cancelled");
-    this.name = "AiRunCancelledError";
-  }
-}
-
-export interface AiRunController {
-  done: Promise<string>;
-  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: {
-    providerId: AiProviderId;
-    prompt: 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 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();
-}
-
-export function setAiRuntimeCatalog(catalog: AiRuntimeCatalog): void {
-  publishCatalog(catalog);
-}
-
-/**
- * Stable snapshot for useSyncExternalStore. A new reference is published only
- * when set/connect/disconnect replaces the catalog.
- */
-export function getAiRuntimeCatalogSnapshot(): AiRuntimeCatalog {
-  return runtimeCatalog;
-}
-
-export function subscribeAiRuntimeCatalog(listener: CatalogListener): () => void {
-  catalogListeners.add(listener);
-  return () => {
-    catalogListeners.delete(listener);
-  };
-}
-
-/** Defensive copy for imperative consumers. */
-export function getAiRuntimeCatalog(): AiRuntimeCatalog {
-  return cloneCatalog(runtimeCatalog);
-}
-
-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;
-}
-
-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 {
-    available: false,
-    authenticated: false,
-    message: account?.connectionLabel ?? "AI provider is not connected.",
-  };
-}
-
-export function runAiPrompt({
-  providerId,
-  prompt,
-  messages,
-  agentMessages,
-  modelId,
-  onChunk,
-  onAgentMessages,
-  outputMode,
-}: {
-  providerId: string;
-  prompt: string;
-  messages?: AiConversationMessage[];
-  agentMessages?: AiAgentHistoryMessage[];
-  modelId?: string;
-  onChunk?: (output: string) => void;
-  onAgentMessages?: (messages: AiAgentHistoryMessage[]) => void;
-  outputMode?: AiRunOutputMode;
-}): AiRunController {
-  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,
-  });
-}