gloomberb 0.9.9 → 0.10.0

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

@@ -1,74 +1,199 @@
+import type { AiRunOutputMode, AiRuntimeProvider } from "./runner";
+
+export const AI_PROVIDER_IDS = [
+  "anthropic",
+  "openai-codex",
+  "openai",
+  "google",
+  "github-copilot",
+  "xai",
+  "openrouter",
+] as const;
+
+export type AiProviderId = (typeof AI_PROVIDER_IDS)[number];
+
+/**
+ * These aliases exist only to migrate persisted pre-Pi selections. Runtime
+ * catalogs and requests always use the canonical Pi provider ids above.
+ */
+export const LEGACY_AI_PROVIDER_ID_ALIASES = {
+  claude: "anthropic",
+  codex: "openai-codex",
+  gemini: "google",
+} as const satisfies Readonly<Record<string, AiProviderId>>;
+
+export type AiProviderStatus = "ready" | "not_authenticated" | "check_failed";
+
+export interface AiProviderDefinition {
+  id: AiProviderId;
+  name: string;
+  outputModes: readonly AiRunOutputMode[];
+  /**
+   * Ordered, curated defaults. The runtime chooses the first one available to
+   * the connected account and never falls back to provider array order.
+   */
+  preferredModelIds: readonly string[];
+}
+
 export interface AiProvider {
-  id: string;
+  id: AiProviderId;
   name: string;
-  command: string;
   available: boolean;
-  buildArgs: (prompt: string) => string[];
+  status: AiProviderStatus;
+  unavailableReason?: string;
+  outputModes: AiRunOutputMode[];
+  defaultModelId?: string;
 }
 
-export interface AiProviderDefinition extends Omit<AiProvider, "available"> {}
+const ALL_OUTPUT_MODES: readonly AiRunOutputMode[] = ["plain", "structured", "screener"];
 
-const PROVIDER_DEFS: AiProviderDefinition[] = [
+const PROVIDER_DEFINITIONS: readonly AiProviderDefinition[] = [
   {
-    id: "claude",
+    id: "anthropic",
     name: "Claude",
-    command: "claude",
-    buildArgs: (prompt) => ["-p", prompt],
+    outputModes: ALL_OUTPUT_MODES,
+    preferredModelIds: ["claude-opus-4-8", "claude-sonnet-5"],
+  },
+  {
+    id: "openai-codex",
+    name: "OpenAI (ChatGPT)",
+    outputModes: ALL_OUTPUT_MODES,
+    preferredModelIds: ["gpt-5.6-sol", "gpt-5.6-terra"],
+  },
+  {
+    id: "openai",
+    name: "OpenAI API",
+    outputModes: ALL_OUTPUT_MODES,
+    preferredModelIds: ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.4"],
+  },
+  {
+    id: "google",
+    name: "Google Gemini",
+    outputModes: ALL_OUTPUT_MODES,
+    preferredModelIds: ["gemini-3.6-flash", "gemini-3.5-flash"],
   },
   {
-    id: "gemini",
-    name: "Gemini",
-    command: "gemini",
-    buildArgs: (prompt) => ["-p", prompt],
+    id: "github-copilot",
+    name: "GitHub Copilot",
+    outputModes: ALL_OUTPUT_MODES,
+    preferredModelIds: ["gpt-5.6-sol", "claude-sonnet-5", "gpt-5.4"],
   },
   {
-    id: "codex",
-    name: "Codex",
-    command: "codex",
-    buildArgs: (prompt) => ["exec", "--skip-git-repo-check", prompt],
+    id: "xai",
+    name: "xAI / Grok",
+    outputModes: ALL_OUTPUT_MODES,
+    preferredModelIds: ["grok-4.5", "grok-4.3"],
+  },
+  {
+    id: "openrouter",
+    name: "OpenRouter",
+    outputModes: ALL_OUTPUT_MODES,
+    preferredModelIds: [
+      "anthropic/claude-sonnet-5",
+      "openai/gpt-5.6-sol",
+      "google/gemini-3.6-flash",
+    ],
   },
 ];
 
 let detectedProviders: AiProvider[] | null = null;
 
-function commandExists(command: string): boolean {
-  try {
-    if (typeof Bun !== "undefined" && typeof Bun.which === "function") {
-      return !!Bun.which(command);
-    }
-  } catch {
-    return false;
-  }
-  return false;
+export function isAiProviderId(providerId: string): providerId is AiProviderId {
+  return (AI_PROVIDER_IDS as readonly string[]).includes(providerId);
 }
 
-export function detectProviders(): AiProvider[] {
-  if (detectedProviders) return detectedProviders;
+export function migrateLegacyAiProviderId(providerId: string): string {
+  return LEGACY_AI_PROVIDER_ID_ALIASES[
+    providerId as keyof typeof LEGACY_AI_PROVIDER_ID_ALIASES
+  ] ?? providerId;
+}
 
-  detectedProviders = PROVIDER_DEFS.map((definition) => ({
+export function getAiProviderDefinition(
+  providerId: string | null | undefined,
+): AiProviderDefinition | null {
+  if (!providerId) return null;
+  const canonicalId = migrateLegacyAiProviderId(providerId);
+  return PROVIDER_DEFINITIONS.find((provider) => provider.id === canonicalId) ?? null;
+}
+
+export function getAiProviderDefinitions(): AiProviderDefinition[] {
+  return PROVIDER_DEFINITIONS.map((definition) => ({
     ...definition,
-    available: commandExists(definition.command),
+    outputModes: [...definition.outputModes],
+    preferredModelIds: [...definition.preferredModelIds],
   }));
+}
+
+function disconnectedProvider(definition: AiProviderDefinition): AiProvider {
+  return {
+    id: definition.id,
+    name: definition.name,
+    available: false,
+    status: "not_authenticated",
+    unavailableReason: `${definition.name} is not connected.`,
+    outputModes: [...definition.outputModes],
+    defaultModelId: definition.preferredModelIds[0],
+  };
+}
+
+export function aiProviderFromRuntime(provider: AiRuntimeProvider): AiProvider {
+  return {
+    id: provider.providerId,
+    name: provider.label,
+    available: provider.status === "ready",
+    status: provider.status,
+    ...(provider.unavailableReason ? { unavailableReason: provider.unavailableReason } : {}),
+    outputModes: [...provider.outputModes],
+    ...(provider.defaultModelId ? { defaultModelId: provider.defaultModelId } : {}),
+  };
+}
+
+/**
+ * Compatibility accessor for pane code while it moves to the reactive runtime
+ * catalog. It contains only Pi providers and never performs CLI discovery.
+ */
+export function detectProviders(): AiProvider[] {
+  if (detectedProviders) return detectedProviders;
+  detectedProviders = PROVIDER_DEFINITIONS.map(disconnectedProvider);
   return detectedProviders;
 }
 
-export function getAvailableProviders(providers = detectProviders()): AiProvider[] {
+export function getAvailableProviders(
+  providers: readonly AiProvider[] = detectProviders(),
+): AiProvider[] {
   return providers.filter((provider) => provider.available);
 }
 
-export function getAiProvider(providerId: string | null | undefined, providers = detectProviders()): AiProvider | null {
+export function getAiProvider(
+  providerId: string | null | undefined,
+  providers: readonly AiProvider[] = detectProviders(),
+): AiProvider | null {
   if (!providerId) return null;
-  return providers.find((provider) => provider.id === providerId) ?? null;
+  const canonicalId = migrateLegacyAiProviderId(providerId);
+  return providers.find((provider) => provider.id === canonicalId) ?? null;
 }
 
-export function resolveDefaultAiProviderId(providers = detectProviders()): string {
-  return getAvailableProviders(providers)[0]?.id ?? providers[0]?.id ?? "claude";
+export function resolveDefaultAiProviderId(
+  providers: readonly AiProvider[] = detectProviders(),
+): AiProviderId {
+  return providers.find((provider) => provider.status === "ready")?.id
+    ?? providers[0]?.id
+    ?? "anthropic";
 }
 
-export function __setDetectedProvidersForTests(providers: AiProvider[] | null): void {
-  detectedProviders = providers;
+export function getAiProviderUnavailableReason(provider: AiProvider): string {
+  return provider.unavailableReason ?? `${provider.name} is not connected.`;
 }
 
-export function getAiProviderDefinitions(): AiProviderDefinition[] {
-  return PROVIDER_DEFS.map((definition) => ({ ...definition }));
+export function getAiProviderUnavailableLabel(provider: AiProvider): string {
+  return provider.status === "check_failed" ? "unavailable" : "sign in";
+}
+
+export function setDetectedProviders(providers: AiProvider[] | null): void {
+  detectedProviders = providers?.map((provider) => ({
+    ...provider,
+    outputModes: [...provider.outputModes],
+  })) ?? null;
 }
+
+export const __setDetectedProvidersForTests = setDetectedProviders;

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

@@ -0,0 +1,174 @@
+import { describe, expect, test } from "bun:test";
+import type { AiProvider, AiProviderId } from "./providers";
+import {
+  AI_AUTO_MODEL_VALUE,
+  buildAiRunnerWizard,
+  getAiModelSelectionOptions,
+  getAiRunnerWizardModelKey,
+  getSelectableAiRunners,
+  isAiProviderReady,
+  modelIdAfterAiProviderChange,
+  normalizeAiModelId,
+  resolveAiRunnerWizardModel,
+  resolveReadyAiRunnerDefault,
+  supportsAiRunOutputMode,
+} from "./runner-selection";
+import type { AiRuntimeCatalog } from "./runner";
+
+function provider(
+  id: AiProviderId,
+  status: AiProvider["status"],
+  outputModes: AiProvider["outputModes"] = ["plain", "structured", "screener"],
+): AiProvider {
+  return {
+    id,
+    name: id.toUpperCase(),
+    available: status === "ready",
+    status,
+    ...(status !== "ready" ? { unavailableReason: `${id} is not connected.` } : {}),
+    outputModes,
+  };
+}
+
+function catalog(providers: AiProvider[]): AiRuntimeCatalog {
+  return {
+    providers: providers.map((entry) => ({
+      providerId: entry.id,
+      label: entry.name,
+      status: entry.status,
+      ...(entry.unavailableReason ? { unavailableReason: entry.unavailableReason } : {}),
+      outputModes: [...entry.outputModes],
+    })),
+    accounts: [],
+    models: [],
+  };
+}
+
+describe("AI runner selection", () => {
+  test("shows every capable provider while preselecting one that is ready", () => {
+    const providers = [
+      provider("anthropic", "not_authenticated"),
+      provider("openai-codex", "ready"),
+      provider("google", "ready", ["plain"]),
+    ];
+
+    expect(getSelectableAiRunners(providers, {
+      outputMode: "structured",
+      runtimeCatalog: catalog(providers),
+    }).map(({ id }) => id)).toEqual(["anthropic", "openai-codex"]);
+    expect(buildAiRunnerWizard(providers, {
+      outputMode: "structured",
+      runtimeCatalog: catalog(providers),
+    })[0]?.defaultValue).toBe("openai-codex");
+  });
+
+  test("shows the full capable catalog with connection labels when none are ready", () => {
+    const providers = [
+      provider("anthropic", "not_authenticated"),
+      provider("openai-codex", "check_failed"),
+      provider("google", "not_authenticated", ["plain"]),
+    ];
+    const wizard = buildAiRunnerWizard(providers, {
+      outputMode: "structured",
+      runtimeCatalog: catalog(providers),
+    });
+
+    expect(getSelectableAiRunners(providers, {
+      outputMode: "structured",
+      runtimeCatalog: catalog(providers),
+    }).map(({ id }) => id)).toEqual(["anthropic", "openai-codex"]);
+    expect(wizard[0]?.type === "select" ? wizard[0].options?.map((option) => option.label) : [])
+      .toEqual(["ANTHROPIC (sign in)", "OPENAI-CODEX (unavailable)"]);
+    expect(wizard[0]?.defaultValue).toBe("anthropic");
+  });
+
+  test("derives capabilities only from Pi catalog output modes", () => {
+    const plain = provider("google", "ready", ["plain"]);
+    const structured = provider("anthropic", "ready");
+    const runtimeCatalog = catalog([plain, structured]);
+
+    expect(supportsAiRunOutputMode(plain, "structured", runtimeCatalog)).toBe(false);
+    expect(supportsAiRunOutputMode(structured, "structured", runtimeCatalog)).toBe(true);
+  });
+
+  test("preselects configured defaults from a provider-scoped Pi model catalog", () => {
+    const providers = [
+      provider("anthropic", "ready"),
+      provider("openai-codex", "ready"),
+    ];
+    const wizard = buildAiRunnerWizard(providers, {
+      defaultProviderId: "anthropic",
+      defaultModelId: " claude-opus-4-8 ",
+      outputMode: "structured",
+    });
+
+    expect(wizard[0]?.defaultValue).toBe("anthropic");
+    expect(wizard[1]).toMatchObject({
+      key: getAiRunnerWizardModelKey("anthropic"),
+      type: "select",
+      required: true,
+      defaultValue: "claude-opus-4-8",
+      dependsOn: { key: "providerId", value: "anthropic" },
+    });
+    expect(wizard[1]?.options?.map((option) => option.value))
+      .toEqual([AI_AUTO_MODEL_VALUE, "claude-opus-4-8"]);
+    expect(resolveAiRunnerWizardModel({
+      [getAiRunnerWizardModelKey("anthropic")]: "claude-opus-4-8",
+    }, "anthropic")).toBe("claude-opus-4-8");
+    expect(resolveAiRunnerWizardModel({
+      [getAiRunnerWizardModelKey("anthropic")]: AI_AUTO_MODEL_VALUE,
+    }, "anthropic")).toBeNull();
+    expect(normalizeAiModelId("  provider/model ")).toBe("provider/model");
+    expect(normalizeAiModelId("   ")).toBeNull();
+  });
+
+  test("uses Pi labels and availability in model choices", () => {
+    const runtimeCatalog = catalog([provider("anthropic", "ready")]);
+    runtimeCatalog.providers[0]!.defaultModelId = "claude-sonnet";
+    runtimeCatalog.models = [
+      {
+        id: "claude-sonnet",
+        providerId: "anthropic",
+        label: "Claude Sonnet",
+        available: true,
+      },
+      {
+        id: "claude-opus",
+        providerId: "anthropic",
+        label: "Claude Opus",
+        available: false,
+      },
+    ];
+
+    expect(getAiModelSelectionOptions("anthropic", null, runtimeCatalog)).toEqual([
+      expect.objectContaining({ value: AI_AUTO_MODEL_VALUE, label: "Auto · Claude Sonnet" }),
+      expect.objectContaining({ value: "claude-sonnet", label: "Claude Sonnet" }),
+      expect.objectContaining({ value: "claude-opus", label: "Claude Opus · connect to use" }),
+    ]);
+  });
+
+  test("replaces an unready configured provider with a ready one and clears its model", () => {
+    const providers = [
+      provider("anthropic", "not_authenticated"),
+      provider("openai-codex", "ready"),
+    ];
+
+    expect(resolveReadyAiRunnerDefault(providers, "claude", "claude-opus-4-8"))
+      .toEqual({ providerId: "openai-codex", modelId: null });
+  });
+
+  test("uses legacy aliases only when migrating defaults and model selections", () => {
+    const providers = [provider("anthropic", "ready")];
+
+    expect(resolveReadyAiRunnerDefault(providers, "claude", "claude-opus-4-8"))
+      .toEqual({ providerId: "anthropic", modelId: "claude-opus-4-8" });
+    expect(modelIdAfterAiProviderChange("anthropic", "claude", " claude-opus-4-8 "))
+      .toBe("claude-opus-4-8");
+    expect(modelIdAfterAiProviderChange("openai-codex", "claude", "claude-opus-4-8"))
+      .toBe("");
+  });
+
+  test("does not present a disconnected provider as ready", () => {
+    expect(isAiProviderReady(provider("anthropic", "not_authenticated"))).toBe(false);
+  });
+});

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

@@ -0,0 +1,193 @@
+import type { WizardStep } from "../../../types/plugin";
+import type { AiProvider } from "./providers";
+import {
+  getAiProviderUnavailableLabel,
+  migrateLegacyAiProviderId,
+  resolveDefaultAiProviderId,
+} from "./providers";
+import {
+  getAiRuntimeCatalog,
+  type AiRunOutputMode,
+  type AiRuntimeCatalog,
+} from "./runner";
+
+export const AI_AUTO_MODEL_VALUE = "__auto__";
+
+export interface AiRunnerSelectionScope {
+  outputMode?: AiRunOutputMode;
+  defaultProviderId?: string | null;
+  defaultModelId?: string | null;
+  runtimeCatalog?: AiRuntimeCatalog;
+}
+
+export interface AiRunnerDefault {
+  providerId: string;
+  modelId: string | null;
+}
+
+export interface AiModelSelectionOption {
+  value: string;
+  label: string;
+  description?: string;
+}
+
+export function isAiProviderReady(provider: AiProvider): boolean {
+  return provider.available && (provider.status === undefined || provider.status === "ready");
+}
+
+export function supportsAiRunOutputMode(
+  provider: AiProvider,
+  outputMode: AiRunOutputMode,
+  runtimeCatalog = getAiRuntimeCatalog(),
+): boolean {
+  const runtimeProvider = runtimeCatalog.providers.find((candidate) => (
+    candidate.providerId === provider.id
+  ));
+  return (runtimeProvider?.outputModes ?? provider.outputModes).includes(outputMode);
+}
+
+export function getSelectableAiRunners(
+  providers: readonly AiProvider[],
+  scope: AiRunnerSelectionScope = {},
+): AiProvider[] {
+  const outputMode = scope.outputMode ?? "plain";
+  const catalog = scope.runtimeCatalog ?? getAiRuntimeCatalog();
+  const capable = providers.filter((provider) => (
+    supportsAiRunOutputMode(provider, outputMode, catalog)
+  ));
+  return capable;
+}
+
+export function normalizeAiModelId(value: string | null | undefined): string | null {
+  const modelId = value?.trim() ?? "";
+  return modelId && modelId !== AI_AUTO_MODEL_VALUE ? modelId : null;
+}
+
+export function getAiModelSelectionOptions(
+  providerId: string,
+  currentModelId?: string | null,
+  runtimeCatalog = getAiRuntimeCatalog(),
+): AiModelSelectionOption[] {
+  const canonicalProviderId = migrateLegacyAiProviderId(providerId);
+  const provider = runtimeCatalog.providers.find((candidate) => (
+    candidate.providerId === canonicalProviderId
+  ));
+  const models = runtimeCatalog.models.filter((model) => (
+    model.providerId === canonicalProviderId
+  ));
+  const defaultModel = models.find((model) => model.id === provider?.defaultModelId);
+  const options: AiModelSelectionOption[] = [
+    {
+      value: AI_AUTO_MODEL_VALUE,
+      label: defaultModel
+        ? `Auto · ${defaultModel.label}`
+        : provider?.defaultModelId
+          ? `Auto · ${provider.defaultModelId}`
+          : "Auto · provider default",
+      description: "Use the provider's recommended model.",
+    },
+    ...models.map((model) => ({
+      value: model.id,
+      label: model.available ? model.label : `${model.label} · connect to use`,
+      description: model.available
+        ? "Available for the connected account."
+        : "This model becomes available after the provider is connected.",
+    })),
+  ];
+  const normalizedCurrent = normalizeAiModelId(currentModelId);
+  if (normalizedCurrent && !models.some((model) => model.id === normalizedCurrent)) {
+    options.push({
+      value: normalizedCurrent,
+      label: `${normalizedCurrent} · current`,
+      description: "Saved before the current Pi model catalog was loaded.",
+    });
+  }
+  return options;
+}
+
+export function getAiRunnerWizardModelKey(providerId: string): string {
+  return `modelId:${migrateLegacyAiProviderId(providerId)}`;
+}
+
+export function resolveAiRunnerWizardModel(
+  values: Record<string, string> | undefined,
+  providerId: string,
+  fallbackModelId?: string | null,
+): string | null {
+  const selected = values?.[getAiRunnerWizardModelKey(providerId)]
+    ?? values?.modelId
+    ?? fallbackModelId;
+  return normalizeAiModelId(selected);
+}
+
+export function modelIdAfterAiProviderChange(
+  providerId: string,
+  defaultProviderId: string,
+  defaultModelId: string | null | undefined,
+): string {
+  return migrateLegacyAiProviderId(providerId) === migrateLegacyAiProviderId(defaultProviderId)
+    ? normalizeAiModelId(defaultModelId) ?? ""
+    : "";
+}
+
+export function resolveReadyAiRunnerDefault(
+  providers: readonly AiProvider[],
+  configuredProviderId?: string | null,
+  configuredModelId?: string | null,
+): AiRunnerDefault {
+  const configuredId = migrateLegacyAiProviderId(configuredProviderId?.trim() ?? "");
+  const configured = providers.find((provider) => provider.id === configuredId);
+  const ready = providers.find(isAiProviderReady);
+  const providerId = configured && (isAiProviderReady(configured) || !ready)
+    ? configured.id
+    : ready?.id ?? resolveDefaultAiProviderId(providers);
+  return {
+    providerId,
+    modelId: providerId === configuredId ? normalizeAiModelId(configuredModelId) : null,
+  };
+}
+
+export function buildAiRunnerWizard(
+  providers: readonly AiProvider[],
+  scope: AiRunnerSelectionScope = {},
+): WizardStep[] {
+  const runners = getSelectableAiRunners(providers, scope);
+  const defaults = resolveReadyAiRunnerDefault(
+    runners,
+    scope.defaultProviderId,
+    scope.defaultModelId,
+  );
+  const runtimeCatalog = scope.runtimeCatalog ?? getAiRuntimeCatalog();
+  return [
+    {
+      key: "providerId",
+      label: "AI Provider",
+      type: "select",
+      defaultValue: defaults.providerId,
+      options: runners.map((provider) => ({
+        label: isAiProviderReady(provider)
+          ? provider.name
+          : `${provider.name} (${getAiProviderUnavailableLabel(provider)})`,
+        value: provider.id,
+      })),
+      body: ["Choose the AI provider for this conversation."],
+    },
+    ...runners.map((provider): WizardStep => {
+      const selectedModelId = provider.id === defaults.providerId ? defaults.modelId : null;
+      return {
+        key: getAiRunnerWizardModelKey(provider.id),
+        label: "AI Model",
+        type: "select",
+        required: true,
+        dependsOn: { key: "providerId", value: provider.id },
+        defaultValue: selectedModelId ?? AI_AUTO_MODEL_VALUE,
+        options: getAiModelSelectionOptions(provider.id, selectedModelId, runtimeCatalog),
+        body: ["Choose from the models published by Pi, or use the provider default."],
+      };
+    }),
+  ];
+}
+
+export function formatAiRunnerSelection(providerName: string, modelId: string | null | undefined): string {
+  return normalizeAiModelId(modelId) ? `${providerName} · ${normalizeAiModelId(modelId)}` : providerName;
+}