@psnext/slingcli 2.5.20260710-1 → 2.5.20260718-2

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/loader.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from "node:url";
 import * as _bundledPiAgentCore from "@earendil-works/pi-agent-core";
 import * as _bundledPiAiCompat from "@earendil-works/pi-ai/compat";
 import * as _bundledPiAiOauth from "@earendil-works/pi-ai/oauth";
+import * as _bundledPiAiProviders from "@earendil-works/pi-ai/providers/all";
 import * as _bundledPiTui from "@earendil-works/pi-tui";
 import { createJiti } from "jiti/static";
 // Static imports of packages that extensions may use.
@@ -42,12 +43,14 @@ const VIRTUAL_MODULES = {
     "@earendil-works/pi-ai": _bundledPiAiCompat,
     "@earendil-works/pi-ai/compat": _bundledPiAiCompat,
     "@earendil-works/pi-ai/oauth": _bundledPiAiOauth,
+    "@earendil-works/pi-ai/providers/all": _bundledPiAiProviders,
     "@earendil-works/pi-coding-agent": _bundledPiCodingAgent,
     "@mariozechner/pi-agent-core": _bundledPiAgentCore,
     "@mariozechner/pi-tui": _bundledPiTui,
     "@mariozechner/pi-ai": _bundledPiAiCompat,
     "@mariozechner/pi-ai/compat": _bundledPiAiCompat,
     "@mariozechner/pi-ai/oauth": _bundledPiAiOauth,
+    "@mariozechner/pi-ai/providers/all": _bundledPiAiProviders,
     "@mariozechner/pi-coding-agent": _bundledPiCodingAgent,
 };
 const require = createRequire(import.meta.url);
@@ -80,19 +83,22 @@ function getAliases() {
     // global API keep working at runtime until compat is removed.
     const piAiCompatEntry = resolveWorkspaceOrImport("ai/dist/compat.js", "@earendil-works/pi-ai/compat");
     const piAiOauthEntry = resolveWorkspaceOrImport("ai/dist/oauth.js", "@earendil-works/pi-ai/oauth");
+    const piAiProvidersEntry = resolveWorkspaceOrImport("ai/dist/providers/all.js", "@earendil-works/pi-ai/providers/all");
     _aliases = {
         "@earendil-works/pi-coding-agent": piCodingAgentEntry,
         "@earendil-works/pi-agent-core": piAgentCoreEntry,
         "@earendil-works/pi-tui": piTuiEntry,
-        "@earendil-works/pi-ai": piAiCompatEntry,
+        "@earendil-works/pi-ai/providers/all": piAiProvidersEntry,
         "@earendil-works/pi-ai/compat": piAiCompatEntry,
         "@earendil-works/pi-ai/oauth": piAiOauthEntry,
+        "@earendil-works/pi-ai": piAiCompatEntry,
         "@mariozechner/pi-coding-agent": piCodingAgentEntry,
         "@mariozechner/pi-agent-core": piAgentCoreEntry,
         "@mariozechner/pi-tui": piTuiEntry,
-        "@mariozechner/pi-ai": piAiCompatEntry,
+        "@mariozechner/pi-ai/providers/all": piAiProvidersEntry,
         "@mariozechner/pi-ai/compat": piAiCompatEntry,
         "@mariozechner/pi-ai/oauth": piAiOauthEntry,
+        "@mariozechner/pi-ai": piAiCompatEntry,
         typebox: typeboxEntry,
         "typebox/compile": typeboxCompileEntry,
         "typebox/value": typeboxValueEntry,
@@ -150,19 +156,24 @@ export function createExtensionRuntime() {
         setThinkingLevel: notInitialized,
         flagValues: new Map(),
         pendingProviderRegistrations: [],
+        pendingNativeProviderRegistrations: [],
         assertActive,
         invalidate: (message) => {
             state.staleMessage ??=
                 message ??
-                    "This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().";
+                    "This extension ctx is stale after session replacement or reload. Do not use a captured sling or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().";
         },
         // Pre-bind: queue registrations so bindCore() can flush them once the
         // model registry is available. bindCore() replaces both with direct calls.
         registerProvider: (name, config, extensionPath = "<unknown>") => {
             runtime.pendingProviderRegistrations.push({ name, config, extensionPath });
         },
+        registerNativeProvider: (provider, extensionPath = "<unknown>") => {
+            runtime.pendingNativeProviderRegistrations.push({ provider, extensionPath });
+        },
         unregisterProvider: (name) => {
             runtime.pendingProviderRegistrations = runtime.pendingProviderRegistrations.filter((r) => r.name !== name);
+            runtime.pendingNativeProviderRegistrations = runtime.pendingNativeProviderRegistrations.filter((r) => r.provider.id !== name);
         },
     };
     return runtime;
@@ -281,9 +292,15 @@ function createExtensionAPI(extension, runtime, cwd, eventBus) {
             runtime.assertActive();
             runtime.setThinkingLevel(level);
         },
-        registerProvider(name, config) {
+        registerProvider(providerOrName, config) {
             runtime.assertActive();
-            runtime.registerProvider(name, config, extension.path);
+            if (typeof providerOrName === "string") {
+                if (!config)
+                    throw new Error("Provider config is required when registering by name");
+                runtime.registerProvider(providerOrName, config, extension.path);
+                return;
+            }
+            runtime.registerNativeProvider(providerOrName, extension.path);
         },
         unregisterProvider(name) {
             runtime.assertActive();

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/runner.js

@@ -16,6 +16,7 @@ const RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS = [
     "app.tools.expand",
     "app.thinking.toggle",
     "app.editor.external",
+    "app.message.copy",
     "app.message.followUp",
     "tui.input.submit",
     "tui.select.confirm",
@@ -45,23 +46,6 @@ const buildBuiltinKeybindings = (resolvedKeybindings) => {
     }
     return builtinKeybindings;
 };
-async function callContextHandlerAbortable(fn, signal) {
-    if (signal.aborted) {
-        throw new Error("Agent run aborted");
-    }
-    let cleanup = () => { };
-    const abortPromise = new Promise((_resolve, reject) => {
-        const onAbort = () => reject(new Error("Agent run aborted"));
-        signal.addEventListener("abort", onAbort, { once: true });
-        cleanup = () => signal.removeEventListener("abort", onAbort);
-    });
-    try {
-        return await Promise.race([Promise.resolve().then(fn), abortPromise]);
-    }
-    finally {
-        cleanup();
-    }
-}
 /**
  * Helper function to emit session_shutdown event to extensions.
  * Returns true if the event was emitted, false if there were no handlers.
@@ -218,6 +202,25 @@ export class ExtensionRunner {
             }
         }
         this.runtime.pendingProviderRegistrations = [];
+        for (const { provider, extensionPath } of this.runtime.pendingNativeProviderRegistrations) {
+            try {
+                if (providerActions?.registerNativeProvider) {
+                    providerActions.registerNativeProvider(provider);
+                }
+                else {
+                    this.modelRegistry.registerProvider(provider);
+                }
+            }
+            catch (err) {
+                this.emitError({
+                    extensionPath,
+                    event: "register_provider",
+                    error: err instanceof Error ? err.message : String(err),
+                    stack: err instanceof Error ? err.stack : undefined,
+                });
+            }
+        }
+        this.runtime.pendingNativeProviderRegistrations = [];
         // From this point on, provider registration/unregistration takes effect immediately
         // without requiring a /reload.
         this.runtime.registerProvider = (name, config) => {
@@ -227,6 +230,13 @@ export class ExtensionRunner {
             }
             this.modelRegistry.registerProvider(name, config);
         };
+        this.runtime.registerNativeProvider = (provider) => {
+            if (providerActions?.registerNativeProvider) {
+                providerActions.registerNativeProvider(provider);
+                return;
+            }
+            this.modelRegistry.registerProvider(provider);
+        };
         this.runtime.unregisterProvider = (name) => {
             if (providerActions?.unregisterProvider) {
                 providerActions.unregisterProvider(name);
@@ -413,6 +423,9 @@ export class ExtensionRunner {
             };
         });
     }
+    getModelRegistry() {
+        return this.modelRegistry;
+    }
     getRegisteredCommands() {
         this.commandDiagnostics = [];
         return this.resolveRegisteredCommands();
@@ -430,6 +443,10 @@ export class ExtensionRunner {
     shutdown() {
         this.shutdownHandler();
     }
+    getActiveTools() {
+        this.assertActive();
+        return this.runtime.getActiveTools();
+    }
     /**
      * Create an ExtensionContext for use in event handlers and tool execution.
      * Context values are resolved at call time, so changes via bindCore/bindUI are reflected.
@@ -710,7 +727,6 @@ export class ExtensionRunner {
     }
     async emitContext(messages) {
         const ctx = this.createContext();
-        const signal = ctx.signal;
         let currentMessages = structuredClone(messages);
         for (const ext of this.extensions) {
             const handlers = ext.handlers.get("context");
@@ -719,17 +735,12 @@ export class ExtensionRunner {
             for (const handler of handlers) {
                 try {
                     const event = { type: "context", messages: currentMessages };
-                    const handlerResult = signal
-                        ? await callContextHandlerAbortable(() => handler(event, ctx), signal)
-                        : await handler(event, ctx);
+                    const handlerResult = await handler(event, ctx);
                     if (handlerResult && handlerResult.messages) {
                         currentMessages = handlerResult.messages;
                     }
                 }
                 catch (err) {
-                    if (signal?.aborted) {
-                        throw err;
-                    }
                     const message = err instanceof Error ? err.message : String(err);
                     const stack = err instanceof Error ? err.stack : undefined;
                     this.emitError({
@@ -775,6 +786,35 @@ export class ExtensionRunner {
         }
         return currentPayload;
     }
+    async emitBeforeProviderHeaders(headers) {
+        const ctx = this.createContext();
+        for (const ext of this.extensions) {
+            const handlers = ext.handlers.get("before_provider_headers");
+            if (!handlers || handlers.length === 0)
+                continue;
+            for (const handler of handlers) {
+                try {
+                    // Handlers mutate `headers` in place; the return value is ignored.
+                    const event = {
+                        type: "before_provider_headers",
+                        headers,
+                    };
+                    await handler(event, ctx);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    const stack = err instanceof Error ? err.stack : undefined;
+                    this.emitError({
+                        extensionPath: ext.path,
+                        event: "before_provider_headers",
+                        error: message,
+                        stack,
+                    });
+                }
+            }
+        }
+        return headers;
+    }
     async emitBeforeAgentStart(prompt, images, systemPrompt, systemPromptOptions) {
         let currentSystemPrompt = systemPrompt;
         const ctx = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this.createContext()));

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/wrapper.js

@@ -4,19 +4,38 @@
  * These wrappers only adapt tool execution so extension tools receive the runner context.
  * Tool call and tool result interception is handled by AgentSession via agent-core hooks.
  */
-import { wrapToolDefinition, wrapToolDefinitions } from "../tools/tool-definition-wrapper.js";
+import { wrapToolDefinition } from "../tools/tool-definition-wrapper.js";
 /**
  * Wrap a RegisteredTool into an AgentTool.
  * Uses the runner's createContext() for consistent context across tools and event handlers.
  */
 export function wrapRegisteredTool(registeredTool, runner) {
-    return wrapToolDefinition(registeredTool.definition, () => runner.createContext());
+    const tool = wrapToolDefinition(registeredTool.definition, () => runner.createContext());
+    const execute = tool.execute;
+    return {
+        ...tool,
+        execute: async (toolCallId, params, signal, onUpdate) => {
+            const activeBefore = runner.getActiveTools();
+            const result = await execute(toolCallId, params, signal, onUpdate);
+            const activeAfter = runner.getActiveTools();
+            if (!activeBefore.every((name) => activeAfter.includes(name)))
+                return result;
+            const beforeNames = new Set(activeBefore);
+            const addedToolNames = activeAfter.filter((name) => !beforeNames.has(name));
+            if (addedToolNames.length === 0)
+                return result;
+            return {
+                ...result,
+                addedToolNames: [...new Set([...(result.addedToolNames ?? []), ...addedToolNames])],
+            };
+        },
+    };
 }
 /**
  * Wrap all registered tools into AgentTools.
  * Uses the runner's createContext() for consistent context across tools and event handlers.
  */
 export function wrapRegisteredTools(registeredTools, runner) {
-    return wrapToolDefinitions(registeredTools.map((registeredTool) => registeredTool.definition), () => runner.createContext());
+    return registeredTools.map((tool) => wrapRegisteredTool(tool, runner));
 }
 //# sourceMappingURL=wrapper.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/core/keybindings.js

@@ -37,6 +37,10 @@ export const KEYBINDINGS = {
         defaultKeys: "ctrl+g",
         description: "Open external editor",
     },
+    "app.message.copy": {
+        defaultKeys: "ctrl+x",
+        description: "Copy message to clipboard",
+    },
     "app.message.followUp": {
         defaultKeys: "alt+enter",
         description: "Queue follow-up message",
@@ -47,18 +51,18 @@ export const KEYBINDINGS = {
     },
     "app.clipboard.pasteImage": {
         defaultKeys: process.platform === "win32" ? "alt+v" : "ctrl+v",
-        description: "Paste image from clipboard",
+        description: "Paste image from clipboard (text fallback)",
     },
     "app.session.new": { defaultKeys: [], description: "Start a new session" },
     "app.session.tree": { defaultKeys: [], description: "Open session tree" },
     "app.session.fork": { defaultKeys: [], description: "Fork current session" },
     "app.session.resume": { defaultKeys: [], description: "Resume a session" },
     "app.tree.foldOrUp": {
-        defaultKeys: ["ctrl+left", "alt+left"],
+        defaultKeys: process.platform === "darwin" ? ["alt+left", "ctrl+left"] : ["ctrl+left", "alt+left"],
         description: "Fold tree branch or move up",
     },
     "app.tree.unfoldOrDown": {
-        defaultKeys: ["ctrl+right", "alt+right"],
+        defaultKeys: process.platform === "darwin" ? ["alt+right", "ctrl+right"] : ["ctrl+right", "alt+right"],
         description: "Unfold tree branch or move down",
     },
     "app.tree.editLabel": {
@@ -203,15 +207,10 @@ const KEYBINDING_NAME_MIGRATIONS = {
     deleteSession: "app.session.delete",
     deleteSessionNoninvasive: "app.session.deleteNoninvasive",
 };
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function isLegacyKeybindingName(key) {
     return key in KEYBINDING_NAME_MIGRATIONS;
 }
 function toKeybindingsConfig(value) {
-    if (!isRecord(value))
-        return {};
     const config = {};
     for (const [key, binding] of Object.entries(value)) {
         if (typeof binding === "string") {
@@ -260,7 +259,9 @@ function loadRawConfig(path) {
         return undefined;
     try {
         const parsed = JSON.parse(readFileSync(path, "utf-8"));
-        return isRecord(parsed) ? parsed : undefined;
+        if (typeof parsed !== "object" || parsed === null)
+            return undefined;
+        return parsed;
     }
     catch {
         return undefined;

package/node_modules/@earendil-works/pi-coding-agent/dist/core/model-config.js

@@ -0,0 +1,243 @@
+/** Immutable, credential-blind models.json snapshot. */
+import { readFile } from "node:fs/promises";
+import { Type } from "typebox";
+import { Compile } from "typebox/compile";
+import { stripJsonComments } from "../utils/json.js";
+import { normalizePath } from "../utils/paths.js";
+const PercentileCutoffsSchema = Type.Object({
+    p50: Type.Optional(Type.Number()),
+    p75: Type.Optional(Type.Number()),
+    p90: Type.Optional(Type.Number()),
+    p99: Type.Optional(Type.Number()),
+});
+const OpenRouterRoutingSchema = Type.Object({
+    allow_fallbacks: Type.Optional(Type.Boolean()),
+    require_parameters: Type.Optional(Type.Boolean()),
+    data_collection: Type.Optional(Type.Union([Type.Literal("deny"), Type.Literal("allow")])),
+    zdr: Type.Optional(Type.Boolean()),
+    enforce_distillable_text: Type.Optional(Type.Boolean()),
+    order: Type.Optional(Type.Array(Type.String())),
+    only: Type.Optional(Type.Array(Type.String())),
+    ignore: Type.Optional(Type.Array(Type.String())),
+    quantizations: Type.Optional(Type.Array(Type.String())),
+    sort: Type.Optional(Type.Union([
+        Type.String(),
+        Type.Object({
+            by: Type.Optional(Type.String()),
+            partition: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+        }),
+    ])),
+    max_price: Type.Optional(Type.Object({
+        prompt: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+        completion: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+        image: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+        audio: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+        request: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    })),
+    preferred_min_throughput: Type.Optional(Type.Union([Type.Number(), PercentileCutoffsSchema])),
+    preferred_max_latency: Type.Optional(Type.Union([Type.Number(), PercentileCutoffsSchema])),
+});
+const VercelGatewayRoutingSchema = Type.Object({
+    only: Type.Optional(Type.Array(Type.String())),
+    order: Type.Optional(Type.Array(Type.String())),
+});
+const ThinkingLevelMapValueSchema = Type.Union([Type.String(), Type.Null()]);
+const ThinkingLevelMapSchema = Type.Object({
+    off: Type.Optional(ThinkingLevelMapValueSchema),
+    minimal: Type.Optional(ThinkingLevelMapValueSchema),
+    low: Type.Optional(ThinkingLevelMapValueSchema),
+    medium: Type.Optional(ThinkingLevelMapValueSchema),
+    high: Type.Optional(ThinkingLevelMapValueSchema),
+    xhigh: Type.Optional(ThinkingLevelMapValueSchema),
+    max: Type.Optional(ThinkingLevelMapValueSchema),
+});
+const ChatTemplateKwargScalarSchema = Type.Union([Type.String(), Type.Number(), Type.Boolean(), Type.Null()]);
+const ChatTemplateKwargVariableSchema = Type.Object({
+    $var: Type.Union([Type.Literal("thinking.enabled"), Type.Literal("thinking.effort")]),
+    omitWhenOff: Type.Optional(Type.Boolean()),
+});
+const ChatTemplateKwargSchema = Type.Union([ChatTemplateKwargScalarSchema, ChatTemplateKwargVariableSchema]);
+const OpenAICompletionsCompatSchema = Type.Object({
+    supportsStore: Type.Optional(Type.Boolean()),
+    supportsDeveloperRole: Type.Optional(Type.Boolean()),
+    supportsReasoningEffort: Type.Optional(Type.Boolean()),
+    supportsUsageInStreaming: Type.Optional(Type.Boolean()),
+    maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
+    requiresToolResultName: Type.Optional(Type.Boolean()),
+    requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
+    requiresThinkingAsText: Type.Optional(Type.Boolean()),
+    requiresReasoningContentOnAssistantMessages: Type.Optional(Type.Boolean()),
+    thinkingFormat: Type.Optional(Type.Union([
+        Type.Literal("openai"),
+        Type.Literal("openrouter"),
+        Type.Literal("together"),
+        Type.Literal("deepseek"),
+        Type.Literal("zai"),
+        Type.Literal("qwen"),
+        Type.Literal("chat-template"),
+        Type.Literal("qwen-chat-template"),
+        Type.Literal("string-thinking"),
+        Type.Literal("ant-ling"),
+    ])),
+    chatTemplateKwargs: Type.Optional(Type.Record(Type.String(), ChatTemplateKwargSchema)),
+    cacheControlFormat: Type.Optional(Type.Literal("anthropic")),
+    openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
+    vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema),
+    supportsStrictMode: Type.Optional(Type.Boolean()),
+    sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
+    deferredToolsMode: Type.Optional(Type.Literal("kimi")),
+    sessionAffinityFormat: Type.Optional(Type.Union([Type.Literal("openai"), Type.Literal("openai-nosession"), Type.Literal("openrouter")])),
+    supportsLongCacheRetention: Type.Optional(Type.Boolean()),
+});
+const OpenAIResponsesCompatSchema = Type.Object({
+    supportsDeveloperRole: Type.Optional(Type.Boolean()),
+    sessionAffinityFormat: Type.Optional(Type.Union([Type.Literal("openai"), Type.Literal("openai-nosession"), Type.Literal("openrouter")])),
+    supportsLongCacheRetention: Type.Optional(Type.Boolean()),
+    supportsToolSearch: Type.Optional(Type.Boolean()),
+});
+const AnthropicMessagesCompatSchema = Type.Object({
+    supportsEagerToolInputStreaming: Type.Optional(Type.Boolean()),
+    supportsLongCacheRetention: Type.Optional(Type.Boolean()),
+    sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
+    supportsCacheControlOnTools: Type.Optional(Type.Boolean()),
+    forceAdaptiveThinking: Type.Optional(Type.Boolean()),
+    supportsToolReferences: Type.Optional(Type.Boolean()),
+});
+const ProviderCompatSchema = Type.Union([
+    OpenAICompletionsCompatSchema,
+    OpenAIResponsesCompatSchema,
+    AnthropicMessagesCompatSchema,
+]);
+const ModelCostRatesSchema = {
+    input: Type.Number(),
+    output: Type.Number(),
+    cacheRead: Type.Number(),
+    cacheWrite: Type.Number(),
+};
+const ModelCostTierSchema = Type.Object({
+    inputTokensAbove: Type.Number(),
+    ...ModelCostRatesSchema,
+});
+const ModelCostSchema = Type.Object({
+    ...ModelCostRatesSchema,
+    tiers: Type.Optional(Type.Array(ModelCostTierSchema)),
+});
+const ModelDefinitionSchema = Type.Object({
+    id: Type.String({ minLength: 1 }),
+    name: Type.Optional(Type.String({ minLength: 1 })),
+    api: Type.Optional(Type.String({ minLength: 1 })),
+    baseUrl: Type.Optional(Type.String({ minLength: 1 })),
+    reasoning: Type.Optional(Type.Boolean()),
+    thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
+    input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
+    cost: Type.Optional(ModelCostSchema),
+    contextWindow: Type.Optional(Type.Number()),
+    maxTokens: Type.Optional(Type.Number()),
+    headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+    compat: Type.Optional(ProviderCompatSchema),
+});
+const ModelOverrideSchema = Type.Object({
+    name: Type.Optional(Type.String({ minLength: 1 })),
+    reasoning: Type.Optional(Type.Boolean()),
+    thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
+    input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
+    cost: Type.Optional(Type.Object({
+        input: Type.Optional(Type.Number()),
+        output: Type.Optional(Type.Number()),
+        cacheRead: Type.Optional(Type.Number()),
+        cacheWrite: Type.Optional(Type.Number()),
+        tiers: Type.Optional(Type.Array(ModelCostTierSchema)),
+    })),
+    contextWindow: Type.Optional(Type.Number()),
+    maxTokens: Type.Optional(Type.Number()),
+    headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+    compat: Type.Optional(ProviderCompatSchema),
+});
+const ProviderConfigSchema = Type.Object({
+    name: Type.Optional(Type.String({ minLength: 1 })),
+    baseUrl: Type.Optional(Type.String({ minLength: 1 })),
+    apiKey: Type.Optional(Type.String({ minLength: 1 })),
+    api: Type.Optional(Type.String({ minLength: 1 })),
+    oauth: Type.Optional(Type.Literal("radius")),
+    headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+    compat: Type.Optional(ProviderCompatSchema),
+    authHeader: Type.Optional(Type.Boolean()),
+    models: Type.Optional(Type.Array(ModelDefinitionSchema)),
+    modelOverrides: Type.Optional(Type.Record(Type.String(), ModelOverrideSchema)),
+});
+const ModelsConfigSchema = Type.Object({
+    providers: Type.Record(Type.String(), ProviderConfigSchema),
+});
+const validateModelsConfig = Compile(ModelsConfigSchema);
+function formatValidationPath(error) {
+    if (error.keyword === "required") {
+        const requiredProperties = error.params.requiredProperties;
+        const requiredProperty = requiredProperties?.[0];
+        if (requiredProperty) {
+            const basePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+            return basePath ? `${basePath}.${requiredProperty}` : requiredProperty;
+        }
+    }
+    const path = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+    return path || "root";
+}
+function deepFreeze(value) {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value))
+        return value;
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return Object.freeze(value);
+}
+/** One immutable load of models.json. */
+export class ModelConfig {
+    providers;
+    error;
+    constructor(providers, error) {
+        this.providers = providers;
+        this.error = error;
+    }
+    static async load(modelsJsonPath) {
+        if (!modelsJsonPath)
+            return new ModelConfig(new Map());
+        const path = normalizePath(modelsJsonPath);
+        let content;
+        try {
+            content = await readFile(path, "utf-8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return new ModelConfig(new Map());
+            return new ModelConfig(new Map(), `Failed to load models.json: ${error instanceof Error ? error.message : error}\n\nFile: ${path}`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(stripJsonComments(content));
+        }
+        catch (error) {
+            return new ModelConfig(new Map(), `Failed to parse models.json: ${error instanceof Error ? error.message : error}\n\nFile: ${path}`);
+        }
+        if (!validateModelsConfig.Check(parsed)) {
+            const errors = validateModelsConfig
+                .Errors(parsed)
+                .map((error) => `  - ${formatValidationPath(error)}: ${error.message}`)
+                .join("\n") || "Unknown schema error";
+            return new ModelConfig(new Map(), `Invalid models.json schema:\n${errors}\n\nFile: ${path}`);
+        }
+        const config = parsed;
+        const providers = new Map();
+        for (const [providerId, provider] of Object.entries(config.providers)) {
+            providers.set(providerId, deepFreeze(structuredClone(provider)));
+        }
+        return new ModelConfig(providers);
+    }
+    getProvider(providerId) {
+        return this.providers.get(providerId);
+    }
+    getProviderIds() {
+        return [...this.providers.keys()];
+    }
+    getError() {
+        return this.error;
+    }
+}
+//# sourceMappingURL=model-config.js.map