gloomberb 0.13.3 → 0.14.0

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

@@ -1,191 +0,0 @@
-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.
- */
-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: AiProviderId;
-  name: string;
-  available: boolean;
-  status: AiProviderStatus;
-  unavailableReason?: string;
-  outputModes: AiRunOutputMode[];
-  defaultModelId?: string;
-}
-
-const ALL_OUTPUT_MODES: readonly AiRunOutputMode[] = ["plain", "structured", "screener"];
-
-const PROVIDER_DEFINITIONS: readonly AiProviderDefinition[] = [
-  {
-    id: "anthropic",
-    name: "Claude",
-    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: "github-copilot",
-    name: "GitHub Copilot",
-    outputModes: ALL_OUTPUT_MODES,
-    preferredModelIds: ["gpt-5.6-sol", "claude-sonnet-5", "gpt-5.4"],
-  },
-  {
-    id: "xai",
-    name: "xAI / Grok",
-    outputModes: ALL_OUTPUT_MODES,
-    preferredModelIds: ["grok-4.6", "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;
-
-export function isAiProviderId(providerId: string): providerId is AiProviderId {
-  return (AI_PROVIDER_IDS as readonly string[]).includes(providerId);
-}
-
-export function migrateLegacyAiProviderId(providerId: string): string {
-  return LEGACY_AI_PROVIDER_ID_ALIASES[
-    providerId as keyof typeof LEGACY_AI_PROVIDER_ID_ALIASES
-  ] ?? providerId;
-}
-
-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,
-    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 getAiProvider(
-  providerId: string | null | undefined,
-  providers: readonly AiProvider[] = detectProviders(),
-): AiProvider | null {
-  if (!providerId) return null;
-  const canonicalId = migrateLegacyAiProviderId(providerId);
-  return providers.find((provider) => provider.id === canonicalId) ?? null;
-}
-
-export function resolveDefaultAiProviderId(
-  providers: readonly AiProvider[] = detectProviders(),
-): AiProviderId {
-  return providers.find((provider) => provider.status === "ready")?.id
-    ?? providers[0]?.id
-    ?? "anthropic";
-}
-
-export function getAiProviderUnavailableReason(provider: AiProvider): string {
-  return provider.unavailableReason ?? `${provider.name} is not connected.`;
-}
-
-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;
-}

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

@@ -1,174 +0,0 @@
-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

@@ -1,193 +0,0 @@
-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;
-}