@jancellor/ask 1.0.0 → 1.1.0

package/README.md

@@ -50,24 +50,104 @@ npm link
 Configure a provider:
 
 ```bash
-export ASK_API_KEY="your-api-key"
-export ASK_MODEL="anthropic/claude-sonnet-4.6"
-export ASK_BASE_URL="https://openrouter.ai/api/v1"
+ask --config --provider anthropic --model claude-opus-4-6
 ```
 
-Or create `~/.config/ask/config.json`:
+That saves the current config and creates `~/.config/ask/config.json`, eg:
 
 ```json
 {
-  "api_key": "your-api-key",
-  "model": "anthropic/claude-sonnet-4.6",
-  "base_url": "https://openrouter.ai/api/v1"
+  "currentProvider": "anthropic",
+  "providers": {
+    "anthropic": {
+      "currentModel": "claude-opus-4-6"
+    }
+  }
 }
 ```
 
+Store secrets separately in `~/.config/ask/config.secrets.json`:
+
+```json
+{
+  "anthropic": {
+    "apiKey": "your-api-key"
+  }
+}
+```
+
+For OpenAI-compatible endpoints, configure the provider explicitly:
+
+```json
+{
+  "currentProvider": "openrouter",
+  "providers": {
+    "openrouter": {
+      "sdkProvider": "openai-compatible",
+      "providerOptions": {
+        "name": "openrouter",
+        "baseURL": "https://openrouter.ai/api/v1"
+      },
+      "currentModel": "anthropic/claude-sonnet-4.6"
+    }
+  }
+}
+```
+
+Ask uses the [AI SDK](https://ai-sdk.dev/docs/reference/ai-sdk-core), and this
+config is designed to map directly onto that runtime model. You select a
+configured provider, then a model within that provider, and optionally a
+variant within that model. A configured provider can also override
+[`sdkProvider`](https://ai-sdk.dev/docs/providers) so one named config entry can
+target a different SDK provider family, such as `openai-compatible`.
+`providerOptions` live on the provider and are passed to the SDK provider
+factory, while auth stays separate in `config.secrets.json`. `generateOptions`
+can be set globally and at the provider, model, and variant levels; at runtime
+they are merged in that order and passed through as the options object for
+[`generateText`](https://ai-sdk.dev/docs/ai-sdk-core/generating-text).
+
+For example, you can add a Claude reasoning-effort variant with per-variant
+Anthropic options:
+
+```json
+{
+  "currentProvider": "anthropic",
+  "providers": {
+    "anthropic": {
+      "currentModel": "claude-opus-4-6",
+      "models": {
+        "claude-opus-4-6": {
+          "currentVariant": "balanced",
+          "variants": {
+            "balanced": {
+              "generateOptions": {
+                "providerOptions": {
+                  "anthropic": {
+                    "effort": "medium"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+Then use `ask -v balanced` to select that variant for a run.
+
+Use `ask -c` to print the resolved config. If you pass `-p`, `-m`, or `-v`
+with `-c`, those values are saved as the new current selection. Without `-c`,
+they apply only to the current run.
+
 Run:
 
 ```bash
+ask -c                       # Show current resolved config
+ask -c -p openai -m gpt-5    # Update saved provider/model
+ask -c -v                    # Clear the saved variant
 ask                          # Interactive mode
 ask "refactor"               # Batch mode (single positional arg)
 cat file.ts | ask "explain"  # Pipe context, ask a question

package/dist/agent/agent.d.ts

@@ -0,0 +1,38 @@
+import { type ConfigOptions } from './config.js';
+import type { AskMessage } from './messages.js';
+import { type SessionOptions } from './session.js';
+export type { AskMessage, AskMessageMeta } from './messages.js';
+export interface AgentListener {
+    onMessages?(messages: AskMessage[]): void | Promise<void>;
+    onClear?(): void | Promise<void>;
+    onFork?(): void | Promise<void>;
+}
+export type AgentOptions = SessionOptions & ConfigOptions;
+export declare const ABORTED_MESSAGE = "[Aborted]";
+export declare const ERROR_MESSAGE = "[Error]";
+export declare class Agent {
+    private listeners;
+    private config;
+    private systemPrompt;
+    private tools;
+    private session;
+    private serializer;
+    private controller;
+    private constructor();
+    static create(options: AgentOptions): Promise<Agent>;
+    addListener(listener: AgentListener): void;
+    removeListener(listener: AgentListener): void;
+    get messages(): AskMessage[];
+    get sessionId(): string;
+    get model(): string;
+    get provider(): string;
+    get variant(): string | null;
+    ask(message: string): Promise<void>;
+    abort(): void;
+    cancelAll(): Promise<void>;
+    clear(beforeClear?: () => void): Promise<void>;
+    fork(sessionId?: string, beforeFork?: () => void): Promise<void>;
+    private addMessages;
+    private addInitialMessages;
+    private callTools;
+}

package/dist/agent/agent.js

@@ -1,6 +1,5 @@
-import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { generateText, } from 'ai';
-import { ConfigReader } from './config.js';
+import { ConfigReader, } from './config.js';
 import { InitPrompt } from './init-prompt.js';
 import { Session } from './session.js';
 import { SystemPrompt } from './system-prompt.js';
@@ -9,32 +8,25 @@ import { Tools } from './tools.js';
 export const ABORTED_MESSAGE = '[Aborted]';
 export const ERROR_MESSAGE = '[Error]';
 export class Agent {
-    modelId;
-    baseUrl;
     listeners = [];
-    languageModel;
+    config;
     systemPrompt;
     tools;
     session;
     serializer = new Serializer();
     controller = null;
-    constructor(session) {
+    constructor(session, config) {
         this.session = session;
-        const config = new ConfigReader().read();
-        this.modelId = config.model;
-        this.baseUrl = config.baseUrl;
-        const provider = createOpenAICompatible({
-            name: 'ask',
-            apiKey: config.apiKey,
-            baseURL: config.baseUrl,
-        });
-        this.languageModel = provider(config.model);
+        this.config = config;
         this.systemPrompt = new SystemPrompt().build();
         this.tools = new Tools();
     }
     static async create(options) {
-        const session = await Session.create(options);
-        return new Agent(session);
+        const [session, config] = await Promise.all([
+            Session.create(options),
+            new ConfigReader().resolve(options),
+        ]);
+        return new Agent(session, config);
     }
     addListener(listener) {
         this.listeners.push(listener);
@@ -50,6 +42,15 @@ export class Agent {
     get sessionId() {
         return this.session.sessionId;
     }
+    get model() {
+        return this.config.model;
+    }
+    get provider() {
+        return this.config.provider;
+    }
+    get variant() {
+        return this.config.variant;
+    }
     ask(message) {
         return this.serializer.submit(async () => {
             await this.addInitialMessages();
@@ -59,7 +60,8 @@ export class Agent {
             try {
                 while (true) {
                     const result = await generateText({
-                        model: this.languageModel,
+                        ...this.config.generateOptions,
+                        model: this.config.languageModel,
                         system: this.systemPrompt,
                         messages: this.session.messages,
                         tools: this.tools.definitions(),

package/dist/agent/agents-prompt.d.ts

@@ -0,0 +1,4 @@
+export declare class AgentsPrompt {
+    build(): Promise<string>;
+    private tryRead;
+}

package/dist/agent/check.d.ts

@@ -0,0 +1 @@
+export declare function check(condition: unknown, message: string): asserts condition;

package/dist/agent/check.js

@@ -0,0 +1,5 @@
+export function check(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}

package/dist/agent/config-schema.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+export declare const GenerateOptions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export declare const ProviderOptions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export declare const ProviderSecretOptions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export declare const VariantConfig: z.ZodObject<{
+    generateOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const ModelConfig: z.ZodObject<{
+    sdkModel: z.ZodOptional<z.ZodString>;
+    generateOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    currentVariant: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        generateOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ProviderConfig: z.ZodObject<{
+    sdkProvider: z.ZodOptional<z.ZodString>;
+    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    generateOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    currentModel: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        sdkModel: z.ZodOptional<z.ZodString>;
+        generateOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        currentVariant: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            generateOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const Config: z.ZodObject<{
+    currentProvider: z.ZodOptional<z.ZodString>;
+    generateOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        sdkProvider: z.ZodOptional<z.ZodString>;
+        providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        generateOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        currentModel: z.ZodOptional<z.ZodString>;
+        models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            sdkModel: z.ZodOptional<z.ZodString>;
+            generateOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            currentVariant: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                generateOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ConfigSecrets: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+export type GenerateOptions = z.infer<typeof GenerateOptions>;
+export type ProviderOptions = z.infer<typeof ProviderOptions>;
+export type ProviderSecretOptions = z.infer<typeof ProviderSecretOptions>;
+export type Config = z.infer<typeof Config>;
+export type ProviderConfig = z.infer<typeof ProviderConfig>;
+export type ModelConfig = z.infer<typeof ModelConfig>;
+export type VariantConfig = z.infer<typeof VariantConfig>;
+export type ConfigSecrets = z.infer<typeof ConfigSecrets>;

package/dist/agent/config-schema.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const GenerateOptions = z.record(z.string(), z.unknown());
+export const ProviderOptions = z.record(z.string(), z.unknown());
+export const ProviderSecretOptions = z.record(z.string(), z.unknown());
+export const VariantConfig = z.object({
+    generateOptions: GenerateOptions.optional(),
+});
+export const ModelConfig = z.object({
+    sdkModel: z.string().optional(),
+    generateOptions: GenerateOptions.optional(),
+    currentVariant: z.string().nullable().optional(),
+    variants: z.record(z.string(), VariantConfig).optional(),
+});
+export const ProviderConfig = z.object({
+    sdkProvider: z.string().optional(),
+    providerOptions: ProviderOptions.optional(),
+    generateOptions: GenerateOptions.optional(),
+    currentModel: z.string().optional(),
+    models: z.record(z.string(), ModelConfig).optional(),
+});
+export const Config = z.object({
+    currentProvider: z.string().optional(),
+    generateOptions: GenerateOptions.optional(),
+    providers: z.record(z.string(), ProviderConfig).optional(),
+});
+export const ConfigSecrets = z.record(z.string(), ProviderSecretOptions);

package/dist/agent/config-store.d.ts

@@ -0,0 +1,12 @@
+import { ConfigSecrets, type Config as ConfigType } from './config-schema.js';
+export declare class ConfigStore {
+    private static CONFIG_DIR;
+    private static CONFIG_PATH;
+    private static SECRETS_PATH;
+    readConfig(): Promise<ConfigType>;
+    readSecrets(): Promise<ConfigSecrets>;
+    writeConfig(config: ConfigType): Promise<void>;
+    private readJsonFile;
+    private parseWithSchema;
+    private writeConfigAtomically;
+}

package/dist/agent/config-store.js

@@ -0,0 +1,46 @@
+import { mkdir, readFile, rename, writeFile } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+import { Config, ConfigSecrets, } from './config-schema.js';
+import { ignoreMissing } from './fs-ops.js';
+export class ConfigStore {
+    static CONFIG_DIR = join(homedir(), '.config', 'ask');
+    static CONFIG_PATH = join(ConfigStore.CONFIG_DIR, 'config.json');
+    static SECRETS_PATH = join(ConfigStore.CONFIG_DIR, 'config.secrets.json');
+    async readConfig() {
+        const raw = await this.readJsonFile(ConfigStore.CONFIG_PATH);
+        return this.parseWithSchema('config.json', Config, raw ?? {});
+    }
+    async readSecrets() {
+        const raw = await this.readJsonFile(ConfigStore.SECRETS_PATH);
+        return this.parseWithSchema('config.secrets.json', ConfigSecrets, raw ?? {});
+    }
+    async writeConfig(config) {
+        const serialized = JSON.stringify(config, null, 2) + '\n';
+        await this.writeConfigAtomically(serialized);
+    }
+    async readJsonFile(path) {
+        const content = await ignoreMissing(() => readFile(path, 'utf-8'));
+        if (content === undefined)
+            return undefined;
+        try {
+            return JSON.parse(content);
+        }
+        catch {
+            throw new Error(`invalid JSON in ${path}`);
+        }
+    }
+    parseWithSchema(schemaName, parser, input) {
+        const result = parser.safeParse(input);
+        if (result.success)
+            return result.data;
+        throw new Error(`invalid ${schemaName}: ${JSON.stringify(result.error.issues, null, 2)}`);
+    }
+    async writeConfigAtomically(data) {
+        await mkdir(ConfigStore.CONFIG_DIR, { recursive: true });
+        const path = ConfigStore.CONFIG_PATH;
+        const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+        await writeFile(tempPath, data, 'utf-8');
+        await rename(tempPath, path);
+    }
+}

package/dist/agent/config.d.ts

@@ -0,0 +1,27 @@
+import type { LanguageModel } from 'ai';
+import { type GenerateOptions, type ProviderOptions } from './config-schema.js';
+export type ConfigOptions = {
+    provider?: string;
+    model?: string;
+    variant?: string | null;
+    saveAsCurrent?: boolean;
+};
+export type ResolvedConfig = {
+    provider: string;
+    model: string;
+    variant: string | null;
+    sdkProvider: string;
+    sdkModel: string;
+    providerOptions: ProviderOptions;
+    generateOptions: GenerateOptions;
+    languageModel: LanguageModel;
+};
+export declare class ConfigReader {
+    private store;
+    constructor();
+    resolve(configOptions: ConfigOptions): Promise<ResolvedConfig>;
+    private saveAsCurrent;
+    private resolveProvider;
+    private resolveModel;
+    private resolveVariant;
+}

package/dist/agent/config.js

@@ -1,54 +1,92 @@
-import { readFileSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
+import { isMatch, merge } from 'lodash-es';
+import { check } from './check.js';
+import { ConfigStore } from './config-store.js';
+import { createLanguageModel } from './provider-factories.js';
 export class ConfigReader {
-    static CONFIG_PATH = join(homedir(), '.config', 'ask', 'config.json');
-    readConfigFile() {
-        try {
-            return JSON.parse(readFileSync(ConfigReader.CONFIG_PATH, 'utf-8'));
-        }
-        catch {
-            return {};
-        }
-    }
-    envOrFile(envKey, fileKey, fileValues) {
-        const envValue = process.env[envKey];
-        if (envValue)
-            return envValue.trim();
-        const fileValue = fileValues[fileKey];
-        if (fileValue != null)
-            return String(fileValue).trim();
-        throw new Error(`neither ${envKey} nor ${fileKey} is set`);
-    }
-    optionalEnvOrFile(envKey, fileKey, fileValues) {
-        const envValue = process.env[envKey];
-        if (envValue && envValue.trim())
-            return envValue.trim();
-        const fileValue = fileValues[fileKey];
-        if (fileValue == null)
-            return undefined;
-        const value = String(fileValue).trim();
-        return value ? value : undefined;
+    store;
+    constructor() {
+        this.store = new ConfigStore();
     }
-    isOpenAIBaseUrl(baseUrl) {
-        try {
-            return new URL(baseUrl).hostname.includes('openai.com');
-        }
-        catch {
-            return baseUrl.includes('openai.com');
+    async resolve(configOptions) {
+        const [config, secrets] = await Promise.all([
+            this.store.readConfig(),
+            this.store.readSecrets(),
+        ]);
+        const { provider, providerConfig } = this.resolveProvider(config, configOptions);
+        const { model, modelConfig } = this.resolveModel(providerConfig, configOptions);
+        const { variant, variantConfig } = this.resolveVariant(modelConfig, configOptions);
+        const sdkProvider = providerConfig.sdkProvider ?? provider;
+        const sdkModel = modelConfig.sdkModel ?? model;
+        const providerOptions = providerConfig.providerOptions ?? {};
+        const providerSecretOptions = secrets[provider] ?? {};
+        if (configOptions.saveAsCurrent) {
+            await this.saveAsCurrent(config, provider, model, variant);
         }
+        const generateOptions = merge({}, config.generateOptions, providerConfig.generateOptions, modelConfig.generateOptions, variantConfig?.generateOptions);
+        const languageModel = createLanguageModel({
+            sdkProvider,
+            sdkModel,
+            providerOptions,
+            providerSecretOptions,
+        });
+        return {
+            provider,
+            model,
+            variant,
+            sdkProvider,
+            sdkModel,
+            providerOptions,
+            generateOptions,
+            languageModel,
+        };
     }
-    read() {
-        const fileValues = this.readConfigFile();
-        const baseUrl = this.envOrFile('ASK_BASE_URL', 'base_url', fileValues);
-        const apiKey = this.optionalEnvOrFile('ASK_API_KEY', 'api_key', fileValues);
-        if (!apiKey && !this.isOpenAIBaseUrl(baseUrl)) {
-            throw new Error('neither ASK_API_KEY nor api_key is set (required unless ASK_BASE_URL/base_url points to openai.com)');
+    async saveAsCurrent(config, provider, model, variant) {
+        const persistedVariant = config.providers?.[provider]?.models?.[model]?.currentVariant ?? null;
+        // prevent unnecessary config only to set `currentVariant: null`
+        const shouldOmitNullVariant = variant === null && persistedVariant === null;
+        const patch = {
+            currentProvider: provider,
+            providers: {
+                [provider]: {
+                    currentModel: model,
+                    ...(!shouldOmitNullVariant
+                        ? {
+                            models: {
+                                [model]: {
+                                    currentVariant: variant,
+                                },
+                            },
+                        }
+                        : {}),
+                },
+            },
+        };
+        if (!isMatch(config, patch)) {
+            const patched = merge({}, config, patch);
+            await this.store.writeConfig(patched);
         }
-        return {
-            apiKey: apiKey ?? 'oauth',
-            model: this.envOrFile('ASK_MODEL', 'model', fileValues),
-            baseUrl,
+    }
+    resolveProvider(config, configOptions) {
+        const provider = configOptions.provider ?? config.currentProvider;
+        check(provider, 'provider not specified');
+        const providerConfig = config.providers?.[provider] ?? {
+            sdkProvider: provider,
         };
+        return { provider, providerConfig };
+    }
+    resolveModel(provider, configOptions) {
+        const model = configOptions.model ?? provider.currentModel;
+        check(model, `model not specified`);
+        const modelConfig = provider.models?.[model] ?? {
+            sdkModel: model,
+        };
+        return { model, modelConfig };
+    }
+    resolveVariant(model, configOptions) {
+        const variant = configOptions.variant ?? model.currentVariant ?? null;
+        const variantConfig = variant ? model.variants?.[variant] : undefined;
+        if (variant)
+            check(variantConfig, `variant not found: ${variant}`);
+        return { variant, variantConfig };
     }
 }

package/dist/agent/execute-tool.d.ts

@@ -0,0 +1,15 @@
+export type ExecuteToolOutput = {
+    exit?: number;
+    signal?: string;
+    stdout?: string;
+    stderr?: string;
+    error?: string;
+};
+export declare class ExecuteTool {
+    readonly name = "execute";
+    definition(): import("ai").Tool<{
+        command: string;
+    }, never>;
+    execute(input: unknown, signal: AbortSignal): Promise<ExecuteToolOutput>;
+    private signalProcessGroup;
+}

package/dist/agent/execute-tool.js

@@ -5,9 +5,7 @@ import { z } from 'zod';
 const DEFAULT_TIMEOUT_S = 60;
 const TERMINATION_GRACE_MS = 5000;
 const executeInputSchema = z.object({
-    command: z
-        .string()
-        .describe('The shell command to execute using `bash -c`'),
+    command: z.string().describe('The shell command to execute using `bash -c`'),
 });
 export class ExecuteTool {
     name = 'execute';

package/dist/agent/fs-errors.js

@@ -0,0 +1,23 @@
+export function isEnoentError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    return 'code' in error && error.code === 'ENOENT';
+}
+export async function ignoreMissing(op) {
+    try {
+        return await op();
+    }
+    catch (error) {
+        if (!isEnoentError(error))
+            throw error;
+    }
+}
+export function ignoreMissingSync(op) {
+    try {
+        return op();
+    }
+    catch (error) {
+        if (!isEnoentError(error))
+            throw error;
+    }
+}

package/dist/agent/fs-ops.d.ts

@@ -0,0 +1,2 @@
+export declare function isEnoentError(error: unknown): boolean;
+export declare function ignoreMissing<T>(op: () => Promise<T>): Promise<T | undefined>;

package/dist/agent/fs-ops.js

@@ -0,0 +1,14 @@
+export function isEnoentError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    return 'code' in error && error.code === 'ENOENT';
+}
+export async function ignoreMissing(op) {
+    try {
+        return await op();
+    }
+    catch (error) {
+        if (!isEnoentError(error))
+            throw error;
+    }
+}

package/dist/agent/index.d.ts

@@ -0,0 +1 @@
+export { Agent, ABORTED_MESSAGE, ERROR_MESSAGE, type AskMessage, type AgentOptions, type AskMessageMeta, type AgentListener, } from './agent.js';

package/dist/agent/init-prompt.d.ts

@@ -0,0 +1,3 @@
+export declare class InitPrompt {
+    build(): Promise<string>;
+}

package/dist/agent/messages.d.ts

@@ -0,0 +1,10 @@
+import type { ModelMessage } from 'ai';
+export type AskMessageMeta = {
+    id: string;
+    parentId: string | null;
+    uiHidden?: boolean;
+    timestamp?: string;
+};
+export type AskMessage = ModelMessage & {
+    _meta: AskMessageMeta;
+};

package/dist/agent/openai-subscription-fetch.d.ts

@@ -0,0 +1,5 @@
+/**
+ * I don't think this works but leaving it plugged in for now.
+ * We might need to set other headers/content in order to use subscriptions.
+ */
+export declare function createOpenAISubscriptionFetch(): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;