aisubs 0.3.7 → 0.3.8

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.3.8 - 2026-09-19
+
+- Breaking: `createSubscriptionAuth` now requires an explicit credential store.
+- Breaking: provider factories use the `aisubs/providers/*` entrypoints so the core `aisubs` import stays runtime-portable.
+- Add `aisubs/node` SQLite credential and API-key stores with shared-connection support and cross-process refresh ownership.
+- Persist standalone AISubs records in `~/.aisubs/aisubs.db` without retaining the legacy file-store implementation.
+
 ## 0.3.7 - 2026-09-16
 
 - Improve provider compatibility, proxy handling, and request normalization.

package/README.md

@@ -438,9 +438,14 @@ bun add aisubs
 ```
 
 ```js
-import { chatGptProvider, createSubscriptionAuth } from "aisubs";
+import { createSubscriptionAuth } from "aisubs";
+import { SqliteCredentialStore } from "aisubs/node";
+import { chatGptProvider } from "aisubs/providers/chatgpt";
 
-const subscriptions = createSubscriptionAuth({ providers: [chatGptProvider()] });
+const subscriptions = createSubscriptionAuth({
+  store: new SqliteCredentialStore("./data/aisubs.db"),
+  providers: [chatGptProvider()],
+});
 const account = subscriptions.account("chatgpt", "personal");
 
 if (!(await account.status()).authenticated) {
@@ -493,19 +498,16 @@ Useful account methods:
 <summary><strong>Configure every provider and custom credential storage</strong></summary>
 
 ```js
-import {
-  FileCredentialStore,
-  chatGptProvider,
-  claudeProvider,
-  copilotProvider,
-  createSubscriptionAuth,
-  grokProvider,
-  openCodeGoProvider,
-  openCodeZenProvider,
-} from "aisubs";
+import { createSubscriptionAuth } from "aisubs";
+import { SqliteCredentialStore } from "aisubs/node";
+import { chatGptProvider } from "aisubs/providers/chatgpt";
+import { claudeProvider } from "aisubs/providers/claude";
+import { copilotProvider } from "aisubs/providers/copilot";
+import { grokProvider } from "aisubs/providers/grok";
+import { openCodeGoProvider, openCodeZenProvider } from "aisubs/providers/opencode";
 
 const subscriptions = createSubscriptionAuth({
-  store: new FileCredentialStore("./data/aisubs-credentials.json"),
+  store: new SqliteCredentialStore("./data/aisubs.db"),
   providers: [
     chatGptProvider(),
     claudeProvider(),
@@ -517,9 +519,10 @@ const subscriptions = createSubscriptionAuth({
 });
 ```
 
-Without a custom store, credentials are saved to
-`~/.aisubs/credentials.json`. Select an account with its provider ID and a
-local account name:
+Storage is always explicit. The core SDK never discovers a home directory,
+creates files, starts a server, or opens a browser. The standalone CLI composes
+the SQLite adapter at `~/.aisubs/aisubs.db`. Select an account with its provider
+ID and a local account name:
 
 ```js
 const chatgpt = subscriptions.account("chatgpt", "personal");
@@ -596,25 +599,23 @@ const response = await selected.proxy("responses", requestOptions);
 <summary><strong>Run the local HTTP server from Node.js</strong></summary>
 
 This is the programmatic equivalent of `aisubs dashboard`. The API key is
-created once and reused across restarts; delete or regenerate the key file only
-when clients should receive a new key.
+created once and reused across restarts; regenerate it when clients should
+receive a new key.
 
 ```js
 import { homedir } from "node:os";
 import { join } from "node:path";
-import {
-  FileApiKeyStore,
-  FileCredentialStore,
-  chatGptProvider,
-  claudeProvider,
-  createSubscriptionAuth,
-} from "aisubs";
+import { createSubscriptionAuth } from "aisubs";
 import { createSubscriptionAuthServer } from "aisubs/http";
+import { SqliteApiKeyStore, SqliteCredentialStore } from "aisubs/node";
+import { chatGptProvider } from "aisubs/providers/chatgpt";
+import { claudeProvider } from "aisubs/providers/claude";
 
 const directory = join(homedir(), ".aisubs");
-const apiKey = await new FileApiKeyStore(join(directory, "api-key")).readOrCreate();
+const database = join(directory, "aisubs.db");
+const apiKey = await new SqliteApiKeyStore(database).readOrCreate();
 const auth = createSubscriptionAuth({
-  store: new FileCredentialStore(join(directory, "credentials.json")),
+  store: new SqliteCredentialStore(database),
   providers: [chatGptProvider(), claudeProvider()],
 });
 
@@ -674,8 +675,7 @@ the old key.
 
 ## Storage and security
 
-- Credentials: `~/.aisubs/credentials.json`.
-- Persistent local API key: `~/.aisubs/api-key`.
+- Credentials and persistent local API key: `~/.aisubs/aisubs.db`.
 - Optional Codex catalog: `~/.codex/aisubs-catalog.json`.
 - Codex integration stores the local AISubs key in the user-private Codex config.
 - State directories and files use private permissions where the platform supports them.

package/dist/auth.d.ts

@@ -29,6 +29,7 @@ export declare class SubscriptionAuth {
     private readonly attempts;
     private readonly generations;
     private readonly refreshes;
+    private readonly coordinatedRefreshes;
     private readonly usageCache;
     private readonly modelsCache;
     private readonly usageInflight;
@@ -62,6 +63,7 @@ export declare class SubscriptionAuth {
     listAccounts(provider: ProviderId): Promise<Session[]>;
     signOut(provider: ProviderId, account?: string): Promise<void>;
     private credential;
+    private coordinatedCredential;
     getAccessToken(provider: ProviderId, account?: string): Promise<string>;
     credentialSummary(provider: ProviderId, account?: string): Promise<CredentialSummary>;
     details(provider: ProviderId, account?: string, signal?: AbortSignal): Promise<SubscriptionAccountDetails>;
@@ -74,6 +76,6 @@ export declare class SubscriptionAuth {
     account(provider: ProviderId, account: string): SubscriptionAccount;
 }
 export declare function createSubscriptionAuth(options: {
-    store?: CredentialStore;
+    store: CredentialStore;
     providers: readonly ProviderAdapter[];
 } & SubscriptionAuthOptions): SubscriptionAuth;

package/dist/auth.js

@@ -1,9 +1,13 @@
-import { defaultAiSubsDataDir, FileCredentialStore } from "./store.js";
 import { errorMessage } from "./utils.js";
-import { join } from "node:path";
 export const DEFAULT_ACCOUNT = "default";
 const ACCOUNT_STORAGE_PREFIX = "$subscription-account$";
 const LOGIN_ATTEMPT_RETENTION_MS = 5 * 60_000;
+function isCoordinatedStore(store) {
+    return ("readVersioned" in store &&
+        "replaceCredential" in store &&
+        "claimRefresh" in store &&
+        "commitRefresh" in store);
+}
 function normalizeAccountKey(value) {
     if (value == null)
         return DEFAULT_ACCOUNT;
@@ -63,6 +67,7 @@ export class SubscriptionAuth {
     attempts = new Map();
     generations = new Map();
     refreshes = new Map();
+    coordinatedRefreshes = new Map();
     usageCache = new Map();
     modelsCache = new Map();
     usageInflight = new Map();
@@ -157,7 +162,10 @@ export class SubscriptionAuth {
         const accountKey = normalizeAccountKey(options?.account);
         const scope = credentialKey(provider, accountKey);
         const replace = options?.replace !== false;
-        if (!replace && (await this.store.read(scope))) {
+        const durable = isCoordinatedStore(this.store)
+            ? await this.store.readVersioned(scope)
+            : undefined;
+        if (!replace && (durable?.credential ?? (await this.store.read(scope)))) {
             throw new Error(`Account name ${accountKey} is already connected for ${provider}`);
         }
         const epoch = this.advance(scope);
@@ -166,6 +174,7 @@ export class SubscriptionAuth {
                 this.cancelAttempt(attempt);
         }
         const abort = new AbortController();
+        const id = crypto.randomUUID();
         const providerOptions = { ...options };
         delete providerOptions.account;
         delete providerOptions.replace;
@@ -175,18 +184,31 @@ export class SubscriptionAuth {
             void login.complete.catch(() => { });
             throw new Error("Login cancelled");
         }
-        const id = crypto.randomUUID();
         let record;
         const promise = login.complete
             .then(async (credential) => {
-            const saved = await this.store.modify(scope, (current) => {
-                if (this.generation(scope) !== epoch)
-                    return current;
-                if (current && !replace) {
-                    throw new Error(`Account name ${accountKey} is already connected for ${provider}`);
-                }
-                return credential;
-            });
+            let saved;
+            if (isCoordinatedStore(this.store)) {
+                const replacement = await this.store.replaceCredential({
+                    provider: scope,
+                    credential,
+                    expectedGeneration: durable?.generation ?? 0,
+                    operationId: `login:${id}`,
+                });
+                if (!replacement.applied)
+                    throw new Error("Login cancelled");
+                saved = replacement.record.credential;
+            }
+            else {
+                saved = await this.store.modify(scope, (current) => {
+                    if (this.generation(scope) !== epoch)
+                        return current;
+                    if (current && !replace) {
+                        throw new Error(`Account name ${accountKey} is already connected for ${provider}`);
+                    }
+                    return credential;
+                });
+            }
             if (this.generation(scope) !== epoch || !saved)
                 throw new Error("Login cancelled");
             this.clearMetadata(scope);
@@ -290,12 +312,31 @@ export class SubscriptionAuth {
             if (attempt.scope === scope)
                 this.cancelAttempt(attempt);
         }
-        await this.store.delete(scope);
+        if (isCoordinatedStore(this.store)) {
+            await this.store.deleteCredential({
+                provider: scope,
+                operationId: `logout:${crypto.randomUUID()}`,
+            });
+        }
+        else {
+            await this.store.delete(scope);
+        }
     }
     async credential(provider, account, forceRefresh = false) {
         const adapter = this.adapter(provider);
         const accountKey = normalizeAccountKey(account);
         const scope = credentialKey(provider, accountKey);
+        if (isCoordinatedStore(this.store)) {
+            const pending = this.coordinatedRefreshes.get(scope);
+            if (pending)
+                return pending;
+            const operation = this.coordinatedCredential(this.store, adapter, provider, accountKey, scope, forceRefresh).finally(() => {
+                if (this.coordinatedRefreshes.get(scope) === operation)
+                    this.coordinatedRefreshes.delete(scope);
+            });
+            this.coordinatedRefreshes.set(scope, operation);
+            return operation;
+        }
         const observed = await this.store.read(scope);
         if (!observed)
             throw new Error(`Not authenticated with ${provider} account ${accountKey}`);
@@ -350,6 +391,74 @@ export class SubscriptionAuth {
         this.clearMetadata(scope);
         return refreshed;
     }
+    async coordinatedCredential(store, adapter, provider, accountKey, scope, forceRefresh) {
+        const observed = await store.readVersioned(scope);
+        const credential = observed.credential;
+        if (!credential)
+            throw new Error(`Not authenticated with ${provider} account ${accountKey}`);
+        if (credential.metadata?.reauthRequired === true) {
+            throw new Error(`Session expired for ${provider} account ${accountKey}; sign in again`);
+        }
+        if (!forceRefresh && credential.expiresAt > Date.now())
+            return credential;
+        const claimId = crypto.randomUUID();
+        const claim = await store.claimRefresh({
+            provider: scope,
+            expectedVersion: observed.version,
+            expectedGeneration: observed.generation,
+            claimId,
+            operationId: `refresh-claim:${claimId}`,
+        });
+        if (claim === "missing") {
+            throw new Error(`Not authenticated with ${provider} account ${accountKey}`);
+        }
+        if (claim !== "claimed") {
+            const deadline = Date.now() + this.refreshTimeoutMs;
+            while (Date.now() < deadline) {
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                const latest = await store.readVersioned(scope);
+                if (latest.version === observed.version && latest.generation === observed.generation)
+                    continue;
+                if (!latest.credential || latest.credential.metadata?.reauthRequired === true)
+                    break;
+                if (latest.credential.expiresAt > Date.now())
+                    return latest.credential;
+                break;
+            }
+            throw new Error(`Refresh outcome is uncertain for ${provider} account ${accountKey}; sign in again`);
+        }
+        let next;
+        try {
+            next = await adapter.refresh(credential, AbortSignal.timeout(this.refreshTimeoutMs));
+        }
+        catch (error) {
+            if (!adapter.isPermanentRefreshError?.(error))
+                throw error;
+            next = {
+                accessToken: "",
+                expiresAt: 0,
+                account: credential.account,
+                metadata: { ...credential.metadata, reauthRequired: true },
+            };
+        }
+        const committed = await store.commitRefresh({
+            provider: scope,
+            claimId,
+            expectedGeneration: observed.generation,
+            credential: next,
+            operationId: `refresh-commit:${claimId}`,
+        });
+        if (!committed.applied) {
+            throw new Error(`Session changed while refreshing ${provider} account ${accountKey}`);
+        }
+        const saved = committed.record.credential;
+        if (!saved || saved.metadata?.reauthRequired === true) {
+            this.clearMetadata(scope);
+            throw new Error(`Session expired for ${provider} account ${accountKey}; sign in again`);
+        }
+        this.clearMetadata(scope);
+        return saved;
+    }
     async getAccessToken(provider, account = DEFAULT_ACCOUNT) {
         const credential = await this.credential(provider, account);
         if (credential.metadata?.delegatedCli === true) {
@@ -512,6 +621,5 @@ export class SubscriptionAuth {
     }
 }
 export function createSubscriptionAuth(options) {
-    const store = options.store ?? new FileCredentialStore(join(defaultAiSubsDataDir(), "credentials.json"));
-    return new SubscriptionAuth(store, options.providers, options);
+    return new SubscriptionAuth(options.store, options.providers, options);
 }

package/dist/cli.js

@@ -8,7 +8,8 @@ import { claudeProvider } from "./providers/claude.js";
 import { copilotProvider } from "./providers/copilot.js";
 import { grokProvider } from "./providers/grok.js";
 import { openCodeGoProvider, openCodeZenProvider } from "./providers/opencode.js";
-import { defaultAiSubsDataDir, FileApiKeyStore, FileCredentialStore } from "./store.js";
+import { defaultAiSubsDataDir } from "./store.js";
+import { SqliteApiKeyStore, SqliteCredentialStore } from "./sqlite-store.js";
 const DEFAULT_DASHBOARD_PORT = 4319;
 function usage() {
     console.log(`AI Subs
@@ -61,8 +62,9 @@ async function main() {
     }
     if (!Number.isInteger(port) || port < 0 || port > 65535)
         throw new Error("Invalid port");
-    const store = new FileCredentialStore(join(dataDirectory, "credentials.json"));
-    const apiKeys = new FileApiKeyStore(join(dataDirectory, "api-key"));
+    const database = join(dataDirectory, "aisubs.db");
+    const store = new SqliteCredentialStore(database);
+    const apiKeys = new SqliteApiKeyStore(database);
     const auth = createSubscriptionAuth({
         store,
         providers: [

package/dist/http.js

@@ -112,6 +112,7 @@ function openAiModel(provider, model) {
         capabilities: {
             endpoints: model.endpoints ?? [],
             input_modalities: model.inputModalities ?? ["text"],
+            output_modalities: model.outputModalities ?? ["text"],
             reasoning_efforts: model.reasoningEfforts ?? [],
             tools: model.supportsToolCall ?? false,
         },

package/dist/index.d.ts

@@ -1,9 +1,4 @@
 export { createSubscriptionAuth, DEFAULT_ACCOUNT, SubscriptionAuth, type SubscriptionAccount, type SubscriptionAuthOptions, } from "./auth.js";
-export { defaultAiSubsDataDir, FileApiKeyStore, FileCredentialStore, MemoryCredentialStore, } from "./store.js";
-export { chatGptProvider, type ChatGptProviderOptions } from "./providers/chatgpt.js";
-export { claudeProvider, type ClaudeProviderOptions } from "./providers/claude.js";
-export { copilotProvider, type CopilotProviderOptions } from "./providers/copilot.js";
-export { grokProvider, type GrokProviderOptions } from "./providers/grok.js";
-export { openCodeGoProvider, openCodeZenProvider } from "./providers/opencode.js";
+export { MemoryCredentialStore } from "./memory-store.js";
 export { parseChatGptUsage, parseCopilotUsage, parseGrokUsage } from "./usage.js";
-export type { CredentialStore, CredentialSummary, BrowserLoginPrompt, DeviceLoginPrompt, ImmediateLoginPrompt, LoginAttempt, LoginMode, LoginPrompt, LoginState, OAuthCredential, ProviderAdapter, ProviderId, ProviderLogin, ProviderLoginField, ProviderModel, ProviderModels, ProviderSummary, ProviderUsage, ProviderUsageContext, ProviderUsageData, Session, SubscriptionAccountDetails, UsageFact, UsageMeter, UsageResetCredit, UsageResetCredits, } from "./types.js";
+export type { CredentialStore, CoordinatedCredentialStore, CredentialSummary, BrowserLoginPrompt, DeviceLoginPrompt, ImmediateLoginPrompt, LoginAttempt, LoginMode, LoginPrompt, LoginState, OAuthCredential, VersionedCredential, ProviderAdapter, ProviderId, ProviderLogin, ProviderLoginField, ProviderModel, ProviderModels, ProviderSummary, ProviderUsage, ProviderUsageContext, ProviderUsageData, Session, SubscriptionAccountDetails, UsageFact, UsageMeter, UsageResetCredit, UsageResetCredits, } from "./types.js";

package/dist/index.js

@@ -1,8 +1,3 @@
 export { createSubscriptionAuth, DEFAULT_ACCOUNT, SubscriptionAuth, } from "./auth.js";
-export { defaultAiSubsDataDir, FileApiKeyStore, FileCredentialStore, MemoryCredentialStore, } from "./store.js";
-export { chatGptProvider } from "./providers/chatgpt.js";
-export { claudeProvider } from "./providers/claude.js";
-export { copilotProvider } from "./providers/copilot.js";
-export { grokProvider } from "./providers/grok.js";
-export { openCodeGoProvider, openCodeZenProvider } from "./providers/opencode.js";
+export { MemoryCredentialStore } from "./memory-store.js";
 export { parseChatGptUsage, parseCopilotUsage, parseGrokUsage } from "./usage.js";

package/dist/memory-store.d.ts

@@ -0,0 +1,9 @@
+import type { CredentialStore, OAuthCredential, ProviderId } from "./types.js";
+export declare class MemoryCredentialStore implements CredentialStore {
+    private readonly values;
+    private readonly queues;
+    read(provider: ProviderId): Promise<OAuthCredential | null>;
+    listKeys(): Promise<string[]>;
+    modify(provider: ProviderId, update: (current: OAuthCredential | null) => OAuthCredential | null | Promise<OAuthCredential | null>): Promise<OAuthCredential | null>;
+    delete(provider: ProviderId): Promise<void>;
+}

package/dist/memory-store.js

@@ -0,0 +1,34 @@
+export class MemoryCredentialStore {
+    values = new Map();
+    queues = new Map();
+    async read(provider) {
+        return this.values.get(provider) ?? null;
+    }
+    async listKeys() {
+        return [...this.values.keys()];
+    }
+    async modify(provider, update) {
+        const previous = this.queues.get(provider) ?? Promise.resolve();
+        let result = null;
+        const current = previous.then(async () => {
+            result = await update(this.values.get(provider) ?? null);
+            if (result)
+                this.values.set(provider, result);
+            else
+                this.values.delete(provider);
+        });
+        const settled = current.catch(() => { });
+        this.queues.set(provider, settled);
+        try {
+            await current;
+        }
+        finally {
+            if (this.queues.get(provider) === settled)
+                this.queues.delete(provider);
+        }
+        return result;
+    }
+    async delete(provider) {
+        await this.modify(provider, () => null);
+    }
+}

package/dist/node.d.ts

@@ -0,0 +1,2 @@
+export { defaultAiSubsDataDir } from "./store.js";
+export { SqliteApiKeyStore, SqliteCredentialStore } from "./sqlite-store.js";

package/dist/node.js

@@ -0,0 +1,2 @@
+export { defaultAiSubsDataDir } from "./store.js";
+export { SqliteApiKeyStore, SqliteCredentialStore } from "./sqlite-store.js";

package/dist/providers/chatgpt.d.ts

@@ -1,4 +1,5 @@
-import type { ProviderAdapter } from "../types.js";
+import type { ProviderAdapter, ProviderModel } from "../types.js";
+export declare function parseOpenAiImageModels(html: string): ProviderModel[];
 export interface ChatGptProviderOptions {
     clientId?: string;
     compatibilityVersion?: string;

package/dist/providers/chatgpt.js

@@ -12,6 +12,7 @@ const VERIFICATION_URL = `${ISSUER}/codex/device`;
 const USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
 const MODELS_URL = "https://chatgpt.com/backend-api/codex/models";
+const OPENAI_MODELS_URL = "https://developers.openai.com/api/docs/models";
 const EXPIRY_SKEW_MS = 5 * 60_000;
 const BROWSER_LOGIN_TIMEOUT_MS = 10 * 60_000;
 const BROWSER_CALLBACK_PORTS = [1455, 1457];
@@ -84,6 +85,7 @@ function normalizeModel(value) {
         })
         : [];
     const visibility = stringValue(value.visibility);
+    const outputModalities = stringArray(value.output_modalities);
     return {
         id,
         name: stringValue(value.display_name) ?? stringValue(value.name),
@@ -92,12 +94,65 @@ function normalizeModel(value) {
         maxOutputTokens: numberValue(value.max_output_tokens),
         reasoningEfforts: levels.length ? levels : stringArray(value.supported_reasoning_efforts),
         inputModalities: stringArray(value.input_modalities),
-        endpoints: ["responses"],
+        outputModalities,
+        endpoints: outputModalities?.includes("image")
+            ? ["images/generations", "images/edits"]
+            : ["responses"],
         supportsToolCall: value.supports_tool_calls === false || value.supports_tools === false ? false : true,
         available: visibility !== "hide" && value.supported_in_api !== false,
         priority: numberValue(value.priority) ?? Number.MAX_SAFE_INTEGER,
     };
 }
+function imageModelName(id) {
+    const [prefix, suffix] = id.startsWith("chatgpt-image-")
+        ? ["ChatGPT Image", id.slice("chatgpt-image-".length)]
+        : id.startsWith("dall-e-")
+            ? ["DALL-E", id.slice("dall-e-".length)]
+            : ["GPT Image", id.slice("gpt-image-".length)];
+    const label = suffix
+        .split("-")
+        .map((part) => (/^[a-z]/.test(part) ? part[0].toUpperCase() + part.slice(1) : part))
+        .join(" ");
+    return `${prefix} ${label}`.trim();
+}
+export function parseOpenAiImageModels(html) {
+    const ids = new Set();
+    const links = html.matchAll(/href=["'](?:https:\/\/developers\.openai\.com)?\/api\/docs\/models\/([^"'/?#]+)[^"']*["']/gi);
+    for (const link of links) {
+        const id = decodeURIComponent(link[1] ?? "").toLowerCase();
+        if (/^(?:gpt-image-|chatgpt-image-|dall-e-)/.test(id))
+            ids.add(id);
+    }
+    return [...ids].map(openAiImageModel);
+}
+function openAiImageModel(id) {
+    return {
+        id,
+        name: imageModelName(id),
+        inputModalities: ["text", "image"],
+        outputModalities: ["image"],
+        endpoints: ["images/generations", "images/edits"],
+        supportsToolCall: false,
+        available: true,
+        selectable: true,
+    };
+}
+async function discoverOpenAiImageModels(fetcher, signal) {
+    try {
+        const response = await fetcher(OPENAI_MODELS_URL, {
+            headers: { accept: "text/html" },
+            signal,
+        });
+        if (!response.ok)
+            return [];
+        return parseOpenAiImageModels(await response.text());
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw error;
+        return [];
+    }
+}
 async function normalizeChatGptRequest(request) {
     if (request.method !== "POST" || !new URL(request.url).pathname.endsWith("/responses")) {
         return request;
@@ -115,6 +170,7 @@ async function normalizeChatGptRequest(request) {
         headers.set("session-id", sessionId);
     // Preserve instruction placement and message boundaries. The native Codex
     // client sends top-level instructions too; moving them does not enable caching.
+    delete body.max_output_tokens;
     delete body.prompt_cache_options;
     delete body.prompt_cache_retention;
     const stripBreakpoints = (value) => Array.isArray(value)
@@ -459,12 +515,18 @@ export function chatGptProvider(options = {}) {
             const response = await fetch(url, { headers: { accept: "application/json" }, signal });
             const raw = await responseJson(response, "ChatGPT models");
             const models = Array.isArray(raw.models) ? raw.models : [];
-            return models
+            const languageModels = models
                 .map(normalizeModel)
                 .filter((model) => Boolean(model))
                 .filter((model) => model.available !== false)
                 .sort((left, right) => left.priority - right.priority)
                 .map(({ priority: _priority, ...model }) => model);
+            const listed = new Map(languageModels.map((model) => [model.id, model]));
+            for (const model of await discoverOpenAiImageModels(fetcher, signal)) {
+                if (!listed.has(model.id))
+                    listed.set(model.id, model);
+            }
+            return [...listed.values()];
         },
         isPermanentRefreshError(error) {
             return (error instanceof ChatGptTokenError &&

package/dist/providers/opencode.d.ts

@@ -1,4 +1,8 @@
 import type { ProviderAdapter, ProviderUsageData } from "../types.js";
+export interface OpenCodeProviderOptions {
+    compatibilityVersion?: string;
+    fetch?: typeof globalThis.fetch;
+}
 export declare function parseOpenCodeGoUsage(raw: unknown): ProviderUsageData | null;
-export declare function openCodeGoProvider(): ProviderAdapter;
-export declare function openCodeZenProvider(): ProviderAdapter;
+export declare function openCodeGoProvider(options?: OpenCodeProviderOptions): ProviderAdapter;
+export declare function openCodeZenProvider(options?: OpenCodeProviderOptions): ProviderAdapter;