@full-self-developing/fsd 1.0.0

package/extensions/ollama/src/web-search-provider.ts

@@ -0,0 +1,350 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
+import {
+  isNonSecretApiKeyMarker,
+  normalizeOptionalSecretInput,
+} from "openclaw/plugin-sdk/provider-auth";
+import { resolveEnvApiKey } from "openclaw/plugin-sdk/provider-auth-runtime";
+import {
+  enablePluginInConfig,
+  readNumberParam,
+  readResponseText,
+  readStringParam,
+  resolveProviderWebSearchPluginConfig,
+  resolveSearchCount,
+  resolveSiteName,
+  truncateText,
+  wrapWebContent,
+  type WebSearchProviderPlugin,
+} from "openclaw/plugin-sdk/provider-web-search";
+import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { Type } from "typebox";
+import { OLLAMA_DEFAULT_BASE_URL } from "./defaults.js";
+import { readProviderBaseUrl } from "./provider-base-url.js";
+import {
+  buildOllamaBaseUrlSsrFPolicy,
+  fetchOllamaModels,
+  resolveOllamaApiBase,
+} from "./provider-models.js";
+import { checkOllamaCloudAuth } from "./setup.js";
+
+const OLLAMA_WEB_SEARCH_SCHEMA = Type.Object(
+  {
+    query: Type.String({ description: "Search query string." }),
+    count: Type.Optional(
+      Type.Number({
+        description: "Number of results to return (1-10).",
+        minimum: 1,
+        maximum: 10,
+      }),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+const OLLAMA_HOSTED_WEB_SEARCH_PATH = "/api/web_search";
+const OLLAMA_LOCAL_WEB_SEARCH_PROXY_PATH = "/api/experimental/web_search";
+const OLLAMA_CLOUD_BASE_URL = "https://ollama.com";
+const DEFAULT_OLLAMA_WEB_SEARCH_COUNT = 5;
+const DEFAULT_OLLAMA_WEB_SEARCH_TIMEOUT_MS = 15_000;
+const OLLAMA_WEB_SEARCH_SNIPPET_MAX_CHARS = 300;
+
+type OllamaWebSearchResult = {
+  title?: string;
+  url?: string;
+  content?: string;
+};
+
+type OllamaWebSearchResponse = {
+  results?: OllamaWebSearchResult[];
+};
+
+type OllamaWebSearchAttempt = {
+  baseUrl: string;
+  path: string;
+  apiKey?: string;
+};
+
+async function readOllamaWebSearchResponse(response: Response): Promise<OllamaWebSearchResponse> {
+  try {
+    return (await response.json()) as OllamaWebSearchResponse;
+  } catch (cause) {
+    throw new Error("Ollama web search returned malformed JSON", { cause });
+  }
+}
+
+function isOllamaCloudBaseUrl(baseUrl: string): boolean {
+  try {
+    const parsed = new URL(baseUrl);
+    return parsed.protocol === "https:" && parsed.hostname === "ollama.com";
+  } catch {
+    return false;
+  }
+}
+
+function resolveConfiguredOllamaWebSearchApiKey(config?: OpenClawConfig): string | undefined {
+  const providerApiKey = normalizeOptionalSecretInput(config?.models?.providers?.ollama?.apiKey);
+  if (providerApiKey && !isNonSecretApiKeyMarker(providerApiKey)) {
+    return providerApiKey;
+  }
+  return undefined;
+}
+
+function resolveEnvOllamaWebSearchApiKey(): string | undefined {
+  return resolveEnvApiKey("ollama")?.apiKey;
+}
+
+function resolveOllamaWebSearchApiKey(config?: OpenClawConfig): string | undefined {
+  return resolveConfiguredOllamaWebSearchApiKey(config) ?? resolveEnvOllamaWebSearchApiKey();
+}
+
+function resolveOllamaWebSearchBaseUrl(config?: OpenClawConfig): string {
+  const pluginBaseUrl = normalizeOptionalString(
+    resolveProviderWebSearchPluginConfig(config, "ollama")?.baseUrl,
+  );
+  if (pluginBaseUrl) {
+    return resolveOllamaApiBase(pluginBaseUrl);
+  }
+  const configuredBaseUrl = readProviderBaseUrl(config?.models?.providers?.ollama);
+  if (configuredBaseUrl) {
+    return resolveOllamaApiBase(configuredBaseUrl);
+  }
+  return OLLAMA_DEFAULT_BASE_URL;
+}
+
+function normalizeOllamaWebSearchResult(
+  result: OllamaWebSearchResult,
+): { title: string; url: string; content: string } | null {
+  const url = normalizeOptionalString(result.url) ?? "";
+  if (!url) {
+    return null;
+  }
+  return {
+    title: normalizeOptionalString(result.title) ?? "",
+    url,
+    content: normalizeOptionalString(result.content) ?? "",
+  };
+}
+
+function buildOllamaWebSearchAttempts(params: {
+  baseUrl: string;
+  configuredApiKey?: string;
+  envApiKey?: string;
+}): OllamaWebSearchAttempt[] {
+  if (isOllamaCloudBaseUrl(params.baseUrl)) {
+    return [
+      {
+        baseUrl: params.baseUrl,
+        path: OLLAMA_HOSTED_WEB_SEARCH_PATH,
+        apiKey: params.configuredApiKey ?? params.envApiKey,
+      },
+    ];
+  }
+
+  const attempts: OllamaWebSearchAttempt[] = [
+    {
+      baseUrl: params.baseUrl,
+      path: OLLAMA_LOCAL_WEB_SEARCH_PROXY_PATH,
+      apiKey: params.configuredApiKey,
+    },
+    {
+      baseUrl: params.baseUrl,
+      path: OLLAMA_HOSTED_WEB_SEARCH_PATH,
+      apiKey: params.configuredApiKey,
+    },
+  ];
+  if (params.envApiKey) {
+    attempts.push({
+      baseUrl: OLLAMA_CLOUD_BASE_URL,
+      path: OLLAMA_HOSTED_WEB_SEARCH_PATH,
+      apiKey: params.envApiKey,
+    });
+  }
+  return attempts;
+}
+
+export async function runOllamaWebSearch(params: {
+  config?: OpenClawConfig;
+  query: string;
+  count?: number;
+}): Promise<Record<string, unknown>> {
+  const query = params.query.trim();
+  if (!query) {
+    throw new Error("query parameter is required");
+  }
+
+  const baseUrl = resolveOllamaWebSearchBaseUrl(params.config);
+  const configuredApiKey = resolveConfiguredOllamaWebSearchApiKey(params.config);
+  const envApiKey = resolveEnvOllamaWebSearchApiKey();
+  const count = resolveSearchCount(params.count, DEFAULT_OLLAMA_WEB_SEARCH_COUNT);
+  const startedAt = Date.now();
+  const body = JSON.stringify({ query, max_results: count });
+  const attempts = buildOllamaWebSearchAttempts({ baseUrl, configuredApiKey, envApiKey });
+
+  let payload: OllamaWebSearchResponse | undefined;
+  let lastError: Error | undefined;
+  for (const attempt of attempts) {
+    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    if (attempt.apiKey) {
+      headers.Authorization = `Bearer ${attempt.apiKey}`;
+    }
+    const { response, release } = await fetchWithSsrFGuard({
+      url: `${attempt.baseUrl}${attempt.path}`,
+      init: {
+        method: "POST",
+        headers,
+        body,
+        signal: AbortSignal.timeout(DEFAULT_OLLAMA_WEB_SEARCH_TIMEOUT_MS),
+      },
+      policy: buildOllamaBaseUrlSsrFPolicy(attempt.baseUrl),
+      auditContext: "ollama-web-search.search",
+    });
+
+    try {
+      if (response.status === 401) {
+        throw new Error("Ollama web search authentication failed. Run `ollama signin`.");
+      }
+      if (response.status === 403) {
+        throw new Error(
+          "Ollama web search is unavailable. Ensure cloud-backed web search is enabled on the Ollama host.",
+        );
+      }
+      if (!response.ok) {
+        const detail = await readResponseText(response, { maxBytes: 64_000 });
+        const message =
+          `Ollama web search failed (${response.status}): ${detail.text || ""}`.trim();
+        if (response.status === 404) {
+          lastError = new Error(message);
+          continue;
+        }
+        throw new Error(message);
+      }
+      payload = await readOllamaWebSearchResponse(response);
+      break;
+    } catch (error) {
+      if (error instanceof Error) {
+        lastError = error;
+      } else {
+        lastError = new Error(String(error));
+      }
+      throw lastError;
+    } finally {
+      await release();
+    }
+  }
+
+  if (!payload) {
+    throw lastError ?? new Error("Ollama web search failed");
+  }
+
+  const results = Array.isArray(payload.results)
+    ? payload.results
+        .map(normalizeOllamaWebSearchResult)
+        .filter((result): result is NonNullable<typeof result> => result !== null)
+        .slice(0, count)
+    : [];
+
+  return {
+    query,
+    provider: "ollama",
+    count: results.length,
+    tookMs: Date.now() - startedAt,
+    externalContent: {
+      untrusted: true,
+      source: "web_search",
+      provider: "ollama",
+      wrapped: true,
+    },
+    results: results.map((result) => {
+      const snippet = truncateText(result.content, OLLAMA_WEB_SEARCH_SNIPPET_MAX_CHARS).text;
+      return {
+        title: result.title ? wrapWebContent(result.title, "web_search") : "",
+        url: result.url,
+        snippet: snippet ? wrapWebContent(snippet, "web_search") : "",
+        siteName: resolveSiteName(result.url) || undefined,
+      };
+    }),
+  };
+}
+
+async function warnOllamaWebSearchPrereqs(params: {
+  config: OpenClawConfig;
+  prompter: {
+    note: (message: string, title?: string) => Promise<void>;
+  };
+}): Promise<OpenClawConfig> {
+  const baseUrl = resolveOllamaWebSearchBaseUrl(params.config);
+  const { reachable } = await fetchOllamaModels(baseUrl);
+  if (!reachable) {
+    await params.prompter.note(
+      [
+        "Ollama Web Search requires Ollama to be running.",
+        `Expected host: ${baseUrl}`,
+        "Start Ollama before using this provider.",
+      ].join("\n"),
+      "Ollama Web Search",
+    );
+    return params.config;
+  }
+
+  const auth = await checkOllamaCloudAuth(baseUrl);
+  if (!auth.signedIn) {
+    await params.prompter.note(
+      [
+        "Ollama Web Search requires `ollama signin`.",
+        ...(auth.signinUrl ? [auth.signinUrl] : ["Run `ollama signin`."]),
+      ].join("\n"),
+      "Ollama Web Search",
+    );
+  }
+
+  return params.config;
+}
+
+export function createOllamaWebSearchProvider(): WebSearchProviderPlugin {
+  return {
+    id: "ollama",
+    label: "Ollama Web Search",
+    hint: "Local Ollama host · requires ollama signin",
+    onboardingScopes: ["text-inference"],
+    requiresCredential: false,
+    envVars: [],
+    placeholder: "(run ollama signin)",
+    signupUrl: "https://ollama.com/",
+    docsUrl: "https://docs.openclaw.ai/tools/web",
+    autoDetectOrder: 110,
+    credentialPath: "",
+    getCredentialValue: () => undefined,
+    setCredentialValue: () => {},
+    applySelectionConfig: (config) => enablePluginInConfig(config, "ollama").config,
+    runSetup: async (ctx) =>
+      await warnOllamaWebSearchPrereqs({
+        config: ctx.config,
+        prompter: ctx.prompter,
+      }),
+    createTool: (ctx) => ({
+      description:
+        "Search the web using Ollama's web search API. Returns titles, URLs, and snippets from the configured Ollama host.",
+      parameters: OLLAMA_WEB_SEARCH_SCHEMA,
+      execute: async (args) =>
+        await runOllamaWebSearch({
+          config: ctx.config,
+          query: readStringParam(args, "query", { required: true }),
+          count: readNumberParam(args, "count", { integer: true }),
+        }),
+    }),
+  };
+}
+
+export const testing = {
+  buildOllamaWebSearchAttempts,
+  normalizeOllamaWebSearchResult,
+  resolveConfiguredOllamaWebSearchApiKey,
+  resolveEnvOllamaWebSearchApiKey,
+  resolveOllamaWebSearchApiKey,
+  resolveOllamaWebSearchBaseUrl,
+  isOllamaCloudBaseUrl,
+  readOllamaWebSearchResponse,
+  warnOllamaWebSearchPrereqs,
+};
+export { testing as __testing };

package/extensions/ollama/src/wsl2-crash-loop-check.test.ts

@@ -0,0 +1,157 @@
+import { promisify } from "node:util";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { isWSL2SyncMock } = vi.hoisted(() => ({
+  isWSL2SyncMock: vi.fn(() => false),
+}));
+
+vi.mock("openclaw/plugin-sdk/runtime-env", () => ({
+  isWSL2Sync: isWSL2SyncMock,
+}));
+
+vi.mock("node:fs/promises", () => ({
+  access: vi.fn(),
+}));
+
+vi.mock("node:child_process", async () => {
+  const { promisify: realPromisify } = await import("node:util");
+  const mockExecFile = vi.fn();
+  const execFilePromise = vi.fn();
+  (mockExecFile as unknown as Record<symbol, unknown>)[realPromisify.custom] = execFilePromise;
+  return { execFile: mockExecFile };
+});
+
+import { execFile } from "node:child_process";
+import { access } from "node:fs/promises";
+import {
+  checkWsl2CrashLoopRisk,
+  hasWslCuda,
+  isOllamaEnabledWithRestartAlways,
+  parseSystemctlShowProperties,
+} from "./wsl2-crash-loop-check.js";
+
+const accessMock = vi.mocked(access);
+const execFileMock = execFile as unknown as ReturnType<typeof vi.fn> & {
+  [key: symbol]: ReturnType<typeof vi.fn>;
+};
+const execFilePromiseMock = vi.mocked(execFileMock[promisify.custom]);
+
+function createLogger() {
+  return {
+    debug: vi.fn(),
+    error: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+  };
+}
+
+function mockSystemctl(stdout: string): void {
+  execFilePromiseMock.mockResolvedValue({ stdout, stderr: "" });
+}
+
+describe("wsl2 crash-loop check", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    isWSL2SyncMock.mockReturnValue(false);
+  });
+
+  it("parses systemctl show properties", () => {
+    expect(
+      parseSystemctlShowProperties("UnitFileState=enabled\nRestart=always\nIgnoredLine\n"),
+    ).toEqual(
+      new Map([
+        ["UnitFileState", "enabled"],
+        ["Restart", "always"],
+      ]),
+    );
+  });
+
+  it("detects enabled Restart=always ollama service", async () => {
+    mockSystemctl("UnitFileState=enabled\nRestart=always\n");
+
+    await expect(isOllamaEnabledWithRestartAlways()).resolves.toBe(true);
+
+    expect(execFilePromiseMock).toHaveBeenCalledWith(
+      "systemctl",
+      ["show", "ollama.service", "--property=UnitFileState,Restart", "--no-pager"],
+      { timeout: 5000 },
+    );
+  });
+
+  it("does not treat enabled-runtime as persistent autostart", async () => {
+    mockSystemctl("UnitFileState=enabled-runtime\nRestart=always\n");
+
+    await expect(isOllamaEnabledWithRestartAlways()).resolves.toBe(false);
+  });
+
+  it("requires Restart=always", async () => {
+    mockSystemctl("UnitFileState=enabled\nRestart=on-failure\n");
+
+    await expect(isOllamaEnabledWithRestartAlways()).resolves.toBe(false);
+  });
+
+  it("returns false when systemctl is unavailable", async () => {
+    execFilePromiseMock.mockRejectedValue(new Error("systemd unavailable"));
+
+    await expect(isOllamaEnabledWithRestartAlways()).resolves.toBe(false);
+  });
+
+  it("detects CUDA from the first available WSL marker", async () => {
+    accessMock.mockResolvedValueOnce(undefined);
+
+    await expect(hasWslCuda()).resolves.toBe(true);
+    expect(accessMock).toHaveBeenCalledWith("/dev/dxg");
+  });
+
+  it("checks the remaining CUDA markers before returning false", async () => {
+    accessMock.mockRejectedValue(new Error("missing"));
+
+    await expect(hasWslCuda()).resolves.toBe(false);
+    expect(accessMock).toHaveBeenCalledTimes(4);
+  });
+
+  it("warns for WSL2 plus Ollama autostart plus CUDA", async () => {
+    isWSL2SyncMock.mockReturnValue(true);
+    mockSystemctl("UnitFileState=enabled\nRestart=always\n");
+    accessMock.mockResolvedValueOnce(undefined);
+    const logger = createLogger();
+
+    await checkWsl2CrashLoopRisk(logger);
+
+    expect(logger.warn).toHaveBeenCalledTimes(1);
+    const message = String(logger.warn.mock.calls.at(0)?.[0]);
+    expect(message).toContain("WSL2 crash-loop risk");
+    expect(message).toContain("sudo systemctl disable ollama");
+    expect(message).toContain("autoMemoryReclaim=disabled");
+    expect(message).toContain("OLLAMA_KEEP_ALIVE=5m");
+  });
+
+  it("does not probe systemd outside WSL2", async () => {
+    const logger = createLogger();
+
+    await checkWsl2CrashLoopRisk(logger);
+
+    expect(execFilePromiseMock).not.toHaveBeenCalled();
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  it("does not warn when CUDA is not visible", async () => {
+    isWSL2SyncMock.mockReturnValue(true);
+    mockSystemctl("UnitFileState=enabled\nRestart=always\n");
+    accessMock.mockRejectedValue(new Error("missing"));
+    const logger = createLogger();
+
+    await checkWsl2CrashLoopRisk(logger);
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  it("never throws from advisory checks", async () => {
+    isWSL2SyncMock.mockReturnValue(true);
+    execFilePromiseMock.mockRejectedValue(new Error("boom"));
+    const logger = createLogger();
+
+    await expect(checkWsl2CrashLoopRisk(logger)).resolves.toBeUndefined();
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+});

package/extensions/ollama/src/wsl2-crash-loop-check.ts

@@ -0,0 +1,84 @@
+import { execFile } from "node:child_process";
+import { access } from "node:fs/promises";
+import { promisify } from "node:util";
+import type { PluginLogger } from "openclaw/plugin-sdk/plugin-entry";
+import { isWSL2Sync } from "openclaw/plugin-sdk/runtime-env";
+
+const execFileAsync = promisify(execFile);
+const SYSTEMCTL_TIMEOUT_MS = 5_000;
+const WSL_CUDA_MARKERS = [
+  "/dev/dxg",
+  "/usr/lib/wsl/lib/nvidia-smi",
+  "/usr/lib/wsl/lib/libcuda.so.1",
+  "/usr/local/cuda",
+];
+
+export function parseSystemctlShowProperties(stdout: string): Map<string, string> {
+  const properties = new Map<string, string>();
+  for (const line of stdout.split(/\r?\n/u)) {
+    const separator = line.indexOf("=");
+    if (separator <= 0) {
+      continue;
+    }
+    properties.set(line.slice(0, separator), line.slice(separator + 1));
+  }
+  return properties;
+}
+
+export async function isOllamaEnabledWithRestartAlways(): Promise<boolean> {
+  try {
+    const { stdout } = await execFileAsync(
+      "systemctl",
+      ["show", "ollama.service", "--property=UnitFileState,Restart", "--no-pager"],
+      { timeout: SYSTEMCTL_TIMEOUT_MS },
+    );
+    const properties = parseSystemctlShowProperties(stdout);
+    return properties.get("UnitFileState") === "enabled" && properties.get("Restart") === "always";
+  } catch {
+    return false;
+  }
+}
+
+export async function hasWslCuda(): Promise<boolean> {
+  for (const marker of WSL_CUDA_MARKERS) {
+    try {
+      await access(marker);
+      return true;
+    } catch {
+      // Try the next cheap marker.
+    }
+  }
+  return false;
+}
+
+export async function checkWsl2CrashLoopRisk(logger: PluginLogger): Promise<void> {
+  try {
+    if (!isWSL2Sync()) {
+      return;
+    }
+    if (!(await isOllamaEnabledWithRestartAlways())) {
+      return;
+    }
+    if (!(await hasWslCuda())) {
+      return;
+    }
+
+    logger.warn(
+      [
+        "[ollama] WSL2 crash-loop risk: ollama.service is enabled with Restart=always and CUDA is visible.",
+        "On WSL2, GPU-backed Ollama can pin host memory while loading a model.",
+        "Hyper-V memory reclaim cannot always reclaim those pinned pages, so Windows can terminate and restart the WSL2 VM.",
+        "",
+        "Common evidence: repeated WSL2 reboots, high CPU in app.slice at startup, and SIGTERM from systemd rather than the Linux OOM killer.",
+        "See: https://github.com/ollama/ollama/issues/11317",
+        "",
+        "Mitigation:",
+        "  1. Disable autostart: sudo systemctl disable ollama",
+        "  2. Add [experimental] autoMemoryReclaim=disabled to %USERPROFILE%\\.wslconfig on Windows, then run wsl --shutdown",
+        "  3. Set OLLAMA_KEEP_ALIVE=5m in the Ollama service environment or start ollama serve manually when needed",
+      ].join("\n"),
+    );
+  } catch {
+    // Advisory only: never break provider registration or model discovery.
+  }
+}

package/extensions/ollama/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.package-boundary.base.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./*.ts", "./src/**/*.ts"],
+  "exclude": [
+    "./**/*.test.ts",
+    "./dist/**",
+    "./node_modules/**",
+    "./src/test-support/**",
+    "./src/**/*test-helpers.ts",
+    "./src/**/*test-harness.ts",
+    "./src/**/*test-support.ts"
+  ]
+}

package/extensions/ollama/web-search-contract-api.ts

@@ -0,0 +1,26 @@
+import {
+  createWebSearchProviderContractFields,
+  type WebSearchProviderPlugin,
+} from "openclaw/plugin-sdk/provider-web-search-contract";
+
+export function createOllamaWebSearchProvider(): WebSearchProviderPlugin {
+  return {
+    id: "ollama",
+    label: "Ollama Web Search",
+    hint: "Local Ollama host · requires ollama signin",
+    onboardingScopes: ["text-inference"],
+    requiresCredential: false,
+    envVars: [],
+    placeholder: "(run ollama signin)",
+    signupUrl: "https://ollama.com/",
+    docsUrl: "https://docs.openclaw.ai/tools/web",
+    autoDetectOrder: 110,
+    credentialPath: "",
+    ...createWebSearchProviderContractFields({
+      credentialPath: "",
+      searchCredential: { type: "none" },
+      selectionPluginId: "ollama",
+    }),
+    createTool: () => null,
+  };
+}

package/extensions/ollama/web-search-provider.ts

@@ -0,0 +1 @@
+export { createOllamaWebSearchProvider } from "./src/web-search-provider.js";

package/extensions/openai/api.ts

@@ -0,0 +1,16 @@
+export {
+  applyOpenAIConfig,
+  applyOpenAIProviderConfig,
+  OPENAI_CODEX_DEFAULT_MODEL,
+  OPENAI_DEFAULT_AUDIO_TRANSCRIPTION_MODEL,
+  OPENAI_DEFAULT_EMBEDDING_MODEL,
+  OPENAI_DEFAULT_IMAGE_MODEL,
+  OPENAI_DEFAULT_MODEL,
+  OPENAI_DEFAULT_TTS_MODEL,
+  OPENAI_DEFAULT_TTS_VOICE,
+} from "./default-models.js";
+export { buildOpenAICodexProvider } from "./openai-codex-catalog.js";
+export { buildOpenAICodexProviderPlugin } from "./openai-codex-provider.js";
+export { buildOpenAIProvider } from "./openai-provider.js";
+export { buildOpenAIRealtimeTranscriptionProvider } from "./realtime-transcription-provider.js";
+export { buildOpenAIRealtimeVoiceProvider } from "./realtime-voice-provider.js";

package/extensions/openai/auth-choice-copy.ts

@@ -0,0 +1,33 @@
+export const OPENAI_API_KEY_LABEL = "OpenAI API Key";
+export const OPENAI_CHATGPT_LOGIN_LABEL = "ChatGPT Login";
+export const OPENAI_CHATGPT_LOGIN_HINT = "Sign in with your ChatGPT or Codex subscription";
+export const OPENAI_CHATGPT_DEVICE_PAIRING_LABEL = "ChatGPT Device Pairing";
+export const OPENAI_CHATGPT_DEVICE_PAIRING_HINT =
+  "Pair your ChatGPT account in browser with a device code";
+export const OPENAI_CODEX_API_KEY_BACKUP_LABEL = "OpenAI API Key Backup";
+export const OPENAI_CODEX_API_KEY_BACKUP_HINT =
+  "Use an OpenAI API key when your Codex subscription is unavailable";
+export const OPENAI_CODEX_LOGIN_LABEL = "ChatGPT/Codex Browser Login";
+export const OPENAI_CODEX_LOGIN_HINT = "Sign in with OpenAI in your browser";
+export const OPENAI_CODEX_DEVICE_PAIRING_LABEL = "ChatGPT/Codex Device Pairing";
+export const OPENAI_CODEX_DEVICE_PAIRING_HINT = "Pair in browser with a device code";
+
+const OPENAI_UNIFIED_GROUP_HINT = "ChatGPT/Codex sign-in or API key";
+
+export const OPENAI_API_KEY_WIZARD_GROUP = {
+  groupId: "openai",
+  groupLabel: "OpenAI",
+  groupHint: "Direct API key",
+} as const;
+
+export const OPENAI_ACCOUNT_WIZARD_GROUP = {
+  groupId: "openai",
+  groupLabel: "OpenAI",
+  groupHint: OPENAI_UNIFIED_GROUP_HINT,
+} as const;
+
+export const OPENAI_CODEX_WIZARD_GROUP = {
+  groupId: "openai",
+  groupLabel: "OpenAI",
+  groupHint: OPENAI_UNIFIED_GROUP_HINT,
+} as const;