codex-multi-auth 2.15.0 → 2.17.0

package/dist/lib/runtime/api-model-capabilities.js

@@ -0,0 +1,434 @@
+import { mapWithConcurrency } from "../concurrency.js";
+import { classifyCapabilityFailure } from "./runtime-capability-failures.js";
+import { createHash } from "node:crypto";
+import { canonicalServiceTier, } from "../model-route-policy.js";
+import { isRecord } from "../utils.js";
+const efforts = new Set([
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+]);
+/** Read the explicit model-specific statement, never surrounding examples or another model's settings. */
+export function parseApiReasoningDocumentation(id, text) {
+    if (text.match(/^Model ID:\s*`([^`]+)`/m)?.[1] !== id)
+        return [];
+    const statement = text.match(/`?reasoning\.effort`?\s+supports\s*:?\s*([^\n.]+)\./i)?.[1];
+    if (!statement)
+        return [];
+    const values = statement
+        .replace(/`|\(default\)/g, " ")
+        .split(/,|\band\b/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (!values.length ||
+        values.length > 16 ||
+        values.some((v) => !/^[a-z][a-z0-9_-]{0,31}$/.test(v) ||
+            v === "ultra" ||
+            v === "persistent"))
+        return [];
+    return [...new Set(values)];
+}
+/** Only the exact model's input declaration can enable native image attachments. */
+function parseInputModalities(id, text) {
+    if (text.match(/^Model ID:\s*`([^`]+)`/m)?.[1] !== id)
+        return undefined;
+    const details = text.split(/^## Model details[ \t]*\r?\n/m)[1]?.split(/^## /m)[0];
+    const declaration = details?.match(/^- Input modalities:[ \t]*([^\r\n]+)$/m)?.[1];
+    if (!declaration)
+        return undefined;
+    const modalities = declaration.split(",").map(value => value.trim());
+    if (!modalities.length || modalities.some(value => !["text", "image", "audio", "video"].includes(value)))
+        return undefined;
+    // The native coding picker currently accepts text and image inputs.
+    return [...new Set(modalities.filter(value => value === "text" || value === "image"))];
+}
+/** Codes and params that say the key, organization or project itself lacks access. */
+const CREDENTIAL_ACCESS_CODES = new Set([
+    "invalid_api_key", "insufficient_permissions", "permission_denied", "unauthorized",
+    "organization_deactivated", "account_deactivated", "project_not_found", "project_archived",
+    "ip_not_authorized", "unsupported_country_region_territory",
+]);
+/**
+ * A 403 either removes the credential's access ("lost"), denies the whole model
+ * on this credential ("model"), denies only the probed setting ("setting"), or
+ * explains nothing ("ambiguous").
+ */
+function classifyProbe403(data, setting) {
+    const error = isRecord(data) && isRecord(data.error) ? data.error : null;
+    if (!error)
+        return "ambiguous";
+    const code = String(error.code ?? ""), param = String(error.param ?? "");
+    if (CREDENTIAL_ACCESS_CODES.has(code) || ["api_key", "organization", "project"].includes(param))
+        return "lost";
+    // Same model-level denial codes the runtime capability classifier uses.
+    if (classifyCapabilityFailure(403, data) === "model")
+        return "model";
+    // Compatibility and tier probes also carry an effort, but only an effort probe
+    // tests it: an effort-param 403 elsewhere explains nothing about the probed setting.
+    const effortProbe = Boolean(setting.effort) && !setting.tier && !setting.compatibility;
+    if (effortProbe && ["reasoning.effort", "reasoning"].includes(param))
+        return "setting";
+    if (setting.tier && param === "service_tier")
+        return "setting";
+    if (setting.compatibility && ["tools", "tool_choice"].includes(param))
+        return "setting";
+    return "ambiguous";
+}
+export class ApiModelCapabilities {
+    fetchImpl;
+    now;
+    activeProbes = 0;
+    probeWaiters = [];
+    async withProbeSlot(operation) {
+        if (this.activeProbes >= 4)
+            await new Promise((resolve) => this.probeWaiters.push(resolve));
+        else
+            this.activeProbes++;
+        try {
+            return await operation();
+        }
+        finally {
+            const next = this.probeWaiters.shift();
+            if (next)
+                next();
+            else
+                this.activeProbes--;
+        }
+    }
+    inFlight = new Map();
+    probes = new Map();
+    cache = new Map();
+    constructor(fetchImpl = fetch, now = Date.now) {
+        this.fetchImpl = fetchImpl;
+        this.now = now;
+    }
+    /** Probe results keyed by an opaque hash, for a fresh CLI process to honour the 15-minute cache. */
+    exportProbes() {
+        return [...this.probes];
+    }
+    importProbes(entries) {
+        for (const [key, value] of entries.slice(-1000)) {
+            if (this.probes.has(key) || value.at > this.now())
+                continue;
+            this.probes.set(key, value);
+        }
+    }
+    async reasoning(id, refresh = false) {
+        return (await this.documentation(id, refresh)).levels;
+    }
+    async documentation(id, refresh = false) {
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/.test(id))
+            return { levels: [] };
+        const cached = this.cache.get(id);
+        if (!refresh && cached && cached.at + 60000 > this.now())
+            return cached;
+        let metadata = { levels: [] };
+        try {
+            const response = await this.fetchImpl(`https://developers.openai.com/api/docs/models/${encodeURIComponent(id)}.md`, { redirect: "error", signal: AbortSignal.timeout(5000) });
+            if (!response.ok) {
+                await response.body?.cancel();
+                throw Error("Documentation unavailable");
+            }
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw Error("No documentation");
+            const chunks = [];
+            let size = 0;
+            try {
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    size += value.byteLength;
+                    if (size > 256 * 1024)
+                        throw Error("Documentation too large");
+                    chunks.push(value);
+                }
+            }
+            finally {
+                await reader.cancel();
+            }
+            const text = Buffer.concat(chunks).toString("utf8");
+            metadata = {
+                levels: parseApiReasoningDocumentation(id, text),
+                inputModalities: parseInputModalities(id, text),
+            };
+        }
+        catch {
+            // An outage is not a capability revocation. Keep last successful evidence.
+            metadata = cached ?? metadata;
+        }
+        if (this.cache.size >= 1000)
+            this.cache.delete(this.cache.keys().next().value ?? "");
+        this.cache.set(id, { ...metadata, at: this.now() });
+        return metadata;
+    }
+    async probe(route, id, documented, force = false) {
+        const key = createHash("sha256")
+            .update(route.id)
+            .update("\0")
+            .update(route.apiKey)
+            .update("\0")
+            .update(id)
+            .digest("hex");
+        const old = this.probes.get(key);
+        // A probe cut short by 401/403/429 is retried after a minute, not trusted for 15.
+        const freshFor = old?.status.retry === "transient" ? 60_000 : 900_000;
+        if (!force && old && old.at + freshFor > this.now())
+            return old;
+        const running = this.inFlight.get(key);
+        if (running)
+            return running;
+        const pending = this.runProbe(route, id, documented, key).finally(() => this.inFlight.delete(key));
+        this.inFlight.set(key, pending);
+        return pending;
+    }
+    async runProbe(route, id, documented, key) {
+        const result = {
+            at: this.now(),
+            levels: [...documented],
+            tiers: [],
+            status: {},
+        };
+        let credentialUnavailable = false;
+        // 401/403 means this credential lost access: nothing it verified before
+        // may still be advertised. A throttle (429) or transport failure is only
+        // inconclusive and keeps what an earlier probe verified. Only
+        // "unsupported" or "downgraded" removes a setting otherwise.
+        let lostAccess = false;
+        // A model-level denial hides the model on this credential: no efforts, no tiers.
+        let modelDenied = false;
+        const previous = this.probes.get(key);
+        const keep = (name, status) => status === "unverified" && !lostAccess && !modelDenied && previous?.status[name] === "verified" ? "verified" : status;
+        const attempt = async (setting) => {
+            // Lost access drops everything this credential verified; a model-level
+            // denial hides the model; a 403 naming the probed setting removes only it.
+            // An unexplained 403 changes nothing and the probe is retried soon.
+            const denied403 = (data) => {
+                const kind = classifyProbe403(data, setting);
+                if (kind === "lost") {
+                    credentialUnavailable = true;
+                    lostAccess = true;
+                    return "unverified";
+                }
+                if (kind === "model") {
+                    modelDenied = true;
+                    return "unsupported";
+                }
+                if (kind === "setting")
+                    return "unsupported";
+                credentialUnavailable = true;
+                return "unverified";
+            };
+            return this.withProbeSlot(async () => {
+                if (credentialUnavailable || modelDenied)
+                    return "unverified";
+                try {
+                    const response = await this.fetchImpl("https://api.openai.com/v1/responses", {
+                        method: "POST",
+                        headers: {
+                            authorization: `Bearer ${route.apiKey}`,
+                            "content-type": "application/json",
+                        },
+                        redirect: "error",
+                        signal: AbortSignal.timeout(15000),
+                        body: JSON.stringify({
+                            model: id,
+                            input: "Reply OK.",
+                            store: false,
+                            max_output_tokens: 16,
+                            ...(setting.compatibility
+                                ? {
+                                    tools: [
+                                        {
+                                            type: "function",
+                                            name: "capability_probe",
+                                            parameters: {
+                                                type: "object",
+                                                properties: {},
+                                                required: [],
+                                                additionalProperties: false,
+                                            },
+                                            strict: true,
+                                        },
+                                    ],
+                                    tool_choice: {
+                                        type: "function",
+                                        name: "capability_probe",
+                                    },
+                                }
+                                : {}),
+                            ...(setting.effort
+                                ? { reasoning: { effort: setting.effort } }
+                                : {}),
+                            ...(setting.tier ? { service_tier: setting.tier } : {}),
+                        }),
+                    });
+                    if ([401, 429].includes(response.status))
+                        credentialUnavailable = true;
+                    if (response.status === 401)
+                        lostAccess = true;
+                    // Probe bodies are tiny, but an upstream error must not grow local memory unboundedly.
+                    const reader = response.body?.getReader();
+                    if (!reader)
+                        return response.status === 403 ? denied403(null) : "unverified";
+                    const chunks = [];
+                    let bytes = 0;
+                    try {
+                        for (;;) {
+                            const { done, value } = await reader.read();
+                            if (done)
+                                break;
+                            bytes += value.byteLength;
+                            if (bytes > 256 * 1024)
+                                throw Error("Probe response too large");
+                            chunks.push(value);
+                        }
+                    }
+                    finally {
+                        await reader.cancel();
+                    }
+                    let data;
+                    try {
+                        data = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+                    }
+                    catch {
+                        return response.status === 403 ? denied403(null) : "unverified";
+                    }
+                    if (response.status === 403)
+                        return denied403(data);
+                    if (!response.ok) {
+                        if (setting.compatibility) {
+                            const error = isRecord(data) && isRecord(data.error) ? data.error : null;
+                            return classifyCapabilityFailure(response.status, data) ===
+                                "model" ||
+                                (response.status === 400 &&
+                                    error &&
+                                    ["tools", "tool_choice"].includes(String(error.param)) &&
+                                    ["unsupported_parameter", "unsupported_value"].includes(String(error.code)))
+                                ? "unsupported"
+                                : "unverified";
+                        }
+                        const error = isRecord(data) && isRecord(data.error) ? data.error : null;
+                        return response.status === 400 &&
+                            error &&
+                            typeof error.param === "string" &&
+                            ["reasoning.effort", "reasoning", "service_tier"].includes(error.param)
+                            ? "unsupported"
+                            : "unverified";
+                    }
+                    if (setting.compatibility)
+                        return isRecord(data) &&
+                            Array.isArray(data.output) &&
+                            data.output.some((item) => isRecord(item) &&
+                                item.type === "function_call" &&
+                                item.name === "capability_probe")
+                            ? "verified"
+                            : "unverified";
+                    if (!setting.tier)
+                        return isRecord(data) &&
+                            isRecord(data.reasoning) &&
+                            data.reasoning.effort === setting.effort
+                            ? "verified"
+                            : "unverified";
+                    if (!isRecord(data) || typeof data.service_tier !== "string")
+                        return "unverified";
+                    return canonicalServiceTier(data.service_tier) ===
+                        canonicalServiceTier(setting.tier)
+                        ? "verified"
+                        : "downgraded";
+                }
+                catch {
+                    return "unverified";
+                }
+            });
+        };
+        {
+            const checked = await Promise.all([...efforts]
+                .filter((effort) => !documented.includes(effort))
+                .map(async (effort) => ({
+                effort,
+                status: await attempt({ effort }),
+            })));
+            for (const { effort, status } of checked) {
+                const effective = keep(`effort:${effort}`, status);
+                result.status[`effort:${effort}`] = effective;
+                if (effective === "verified")
+                    result.levels.push(effort);
+            }
+        }
+        const effort = result.levels.includes("low") ? "low" : result.levels[0];
+        result.status.responses = keep("responses", await attempt({ compatibility: true, effort }));
+        const checkedTiers = await Promise.all(["fast", "ultrafast"].map(async (tier) => ({
+            tier,
+            status: await attempt({ tier: tier === "fast" ? "priority" : tier, effort }),
+        })));
+        for (const { tier, status } of checkedTiers) {
+            const effective = keep(tier, status);
+            result.status[tier] = effective;
+            if (effective === "verified")
+                result.tiers.push(tier);
+        }
+        if (modelDenied) {
+            result.levels = [];
+            result.tiers = [];
+            for (const name of Object.keys(result.status))
+                result.status[name] = "unsupported";
+            result.status.responses = "unsupported";
+        }
+        if (credentialUnavailable && !modelDenied)
+            result.status.retry = "transient";
+        result.at = this.now();
+        if (this.probes.size >= 1000)
+            this.probes.delete(this.probes.keys().next().value ?? "");
+        this.probes.set(key, result);
+        return result;
+    }
+    async enrich(models, refresh = false, route, forceProbes = false) {
+        return mapWithConcurrency(models, 3, async (model) => {
+            const documented = await this.documentation(model.slug, refresh);
+            let levels = documented.levels;
+            let extra = {};
+            if (route?.enabled && route.probeCapabilities) {
+                const probed = await this.probe(route, model.slug, levels, forceProbes);
+                levels = probed.levels;
+                extra = {
+                    service_tiers: probed.tiers.map((id) => ({
+                        id: id === "fast" ? "priority" : id,
+                        name: id === "fast" ? "Fast" : "Ultrafast",
+                        description: "Verified by an API probe; runtime capacity can still downgrade processing.",
+                    })),
+                    default_service_tier: "default",
+                    additional_speed_tiers: probed.tiers,
+                    capability_probe_status: probed.status,
+                    capability_checked_at: probed.at,
+                };
+            }
+            // Ultra is a native orchestration mode. Codex resolves it to this
+            // supported wire effort; it is not an API entitlement named "ultra".
+            const multiAgentEffort = ["max", "xhigh", "high"].find((level) => levels.includes(level)) ?? null;
+            const nativeLevels = multiAgentEffort
+                ? [...levels, "ultra"]
+                : levels;
+            return {
+                ...model,
+                ...extra,
+                ...(documented.inputModalities ? { input_modalities: documented.inputModalities } : {}),
+                multi_agent_reasoning_effort: multiAgentEffort,
+                supported_reasoning_levels: nativeLevels.map((effort) => ({
+                    effort,
+                    description: effort === "ultra"
+                        ? "Proactive multi-agent mode using a supported API reasoning effort"
+                        : `${effort} reasoning effort`,
+                })),
+                default_reasoning_level: levels.includes("medium")
+                    ? "medium"
+                    : (levels[0] ?? null),
+            };
+        });
+    }
+}

package/dist/lib/runtime/api-model-runtime.d.ts

@@ -0,0 +1,42 @@
+import type { ApiRouteCredential } from "../api-route-store.js";
+import { type RouteCatalog, type RouteModel, modelEntitlements } from "../model-route-policy.js";
+/** Endpoint-family exclusions, not a fixed allowlist of text model releases.
+ * Model ID discovery alone does not prove Responses/tool compatibility. */
+export declare function isNonResponsesModel(id: string): boolean;
+/** Conservative native-picker metadata: discovery proves an ID, not optional tool capabilities. */
+export declare function apiPickerModel(id: string): RouteModel;
+export declare function boundedJson(response: Response, max?: number): Promise<unknown>;
+export interface ApiCatalogStatus {
+    id: string;
+    kind: "api" | "zdr";
+    label: string;
+    priority: number;
+    checkedAt: number;
+    error: boolean;
+    availableModels: string[];
+    visibleModels: string[];
+    entitlements: ReturnType<typeof modelEntitlements>[];
+}
+export declare class ApiModelRuntime {
+    private readonly fetchImpl;
+    private readonly now;
+    private readonly updateDiscovery?;
+    private readonly enrichModels?;
+    private readonly onCatalogUpdated?;
+    private readonly discoveryUpdates;
+    lastPersistenceError: string | null;
+    private readonly failures;
+    private readonly visibility;
+    private readonly snapshots;
+    private activeKeys;
+    cachedCatalogs(): RouteCatalog[];
+    private readonly cache;
+    constructor(fetchImpl?: typeof fetch, now?: () => number, updateDiscovery?: ((route: ApiRouteCredential, models: string[]) => Promise<ApiRouteCredential>) | undefined, enrichModels?: ((models: RouteModel[], refresh: boolean, route: ApiRouteCredential, forceProbes: boolean) => Promise<RouteModel[]>) | undefined, onCatalogUpdated?: (() => void) | undefined);
+    private key;
+    catalogs(routes: ApiRouteCredential[], refresh?: boolean, forceProbes?: boolean, waitForCapabilities?: boolean, waitForPersistence?: boolean, requestKind?: "oauth" | "api" | "zdr"): Promise<RouteCatalog[]>;
+    statuses(routes: ApiRouteCredential[]): ApiCatalogStatus[];
+    request(alias: string, body: Record<string, unknown>, routes: ApiRouteCredential[], signal?: AbortSignal, onAttempt?: (credentialIndex: number) => void): Promise<Response>;
+    recordStreamFailure(credential: ApiRouteCredential, alias: string, body: Record<string, unknown>, error: unknown): void;
+    private failure;
+}
+//# sourceMappingURL=api-model-runtime.d.ts.map

package/dist/lib/runtime/api-model-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-model-runtime.d.ts","sourceRoot":"","sources":["../../../lib/runtime/api-model-runtime.ts"],"names":[],"mappings":"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"}