@mcoda/codali 0.1.134 → 0.1.135-codali.4

package/dist/permissions/PermissionGate.js

@@ -0,0 +1,97 @@
+import { createHash, randomUUID } from "node:crypto";
+import { ToolExecutionError } from "../tools/ToolTypes.js";
+const fileRead = new Set(["prepare_edit", "read_file", "list_directory", "list_files", "stat_path", "diff_summary", "search", "search_files", "search_text", "glob", "file_search"]);
+const fileWrite = new Set(["write_file", "apply_patch", "apply_diff", "media_export_artifact"]);
+const controlRead = new Set(["work_status", "work_refine", "work_plan", "work_claim", "work_release", "work_reopen", "work_checkpoint", "work_decision", "work_verify", "work_complete", "work_block"]);
+const executionWork = new Set(["work_claim", "work_verify", "work_complete"]);
+export const isExecutionWorkTool = (name) => executionWork.has(name);
+const docdexReads = /^(docdex_(search|batch_search|rerank|open|files|tree|stats|symbols|ast|repo_inspect|impact_graph|impact_diagnostics|dag_export|memory_recall|get_profile|wakeup|diary_read|capabilities|conversation_search|conversation_read|conversation_list|kg_query))$/;
+export const permissionKind = (tool) => {
+    if (tool.name === "run_shell")
+        return "shell";
+    if (fileWrite.has(tool.name))
+        return "write";
+    if (["tools_discover", "tools_enable"].includes(tool.name))
+        return "read";
+    if (["media_job_status", "media_job_wait", "delegate_helper"].includes(tool.name))
+        return "read";
+    if (tool.name === "media_job_cancel")
+        return "media";
+    if (/image.*generat|audio.*generat|video.*generat|media.*generat/.test(tool.name) || /^(image|audio|video|media)_generation$/.test(tool.capability))
+        return "media";
+    if (tool.name === "docdex_web_research")
+        return "web";
+    if (/^docdex_(memory_save|save_preference|index|diary_write|conversation_import|delegate)/.test(tool.name))
+        return "memory";
+    if ((fileRead.has(tool.name) || docdexReads.test(tool.name)) && tool.readOnly || controlRead.has(tool.name))
+        return "read";
+    return "external";
+};
+export class PermissionGate {
+    constructor(profile = "ask", prompt, options = {}) {
+        this.profile = profile;
+        this.prompt = prompt;
+        this.options = options;
+        this.grants = new Set();
+        this.denials = new Set();
+        this.revision = 1;
+    }
+    inspect() {
+        return { profile: this.profile, revision: this.revision, sessionGrants: this.grants.size, sessionDenials: this.denials.size, shellIsolated: this.options.shellIsolated === true, allowWeb: this.options.allowWeb === true, allowMemory: this.options.allowMemory === true, allowMedia: this.options.allowMedia === true, deniedTools: this.options.deniedTools ?? [] };
+    }
+    setProfile(profile) {
+        if (!["plan", "ask", "workspace"].includes(profile))
+            throw new Error("Unknown permission profile");
+        this.profile = profile;
+        this.revision += 1;
+    }
+    clearGrants() { this.grants.clear(); this.denials.clear(); this.revision += 1; }
+    exportGrants() { return { schemaVersion: 1, grants: [...this.grants], denials: [...this.denials] }; }
+    restoreGrants(value) {
+        if (value.schemaVersion !== 1 || !Array.isArray(value.grants) || !Array.isArray(value.denials) || [...value.grants, ...value.denials].some(key => typeof key !== "string" || !/^[a-f0-9]{64}$/.test(key)))
+            throw new Error("Invalid permission grant record");
+        this.grants = new Set(value.grants);
+        this.denials = new Set(value.denials);
+        this.revision += 1;
+    }
+    async authorize(tool, args, signal) {
+        signal?.throwIfAborted();
+        const kind = permissionKind(tool);
+        const key = createHash("sha256").update(JSON.stringify([tool.name, kind, args])).digest("hex");
+        const deny = (reason) => { throw new ToolExecutionError("tool_permission_denied", reason, { retryable: false, details: { tool: tool.name, kind } }); };
+        if (this.options.deniedTools?.includes(tool.name) || this.denials.has(key))
+            deny("Operation explicitly denied");
+        if (this.profile === "plan" && isExecutionWorkTool(tool.name))
+            deny("Planning mode cannot claim, verify or complete execution tasks; record the plan and leave the goal open");
+        if (kind === "read")
+            return;
+        if (this.profile === "plan")
+            deny("Planning mode permits read operations only");
+        if (kind === "web" && this.options.allowWeb)
+            return;
+        if (kind === "memory" && this.options.allowMemory)
+            return;
+        if (kind === "media" && this.options.allowMedia)
+            return;
+        if (kind === "shell" && !this.options.shellIsolated)
+            deny("An isolated shell executor is required; run codali doctor");
+        if (this.profile === "workspace" && (kind === "write" || kind === "shell"))
+            return;
+        if (this.grants.has(key))
+            return;
+        if (!this.prompt)
+            deny("Permission is required; interactive approval or an applicable grant is unavailable");
+        const revision = this.revision;
+        const answer = await this.prompt({ id: randomUUID(), tool: tool.name, kind, args, reason: `Allow ${kind} operation ${tool.name}?` }, signal);
+        signal?.throwIfAborted();
+        if (revision !== this.revision)
+            return this.authorize(tool, args, signal);
+        if (!answer.allow) {
+            if (answer.scope === "session")
+                this.denials.add(key);
+            deny("Operation denied by user");
+        }
+        if (answer.scope === "session")
+            this.grants.add(key);
+    }
+}

package/dist/providers/ConfiguredEmbeddings.d.ts

@@ -0,0 +1,43 @@
+import { type ResolvedOrchestrationConfig } from "../config/OrchestrationConfig.js";
+export interface EmbeddingReceipt {
+    id: string;
+    modelId: string;
+    catalogId: string;
+    spaceId: string;
+    configHash: string;
+    purpose: "query" | "document";
+    inputs: number;
+    reportedTokens?: number;
+    elapsedMs: number;
+    status: "succeeded" | "failed";
+    failureCode?: "aborted" | "request_failed" | "upstream_error" | "invalid_response";
+}
+export interface EmbeddingIntent {
+    id: string;
+    modelId: string;
+    catalogId: string;
+    spaceId: string;
+    inputs: number;
+    estimatedTokens: number;
+}
+/** Owns embedding identity; network retries after dispatch are deliberately left to the caller. */
+export declare class ConfiguredEmbeddings {
+    readonly resolved: ResolvedOrchestrationConfig;
+    private readonly onReceipt?;
+    private readonly beforeRequest?;
+    readonly space: {
+        id: string;
+        queryPrefix: string;
+        documentPrefix: string;
+        normalization: "none" | "l2";
+        pooling: string;
+        revision: string;
+        dimensions: number;
+        label: string;
+    };
+    private readonly router;
+    constructor(resolved: ResolvedOrchestrationConfig, onReceipt?: ((receipt: EmbeddingReceipt) => Promise<void>) | undefined, beforeRequest?: ((intent: EmbeddingIntent) => Promise<void>) | undefined);
+    pin(directory: string): Promise<void>;
+    embed(input: string[], purpose: "query" | "document", signal?: AbortSignal): Promise<number[][]>;
+}
+//# sourceMappingURL=ConfiguredEmbeddings.d.ts.map

package/dist/providers/ConfiguredEmbeddings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfiguredEmbeddings.d.ts","sourceRoot":"","sources":["../../src/providers/ConfiguredEmbeddings.ts"],"names":[],"mappings":"AAIA,OAAO,EAA4B,KAAK,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAI9G,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IACpF,OAAO,EAAE,OAAO,GAAG,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAC1F,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC/B,WAAW,CAAC,EAAE,SAAS,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,kBAAkB,CAAC;CACpF;AACD,MAAM,WAAW,eAAe;IAAG,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;CAAE;AAE9I,mGAAmG;AACnG,qBAAa,oBAAoB;IAGnB,QAAQ,CAAC,QAAQ,EAAE,2BAA2B;IAAE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;IACrF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;IAHjC,QAAQ,CAAC,KAAK;;;;;;;;;MAAC;IACf,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;gBACvB,QAAQ,EAAE,2BAA2B,EAAmB,SAAS,CAAC,GAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,IAAI,CAAC,aAAA,EAClH,aAAa,CAAC,GAAE,CAAC,MAAM,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,aAAA;IAKvE,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYrC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,UAAU,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;CAiDvG"}

package/dist/providers/ConfiguredEmbeddings.js

@@ -0,0 +1,87 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { validateEmbeddingRequest, validateEmbeddingResponse } from "@mcoda/shared";
+import { configuredEmbeddingSpace } from "../config/OrchestrationConfig.js";
+import { atomicWriteJson, withStateLock } from "../session/AtomicState.js";
+import { ConfiguredProvider } from "./ConfiguredProvider.js";
+/** Owns embedding identity; network retries after dispatch are deliberately left to the caller. */
+export class ConfiguredEmbeddings {
+    constructor(resolved, onReceipt, beforeRequest) {
+        this.resolved = resolved;
+        this.onReceipt = onReceipt;
+        this.beforeRequest = beforeRequest;
+        this.space = configuredEmbeddingSpace(resolved.config);
+        this.router = new ConfiguredProvider(resolved, "embedding");
+    }
+    async pin(directory) {
+        const file = path.join(directory, "embedding-space.json");
+        await withStateLock(file, async () => {
+            try {
+                const previous = JSON.parse(await fs.readFile(file, "utf8"));
+                if (previous.schemaVersion !== 1 || previous.space?.id !== this.space.id)
+                    throw new Error("Embedding space changed; rebuild into a separate index before using this configuration");
+                return;
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            await atomicWriteJson(file, { schemaVersion: 1, space: this.space, createdAt: new Date().toISOString() });
+        });
+    }
+    async embed(input, purpose, signal) {
+        const prefix = purpose === "query" ? this.space.queryPrefix : this.space.documentPrefix;
+        const prepared = validateEmbeddingRequest({ input: input.map(text => prefix + text) }, "pending");
+        const selected = await this.router.select("embeddings", signal);
+        const descriptor = Array.isArray(selected.actual.raw.operations)
+            ? selected.actual.raw.operations.find(value => value && typeof value === "object" && value.type === "embeddings") : undefined;
+        if (selected.provider.adapter === "mswarm" && (!descriptor || descriptor.limits?.embedding_dimensions !== this.space.dimensions)) {
+            throw new Error("Embedding catalog does not attest the configured dimensions");
+        }
+        if (selected.provider.adapter === "mswarm" && selected.actual.raw.digest !== this.space.revision)
+            throw new Error("Embedding catalog revision does not match the pinned artifact");
+        const started = Date.now();
+        const id = randomUUID();
+        await this.beforeRequest?.({ id, modelId: selected.id, catalogId: selected.model.catalogId, spaceId: this.space.id,
+            inputs: input.length, estimatedTokens: Math.ceil(JSON.stringify(prepared.input).length / 3) });
+        const receipt = { id, modelId: selected.id, catalogId: selected.model.catalogId,
+            spaceId: this.space.id, configHash: this.resolved.hash, purpose, inputs: input.length };
+        let failureCode = "request_failed";
+        let vectors;
+        let reportedTokens;
+        try {
+            const payload = await this.router.client(selected.model.provider).json(`${selected.provider.baseUrl.replace(/\/$/, "")}/embeddings`, {
+                method: "POST", body: { ...prepared, model: selected.model.catalogId }, signal, timeoutMs: 120000,
+            });
+            // A relay may start a 200 keepalive before native execution fails.
+            // Do not expose upstream messages, which can contain private input.
+            if (payload && typeof payload === "object" && "error" in payload) {
+                failureCode = "upstream_error";
+                throw new Error("Embedding upstream execution failed");
+            }
+            failureCode = "invalid_response";
+            const result = validateEmbeddingResponse(payload, input.length, this.space.dimensions, selected.model.catalogId);
+            if (selected.provider.adapter === "mswarm" && payload.embedding_revision !== this.space.revision)
+                throw new Error("Embedding response revision changed after selection");
+            vectors = result.data.map(item => {
+                if (this.space.normalization === "none")
+                    return item.embedding;
+                const scale = Math.max(...item.embedding.map(Math.abs));
+                if (!scale)
+                    throw new Error("Embedding model returned a zero vector");
+                const norm = Math.sqrt(item.embedding.reduce((sum, value) => sum + (value / scale) ** 2, 0));
+                return item.embedding.map(value => value / scale / norm);
+            });
+            reportedTokens = result.usage?.total_tokens;
+        }
+        catch (error) {
+            await this.onReceipt?.({ ...receipt, status: "failed", failureCode: signal?.aborted ? "aborted" : failureCode,
+                elapsedMs: Date.now() - started });
+            throw error;
+        }
+        await this.onReceipt?.({ ...receipt, status: "succeeded",
+            ...(reportedTokens !== undefined ? { reportedTokens } : {}), elapsedMs: Date.now() - started });
+        return vectors;
+    }
+}

package/dist/providers/ConfiguredModelScope.d.ts

@@ -0,0 +1,69 @@
+import { type EffortLevel, type ResolvedOrchestrationConfig } from "../config/OrchestrationConfig.js";
+import { type ModelCallerContext, type ModelInvocation } from "./ConfiguredProvider.js";
+import type { Provider, ProviderUsage } from "./ProviderTypes.js";
+export interface ScopedModelUsage {
+    modelCalls: number;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    estimated: boolean;
+    pendingCalls: number;
+}
+export interface ScopedModelEvent {
+    type: "intent" | "receipt";
+    id: string;
+    binding: string;
+    configHash: string;
+    route?: ModelInvocation;
+    status: "pending" | "success" | "failed";
+    usage: ScopedModelUsage;
+}
+/** Invalid upstream accounting cannot lower a shared budget or turn it into NaN. */
+export declare const verifiedTokenUsage: (usage?: ProviderUsage) => {
+    input?: number;
+    output?: number;
+    total: number;
+} | undefined;
+/** One model budget/deadline for one embedded gateway or pipeline invocation. */
+export declare class ConfiguredModelScope {
+    private readonly options;
+    private readonly resolved;
+    private readonly controller;
+    private readonly timer;
+    private readonly limits;
+    private readonly stop;
+    private readonly pending;
+    private toolCalls;
+    private readonly usage;
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    constructor(resolved: ResolvedOrchestrationConfig, options?: {
+        effort?: EffortLevel;
+        signal?: AbortSignal;
+        caller?: ModelCallerContext;
+        onEvent?: (event: ScopedModelEvent) => Promise<void> | void;
+        credentials?: Readonly<Record<string, string>>;
+    });
+    get signal(): AbortSignal;
+    get configHash(): string;
+    get effort(): EffortLevel;
+    matchesCaller(caller: ModelCallerContext): boolean;
+    budget(): {
+        maxSteps: number;
+        maxToolCalls: number;
+        maxModelCalls: number;
+        maxTotalTokens: number;
+        maxOutputTokens: number;
+        timeoutMs: number;
+    };
+    get toolsUsed(): number;
+    reserveTool(): void;
+    models(binding: string): {
+        id: string;
+        model: import("../config/OrchestrationConfig.js").OrchestrationModel;
+    }[];
+    snapshot(): ScopedModelUsage;
+    close(): void;
+    provider(binding: string): Provider;
+    private generate;
+}
+//# sourceMappingURL=ConfiguredModelScope.d.ts.map

package/dist/providers/ConfiguredModelScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfiguredModelScope.d.ts","sourceRoot":"","sources":["../../src/providers/ConfiguredModelScope.ts"],"names":[],"mappings":"AACA,OAAO,EAAwD,KAAK,WAAW,EAAE,KAAK,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAC5J,OAAO,EAA4C,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAClI,OAAO,KAAK,EAAE,QAAQ,EAAqC,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAErG,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IACnF,SAAS,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;CAC1C;AACD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IACzC,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAED,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,GAAI,QAAQ,aAAa,KAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAQ/G,CAAC;AAEF,iFAAiF;AACjF,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2L;IACnN,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IACvD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyB;IACpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2H;IACjJ,QAAQ,CAAC,EAAE,sDAAgB;gBAEf,QAAQ,EAAE,2BAA2B,EAAE,OAAO,GAAE;QAC1D,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,MAAM,CAAC,EAAE,kBAAkB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QACrI,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;KAC3C;IAWN,IAAI,MAAM,IAAI,WAAW,CAAmC;IAC5D,IAAI,UAAU,IAAI,MAAM,CAA+B;IACvD,IAAI,MAAM,IAAI,WAAW,CAA4C;IACrE,aAAa,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO;IAClD,MAAM;;;;;;;;IACN,IAAI,SAAS,IAAI,MAAM,CAA2B;IAClD,WAAW,IAAI,IAAI;IASnB,MAAM,CAAC,OAAO,EAAE,MAAM;;;;IACtB,QAAQ,IAAI,gBAAgB;IAC5B,KAAK,IAAI,IAAI;IAEb,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ;YAKrB,QAAQ;CA2CvB"}

package/dist/providers/ConfiguredModelScope.js

@@ -0,0 +1,113 @@
+import { randomUUID } from "node:crypto";
+import { effortBudget, pinOrchestrationConfig, resolveBinding } from "../config/OrchestrationConfig.js";
+import { ConfiguredProvider, normalizeModelCaller } from "./ConfiguredProvider.js";
+/** Invalid upstream accounting cannot lower a shared budget or turn it into NaN. */
+export const verifiedTokenUsage = (usage) => {
+    const valid = (value) => Number.isSafeInteger(value) && value >= 0;
+    if (!usage)
+        return undefined;
+    for (const value of [usage.inputTokens, usage.outputTokens, usage.totalTokens])
+        if (value !== undefined && !valid(value))
+            return undefined;
+    const sum = usage.inputTokens !== undefined && usage.outputTokens !== undefined ? usage.inputTokens + usage.outputTokens : undefined;
+    const total = usage.totalTokens ?? sum;
+    if (!valid(total) || total < (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0))
+        return undefined;
+    return { input: usage.inputTokens, output: usage.outputTokens, total };
+};
+/** One model budget/deadline for one embedded gateway or pipeline invocation. */
+export class ConfiguredModelScope {
+    constructor(resolved, options = {}) {
+        this.controller = new AbortController();
+        this.pending = new Map();
+        this.toolCalls = 0;
+        this.usage = { modelCalls: 0, inputTokens: 0, outputTokens: 0, totalTokens: 0, estimated: false, pendingCalls: 0 };
+        this.id = randomUUID();
+        this.options = { ...options, caller: normalizeModelCaller(options.caller), credentials: Object.freeze(Object.assign(Object.create(null), options.credentials)) };
+        this.resolved = pinOrchestrationConfig(resolved);
+        this.limits = effortBudget(this.resolved.config, options.effort ?? "medium");
+        this.stop = () => this.controller.abort(this.options.signal?.reason ?? new Error("Model scope cancelled"));
+        options.signal?.addEventListener("abort", this.stop, { once: true });
+        if (options.signal?.aborted)
+            this.stop();
+        this.timer = setTimeout(() => this.controller.abort(new Error("Shared model deadline exceeded")), this.limits.timeoutMs);
+        this.timer.unref();
+    }
+    get signal() { return this.controller.signal; }
+    get configHash() { return this.resolved.hash; }
+    get effort() { return this.options.effort ?? "medium"; }
+    matchesCaller(caller) { return JSON.stringify(normalizeModelCaller(caller)) === JSON.stringify(this.options.caller); }
+    budget() { return { ...this.limits }; }
+    get toolsUsed() { return this.toolCalls; }
+    reserveTool() {
+        this.signal.throwIfAborted();
+        if (this.toolCalls >= this.limits.maxToolCalls) {
+            const error = new Error("Shared orchestration tool budget exhausted");
+            this.controller.abort(error);
+            throw error;
+        }
+        this.toolCalls++;
+    }
+    models(binding) { return structuredClone(resolveBinding(this.resolved.config, binding, "chat.completions")); }
+    snapshot() { return { ...this.usage, pendingCalls: this.pending.size, estimated: this.usage.estimated || this.pending.size > 0 }; }
+    close() { clearTimeout(this.timer); this.options.signal?.removeEventListener("abort", this.stop); this.controller.abort(new Error("Model scope closed")); }
+    provider(binding) {
+        resolveBinding(this.resolved.config, binding, "chat.completions");
+        return { name: `configured:${binding}`, supportsToolCalls: true, generate: request => this.generate(binding, request) };
+    }
+    async generate(binding, request) {
+        this.signal.throwIfAborted();
+        request.signal?.throwIfAborted();
+        const linked = new AbortController();
+        const stopScope = () => linked.abort(this.signal.reason);
+        const stopRequest = () => linked.abort(request.signal?.reason);
+        this.signal.addEventListener("abort", stopScope, { once: true });
+        request.signal?.addEventListener("abort", stopRequest, { once: true });
+        let invocation;
+        const provider = new ConfiguredProvider(this.resolved, binding, {
+            caller: this.options.caller,
+            credentials: this.options.credentials,
+            effort: this.options.effort,
+            beforeRequest: async (route, bounded) => {
+                linked.signal.throwIfAborted();
+                const reservation = Math.ceil(JSON.stringify([bounded.messages, bounded.tools]).length / 3) + (bounded.maxTokens ?? this.limits.maxOutputTokens);
+                if (this.usage.modelCalls >= this.limits.maxModelCalls || this.usage.totalTokens + reservation > this.limits.maxTotalTokens)
+                    throw new Error("Shared model budget exhausted");
+                invocation = route;
+                this.usage.modelCalls++;
+                this.usage.totalTokens += reservation;
+                this.pending.set(route.id, reservation);
+                await this.options.onEvent?.({ type: "intent", id: route.id, binding, configHash: this.resolved.hash, route, status: "pending", usage: this.snapshot() });
+            },
+        });
+        try {
+            const response = await provider.generate({ ...request, signal: linked.signal, maxTokens: Math.min(request.maxTokens ?? this.limits.maxOutputTokens, this.limits.maxOutputTokens) });
+            linked.signal.throwIfAborted();
+            if (!invocation)
+                throw new Error("Configured provider did not reserve its invocation");
+            const reported = verifiedTokenUsage(response.usage);
+            if (reported) {
+                this.usage.totalTokens += reported.total - this.pending.get(invocation.id);
+                this.usage.inputTokens += reported.input ?? 0;
+                this.usage.outputTokens += reported.output ?? 0;
+            }
+            else
+                this.usage.estimated = true;
+            this.pending.delete(invocation.id);
+            await this.options.onEvent?.({ type: "receipt", id: invocation.id, binding, configHash: this.resolved.hash, route: invocation, status: "success", usage: this.snapshot() });
+            return response;
+        }
+        catch (error) {
+            // A submitted request is never replayed; an unknown bill keeps its reservation.
+            if (invocation && this.pending.has(invocation.id)) {
+                this.usage.estimated = true;
+                await this.options.onEvent?.({ type: "receipt", id: invocation.id, binding, configHash: this.resolved.hash, route: invocation, status: "failed", usage: this.snapshot() });
+            }
+            throw error;
+        }
+        finally {
+            this.signal.removeEventListener("abort", stopScope);
+            request.signal?.removeEventListener("abort", stopRequest);
+        }
+    }
+}

package/dist/providers/ConfiguredProvider.d.ts

@@ -0,0 +1,79 @@
+import { type OrchestrationProvider, type ResolvedOrchestrationConfig, type ModelOperation, type EffortLevel } from "../config/OrchestrationConfig.js";
+import type { Provider, ProviderRequest, ProviderResponse } from "./ProviderTypes.js";
+export interface CatalogEntry {
+    id: string;
+    aliases: string[];
+    backend?: string;
+    health: string;
+    supportsTools: boolean;
+    contextWindow?: number;
+    operations: string[];
+    raw: Record<string, unknown>;
+}
+/** Authenticated host context, separate from user/model supplied request bodies. */
+export interface ModelCallerContext {
+    clientIdentity?: string;
+    clientProduct?: string;
+}
+export declare const normalizeModelCaller: (caller?: ModelCallerContext) => ModelCallerContext;
+/** Discovery failed before inference; a caller may release its local token reservation. */
+export declare class NativeReasoningTransportError extends Error {
+    constructor(message: string);
+}
+export declare const providerCredential: (provider: OrchestrationProvider) => Promise<string | undefined>;
+export declare class ModelServiceClient {
+    readonly provider: OrchestrationProvider;
+    private readonly credentialOverride?;
+    private cache?;
+    private readonly caller;
+    constructor(provider: OrchestrationProvider, credentialOverride?: string | undefined, caller?: ModelCallerContext);
+    private credential;
+    json(url: string, options?: {
+        signal?: AbortSignal;
+        method?: string;
+        body?: unknown;
+        timeoutMs?: number;
+    }): Promise<unknown>;
+    catalog(signal?: AbortSignal, refresh?: boolean): Promise<CatalogEntry[]>;
+    usage(signal?: AbortSignal): Promise<unknown>;
+    /** The proxy and selected node must both advertise this transport contract.
+     * A model's supports_reasoning flag alone says nothing about request forwarding. */
+    requireNativeReasoning(modelId: string, parameters: string[], signal?: AbortSignal): Promise<void>;
+}
+export interface ModelInvocation {
+    id: string;
+    binding: string;
+    configHash: string;
+    modelId: string;
+    catalogId: string;
+    backend?: string;
+    host?: string;
+    nativeReasoningRequest?: Record<string, unknown>;
+}
+export declare class ConfiguredProvider implements Provider {
+    readonly resolved: ResolvedOrchestrationConfig;
+    readonly binding: string;
+    private readonly options;
+    readonly name = "configured";
+    readonly supportsToolCalls = true;
+    private clients;
+    private readonly caller;
+    private readonly credentials;
+    constructor(resolved: ResolvedOrchestrationConfig, binding?: string, options?: {
+        caller?: ModelCallerContext;
+        /** Trusted host credential resolution; never accepted from a request/config document. */
+        credentials?: Readonly<Record<string, string>>;
+        effort?: EffortLevel;
+        beforeRequest?: (invocation: ModelInvocation, request: ProviderRequest) => Promise<void>;
+        afterRequest?: (invocation: ModelInvocation, response: ProviderResponse) => Promise<void>;
+    });
+    client(providerId: string): ModelServiceClient;
+    select(operation: ModelOperation, signal?: AbortSignal, requireTools?: boolean): Promise<{
+        id: string;
+        model: import("../config/OrchestrationConfig.js").OrchestrationModel;
+        actual: CatalogEntry;
+        provider: OrchestrationProvider;
+    }>;
+    generate(request: ProviderRequest): Promise<ProviderResponse>;
+}
+//# sourceMappingURL=ConfiguredProvider.d.ts.map

package/dist/providers/ConfiguredProvider.d.ts.map

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