@inhuman.tools/harness 0.1.0 → 0.3.0

package/dist/drivers/openai-compat/openai-compat-driver.js

@@ -1,843 +0,0 @@
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
-    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-};
-import { createStreamSession, normalizeMessage } from "@inhuman.tools/tool-call-normalize";
-import { action, autorun, observable, runInAction } from "mobx";
-import invariant from "tiny-invariant";
-import { ExpectationActor, PEWDriverConnection, } from "@inhuman.tools/plexus-expectations/driver";
-import { asAdoptString, } from "../adopt.js";
-import { remember, viewWire, worldFor, recallMessagesOf, toolsFor, } from "./lineage.js";
-import { parseModelCatalog, usageTotalTokens } from "./model-catalog.js";
-import { labelFromSettings, openaiCompatConfigurationSchema, openaiCompatSecretsSchema, } from "./config.js";
-import { advertisedOffers, nameFromBaseUrl } from "./presence.js";
-import { accountGetterFor, paintAccountHint } from "./account-look.js";
-import { maskSecret } from "./api-extensions/index.js";
-import { ARG_ALIASES } from "../toolkit/catalog.js";
-function isGenericCompatName(name) {
-    return name === "" || name === "openai-compat" || name === "OpenAI-compatible";
-}
-function compatAdoptName(given, baseUrl) {
-    const fallback = (given ?? "").trim();
-    if (isGenericCompatName(fallback))
-        return nameFromBaseUrl(baseUrl) ?? (fallback || "openai-compat");
-    return fallback;
-}
-function catalogToolDefs(expectation) {
-    return toolsFor(expectation).map((tool) => ({
-        name: tool.function.name,
-        parameters: tool.function.parameters,
-    }));
-}
-const HEALTH_MS = 30_000;
-const ACCOUNT_STALE_MS = 45_000;
-/** Anthropic/OpenAI prompt-cache default. */
-const PROMPT_CACHE_TTL_MS = 5 * 60 * 1000;
-/** Local OpenAI-compat (LM Studio / Ollama) answers in milliseconds. */
-export const LOCAL_HANDSHAKE_MS = 2_500;
-/** Remote catalogs (OpenRouter, Grok proxy, ChatGPT) need a real RTT. */
-export const REMOTE_HANDSHAKE_MS = 60_000;
-export function handshakeTimeoutMs(url) {
-    try {
-        const host = new URL(url).hostname;
-        if (host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]")
-            return LOCAL_HANDSHAKE_MS;
-    }
-    catch {
-        /* keep remote */
-    }
-    return REMOTE_HANDSHAKE_MS;
-}
-function extractReasoning(message) {
-    if (!message)
-        return "";
-    if (typeof message.reasoning_content === "string" && message.reasoning_content.length > 0) {
-        return message.reasoning_content;
-    }
-    if (typeof message.reasoning === "string" && message.reasoning.length > 0) {
-        return message.reasoning;
-    }
-    return "";
-}
-function asChatChunk(raw) {
-    if (typeof raw !== "object" || raw === null)
-        return null;
-    const rec = raw;
-    const choice = rec.choices?.[0];
-    const delta = choice?.delta;
-    if (!delta)
-        return rec;
-    const alt = typeof delta.reasoning === "string"
-        ? delta.reasoning
-        : "";
-    if (alt.length > 0 &&
-        !(typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0)) {
-        return {
-            ...rec,
-            choices: [
-                {
-                    ...choice,
-                    delta: { ...delta, reasoning_content: alt },
-                },
-                ...(rec.choices?.slice(1) ?? []),
-            ],
-        };
-    }
-    return rec;
-}
-async function* readSseJson(body, signal) {
-    if (!body)
-        return;
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buf = "";
-    try {
-        while (!signal.aborted) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buf += decoder.decode(value, { stream: true });
-            for (;;) {
-                const sep = buf.indexOf("\n\n");
-                if (sep < 0)
-                    break;
-                const event = buf.slice(0, sep);
-                buf = buf.slice(sep + 2);
-                for (const line of event.split(/\r?\n/)) {
-                    const trimmed = line.trimEnd();
-                    if (!trimmed.startsWith("data:"))
-                        continue;
-                    const data = trimmed.slice(5).trimStart();
-                    if (!data || data === "[DONE]") {
-                        if (data === "[DONE]")
-                            return;
-                        continue;
-                    }
-                    try {
-                        yield JSON.parse(data);
-                    }
-                    catch {
-                        // skip malformed line
-                    }
-                }
-            }
-        }
-        if (buf.trim().length > 0) {
-            for (const line of buf.split(/\r?\n/)) {
-                const trimmed = line.trimEnd();
-                if (!trimmed.startsWith("data:"))
-                    continue;
-                const data = trimmed.slice(5).trimStart();
-                if (!data || data === "[DONE]")
-                    continue;
-                try {
-                    yield JSON.parse(data);
-                }
-                catch {
-                    /* skip */
-                }
-            }
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-}
-/** OpenAI-compat extras: invocation catalog plus the account/key face. */
-export function openaiCompatLiveState() {
-    return {
-        catalogName: "",
-        account: undefined,
-        keyMask: "",
-        /** Handshake model ids — invocation arguments this connection will take. */
-        models: [],
-        /** Known context windows keyed by model id. Sparse — omit when the host did not say. */
-        windows: {},
-    };
-}
-function isBulkJsonBody(contentType, head) {
-    const ct = contentType.toLowerCase();
-    if (ct.includes("text/event-stream") || ct.includes("event-stream"))
-        return false;
-    if (ct.includes("application/json"))
-        return true;
-    const t = head.trimStart();
-    return t.startsWith("{") || t.startsWith("[");
-}
-let OpenAiCompatDriverConnection = (() => {
-    var _a;
-    let _classSuper = PEWDriverConnection;
-    let _instanceExtraInitializers = [];
-    let _state_decorators;
-    let _state_initializers = [];
-    let _state_extraInitializers = [];
-    let _private_stampWindow_decorators;
-    let _private_stampWindow_descriptor;
-    let _private_stampConsumed_decorators;
-    let _private_stampConsumed_descriptor;
-    let _private_stampWarm_decorators;
-    let _private_stampWarm_descriptor;
-    let _reportLive_decorators;
-    let _private_noteOk_decorators;
-    let _private_noteOk_descriptor;
-    let _private_noteFail_decorators;
-    let _private_noteFail_descriptor;
-    return class OpenAiCompatDriverConnection extends _classSuper {
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            __esDecorate(this, null, _state_decorators, { kind: "accessor", name: "state", static: false, private: false, access: { has: obj => "state" in obj, get: obj => obj.state, set: (obj, value) => { obj.state = value; } }, metadata: _metadata }, _state_initializers, _state_extraInitializers);
-            __esDecorate(this, _private_stampWindow_descriptor = { value: __setFunctionName(function (expectation) {
-                    const limit = this.state.windows[this.#effectiveModel()] ?? 0;
-                    if (limit <= 0)
-                        return;
-                    expectation.contextLimit = limit;
-                }, "#stampWindow") }, _private_stampWindow_decorators, { kind: "method", name: "#stampWindow", static: false, private: true, access: { has: obj => #stampWindow in obj, get: obj => obj.#stampWindow }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, _private_stampConsumed_descriptor = { value: __setFunctionName(function (expectation, raw) {
-                    const total = usageTotalTokens(raw);
-                    if (total == null)
-                        return;
-                    expectation.totalTokens = total;
-                }, "#stampConsumed") }, _private_stampConsumed_decorators, { kind: "method", name: "#stampConsumed", static: false, private: true, access: { has: obj => #stampConsumed in obj, get: obj => obj.#stampConsumed }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, _private_stampWarm_descriptor = { value: __setFunctionName(function (expectation) {
-                    expectation.warmUntil = new Date(Date.now() + PROMPT_CACHE_TTL_MS);
-                }, "#stampWarm") }, _private_stampWarm_decorators, { kind: "method", name: "#stampWarm", static: false, private: true, access: { has: obj => #stampWarm in obj, get: obj => obj.#stampWarm }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _reportLive_decorators, { kind: "method", name: "reportLive", static: false, private: false, access: { has: obj => "reportLive" in obj, get: obj => obj.reportLive }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, _private_noteOk_descriptor = { value: __setFunctionName(function () {
-                    this.readyState = "ready";
-                    this.error = "";
-                }, "#noteOk") }, _private_noteOk_decorators, { kind: "method", name: "#noteOk", static: false, private: true, access: { has: obj => #noteOk in obj, get: obj => obj.#noteOk }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, _private_noteFail_descriptor = { value: __setFunctionName(function (error) {
-                    this.readyState = "failed";
-                    this.error = error instanceof Error ? error.message : String(error);
-                }, "#noteFail") }, _private_noteFail_decorators, { kind: "method", name: "#noteFail", static: false, private: true, access: { has: obj => #noteFail in obj, get: obj => obj.#noteFail }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        }
-        static configurationSchema = openaiCompatConfigurationSchema;
-        static secretsSchema = openaiCompatSecretsSchema;
-        static configurationLabel = "openai-compat";
-        static offers = advertisedOffers();
-        static async adopt(args, callback) {
-            const settings = { ...(args.settings ?? {}) };
-            const hadBaseUrl = asAdoptString(settings.baseUrl) !== "";
-            let baseUrl = asAdoptString(settings.baseUrl);
-            if (!hadBaseUrl) {
-                const { input } = await callback("UI", '(harness/input :name "Base URL" :description "OpenAI-compatible endpoint")');
-                baseUrl = asAdoptString(input);
-            }
-            settings.baseUrl = baseUrl;
-            const secrets = {};
-            if (!hadBaseUrl) {
-                const { input: apiKey } = await callback("UI", '(harness/input :name "API key" :description "Optional. Empty to skip." :secret #t)');
-                const key = asAdoptString(apiKey);
-                if (key !== "")
-                    secrets.apiKey = key;
-            }
-            return { name: compatAdoptName(args.name, baseUrl), settings, secrets };
-        }
-        #baseUrl = (__runInitializers(this, _instanceExtraInitializers), "");
-        #model = "";
-        #headers = {};
-        #temperature;
-        #apiKey;
-        #lineage = new WeakMap();
-        #healthy = false;
-        #abort = null;
-        #emit;
-        #turnModel = null;
-        #healthTimer = null;
-        #accountLoop = null;
-        #accountInflight = null;
-        #accountStop = null;
-        #account;
-        #state_accessor_storage = __runInitializers(this, _state_initializers, openaiCompatLiveState());
-        get state() { return this.#state_accessor_storage; }
-        set state(value) { this.#state_accessor_storage = value; }
-        get alive() {
-            return this.#healthy;
-        }
-        async bootstrap() {
-            this.#baseUrl = this.settings.baseUrl;
-            this.#model = this.settings.model ?? "";
-            this.#headers = this.settings.headers ?? {};
-            this.#temperature = this.settings.temperature;
-            this.#apiKey = this.#secret("apiKey");
-            this.#healthy = false;
-            this.reportLive();
-            await this.#probe();
-            this.#healthTimer = setInterval(() => {
-                void this.#probe().catch((error) => this.#noteFail(error));
-            }, HEALTH_MS);
-            this.#healthTimer.unref?.();
-            this.#accountStop = autorun(() => {
-                if (this.attention === "none") {
-                    this.#stopAccountLoop();
-                    return;
-                }
-                void this.#refreshAccount();
-                if (this.#accountLoop !== null || accountGetterFor(this.#baseUrl) === undefined)
-                    return;
-                this.#accountLoop = setInterval(() => {
-                    void this.#refreshAccount();
-                }, ACCOUNT_STALE_MS);
-                this.#accountLoop.unref?.();
-            });
-        }
-        modelsRequestUrl() {
-            return `${this.#baseUrl}/models`;
-        }
-        completionRequestUrl() {
-            return `${this.#baseUrl}/chat/completions`;
-        }
-        completionApi() {
-            return "chat";
-        }
-        async #probe() {
-            const url = this.modelsRequestUrl();
-            let response;
-            try {
-                response = await this.#fetchWithTimeout(url, { headers: this.#requestHeaders() }, handshakeTimeoutMs(url));
-            }
-            catch (error) {
-                this.#noteFail(error);
-                throw error instanceof Error ? error : new Error(String(error));
-            }
-            if (!response.ok) {
-                const error = new Error(`openai-compat handshake failed: ${response.status}`);
-                this.#noteFail(error);
-                throw error;
-            }
-            const catalog = parseModelCatalog(await response.json());
-            this.state.models = catalog.ids;
-            this.state.windows = catalog.windows;
-            this.#noteOk();
-            this.#healthy = true;
-        }
-        get #stampWindow() { return _private_stampWindow_descriptor.value; }
-        get #stampConsumed() { return _private_stampConsumed_descriptor.value; }
-        get #stampWarm() { return _private_stampWarm_descriptor.value; }
-        reportLive() {
-            this.state.catalogName = this.connectionCatalogName();
-            this.state.account = this.#account;
-            this.state.keyMask = this.connectionKeyMask();
-        }
-        connectionCatalogName() {
-            return labelFromSettings(this.connectionId, this.settings);
-        }
-        connectionKeyMask() {
-            if (this.#account !== undefined)
-                return paintAccountHint(this.#account, this.#apiKey);
-            if (this.#apiKey === undefined || this.#apiKey === "")
-                return "";
-            return maskSecret(this.#apiKey);
-        }
-        #stopAccountLoop() {
-            if (this.#accountLoop !== null) {
-                clearInterval(this.#accountLoop);
-                this.#accountLoop = null;
-            }
-        }
-        #refreshAccount() {
-            if (this.#accountInflight !== null)
-                return this.#accountInflight;
-            const pending = this.#accountOnce().finally(() => {
-                if (this.#accountInflight === pending)
-                    this.#accountInflight = null;
-            });
-            this.#accountInflight = pending;
-            return pending;
-        }
-        async #accountOnce() {
-            const getter = accountGetterFor(this.#baseUrl);
-            if (getter === undefined)
-                return;
-            try {
-                const snap = await getter({ baseUrl: this.#baseUrl, apiKey: this.#apiKey });
-                this.#account = snap;
-                this.reportLive();
-            }
-            catch {
-                /* keep last report */
-            }
-        }
-        get #noteOk() { return _private_noteOk_descriptor.value; }
-        get #noteFail() { return _private_noteFail_descriptor.value; }
-        /**
-         * HTTP round as speech frames. The actor reports each onto the role lane;
-         * there is no progress callback. Iterate to run the request.
-         */
-        async *complete(expectation, options) {
-            invariant(this.#healthy, "openai-compat connection is not alive");
-            if (options?.signal?.aborted)
-                return;
-            const world = worldFor(expectation);
-            const messages = viewWire(this.#lineage, expectation, world);
-            const abort = new AbortController();
-            this.#abort = abort;
-            this.#turnModel = options?.model && options.model.trim() !== "" ? options.model.trim() : null;
-            this.#stampWindow(expectation);
-            const external = options?.signal;
-            const onExternalAbort = () => {
-                abort.abort();
-            };
-            if (external) {
-                external.addEventListener("abort", onExternalAbort, { once: true });
-            }
-            const pump = speechPump();
-            this.#emit = (frame) => pump.push(frame);
-            const work = (async () => {
-                try {
-                    const answer = await this.#round(messages, abort.signal, expectation);
-                    if (answer === null) {
-                        if (abort.signal.aborted)
-                            return;
-                        throw new Error("openai-compat completion failed");
-                    }
-                    const assistant = {
-                        role: "assistant",
-                        content: answer.content === "" && answer.calls.length > 0 ? null : answer.content,
-                        ...(answer.calls.length > 0 ? { tool_calls: answer.calls } : {}),
-                    };
-                    const prefix = [
-                        ...recallMessagesOf(expectation),
-                        ...(expectation.promptText !== "" ? [{ role: "user", content: expectation.promptText }] : []),
-                    ];
-                    const slice = {
-                        world,
-                        messages: [...prefix, assistant],
-                    };
-                    remember(this.#lineage, expectation, slice);
-                    runInAction(() => {
-                        expectation.responseCallsJson = JSON.stringify(answer.calls);
-                    });
-                    this.#stampWarm(expectation);
-                    this.#emit?.({ text: answer.content, thought: answer.reasoning });
-                }
-                catch (error) {
-                    pump.fail(error);
-                }
-                finally {
-                    pump.end();
-                }
-            })();
-            try {
-                yield* pump.values();
-                await work;
-            }
-            finally {
-                this.#emit = undefined;
-                this.#turnModel = null;
-                external?.removeEventListener("abort", onExternalAbort);
-                if (this.#abort === abort)
-                    this.#abort = null;
-            }
-        }
-        async cancel() {
-            this.#abort?.abort();
-        }
-        async [(_state_decorators = [(_a = observable).shallow.bind(_a)], _private_stampWindow_decorators = [action], _private_stampConsumed_decorators = [action], _private_stampWarm_decorators = [action], _reportLive_decorators = [action], _private_noteOk_decorators = [action], _private_noteFail_decorators = [action], Symbol.asyncDispose)]() {
-            this.#accountStop?.();
-            this.#accountStop = null;
-            this.#stopAccountLoop();
-            if (this.#healthTimer !== null) {
-                clearInterval(this.#healthTimer);
-                this.#healthTimer = null;
-            }
-            this.#abort?.abort();
-            this.#healthy = false;
-        }
-        resolve(expectation) {
-            invariant(this.#healthy, "OpenAiCompatDriverConnection.resolve: connection not warmed");
-            return new OpenAiCompatActor(expectation, this);
-        }
-        #requestHeaders() {
-            const apiKey = this.#secret("apiKey") ?? this.#apiKey;
-            return {
-                "content-type": "application/json",
-                ...this.#headers,
-                ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
-                ...this.authHeaders(),
-            };
-        }
-        /** Extra auth headers for a subscription profile (account id, grok-cli token). */
-        authHeaders() {
-            return {};
-        }
-        #secret(field) {
-            const value = this.secrets.get(field);
-            return typeof value === "string" && value.length > 0 ? value : undefined;
-        }
-        #effectiveModel() {
-            const turn = this.#turnModel?.trim();
-            if (turn)
-                return turn;
-            const configured = this.#model.trim();
-            if (configured)
-                return configured;
-            const live = this.state.models.find((id) => id.trim() !== "")?.trim();
-            invariant(live, "openai-compat model is required");
-            return live;
-        }
-        #completionBody(messages, expectation) {
-            if (this.completionApi() === "responses") {
-                const system = messages.find((message) => message.role === "system")?.content;
-                const input = messages
-                    .filter((message) => message.role !== "system")
-                    .map((message) => ({
-                    role: message.role === "assistant" ? "assistant" : "user",
-                    content: message.content ?? "",
-                }));
-                return {
-                    model: this.#effectiveModel(),
-                    ...(typeof system === "string" && system.length > 0 ? { instructions: system } : {}),
-                    input,
-                    stream: true,
-                    store: false,
-                };
-            }
-            const tools = toolsFor(expectation);
-            return {
-                model: this.#effectiveModel(),
-                messages,
-                stream: true,
-                stream_options: { include_usage: true },
-                temperature: this.#temperature,
-                ...(tools.length > 0 ? { tools } : {}),
-            };
-        }
-        async #fetchWithTimeout(url, init, ms = LOCAL_HANDSHAKE_MS) {
-            const ctrl = new AbortController();
-            const timer = setTimeout(() => ctrl.abort(), ms);
-            try {
-                return await fetch(url, { ...init, signal: ctrl.signal });
-            }
-            catch (error) {
-                if (ctrl.signal.aborted)
-                    throw new Error(`openai-compat timeout after ${ms}ms: ${url}`);
-                throw error;
-            }
-            finally {
-                clearTimeout(timer);
-            }
-        }
-        async #round(messages, signal, expectation) {
-            const response = await fetch(this.completionRequestUrl(), {
-                method: "POST",
-                headers: this.#requestHeaders(),
-                signal,
-                body: JSON.stringify(this.#completionBody(messages, expectation)),
-            });
-            if (!response.ok) {
-                const detail = (await response.text()).trim().slice(0, 240);
-                const message = `openai-compat completion failed: ${response.status}${detail === "" ? "" : ` ${detail}`}`;
-                if (response.status === 401 || response.status === 403)
-                    this.#noteFail(new Error(message));
-                throw new Error(message);
-            }
-            if (this.completionApi() === "responses") {
-                return this.#roundFromResponses(response, signal, expectation);
-            }
-            const contentType = response.headers.get("content-type") ?? "";
-            if (contentType.toLowerCase().includes("application/json")) {
-                const payload = (await response.json());
-                return this.#roundFromBulk(payload, expectation);
-            }
-            if (contentType.toLowerCase().includes("text/event-stream") ||
-                contentType.toLowerCase().includes("event-stream")) {
-                return this.#roundFromSse(response.body, signal, expectation);
-            }
-            const text = await response.text();
-            if (isBulkJsonBody(contentType, text)) {
-                let payload;
-                try {
-                    payload = JSON.parse(text);
-                }
-                catch {
-                    return null;
-                }
-                return this.#roundFromBulk(payload, expectation);
-            }
-            return this.#roundFromSseText(text, signal, expectation);
-        }
-        async #roundFromBulk(payload, expectation) {
-            this.#stampConsumed(expectation, payload);
-            const choice = payload.choices?.[0];
-            const message = choice?.message;
-            const normalized = normalizeMessage({
-                content: message?.content ?? "",
-                tool_calls: message?.tool_calls ?? null,
-                reasoning_content: extractReasoning(message) || null,
-            }, {
-                mode: "repair",
-                tools: catalogToolDefs(expectation),
-                argAliases: ARG_ALIASES,
-                modelHint: this.#effectiveModel(),
-                finishReasonIn: choice?.finish_reason ?? null,
-            });
-            const answer = {
-                content: normalized.content ?? "",
-                reasoning: normalized.reasoning_content ?? "",
-                calls: normalized.tool_calls,
-                dropped: normalized.meta.dropped.map((drop) => ({ name: drop.name, reason: drop.reason })),
-            };
-            await this.#emitSpeech(answer);
-            return answer;
-        }
-        async #roundFromResponses(response, _signal, expectation) {
-            const contentType = response.headers.get("content-type") ?? "";
-            if (contentType.toLowerCase().includes("application/json") && !contentType.toLowerCase().includes("event-stream")) {
-                const payload = (await response.json());
-                this.#stampConsumed(expectation, payload);
-                const parts = [];
-                if (Array.isArray(payload.output)) {
-                    for (const item of payload.output) {
-                        if (typeof item !== "object" || item === null)
-                            continue;
-                        const rec = item;
-                        if (rec.type !== "message" || !Array.isArray(rec.content))
-                            continue;
-                        for (const part of rec.content) {
-                            if (typeof part !== "object" || part === null)
-                                continue;
-                            const piece = part;
-                            if (piece.type === "output_text" && typeof piece.text === "string")
-                                parts.push(piece.text);
-                        }
-                    }
-                }
-                const text = parts.join("");
-                await this.#emitSpeech({ content: text, reasoning: "" });
-                return { content: text, reasoning: "", calls: [], dropped: [] };
-            }
-            return this.#consumeResponses(readSseJson(response.body, _signal), expectation);
-        }
-        async #consumeResponses(chunks, expectation) {
-            let acc = { text: "", thought: "" };
-            for await (const raw of chunks) {
-                this.#stampConsumed(expectation, raw);
-                if (typeof raw !== "object" || raw === null)
-                    continue;
-                const rec = raw;
-                if (rec.type === "response.output_text.delta" && typeof rec.delta === "string") {
-                    acc = { text: acc.text + rec.delta, thought: acc.thought };
-                    this.#emit?.({ text: acc.text, thought: acc.thought });
-                }
-                else if ((rec.type === "response.reasoning_summary_text.delta" || rec.type === "response.reasoning_text.delta") &&
-                    typeof rec.delta === "string") {
-                    acc = { text: acc.text, thought: acc.thought + rec.delta };
-                    this.#emit?.({ text: acc.text, thought: acc.thought });
-                }
-            }
-            return { content: acc.text, reasoning: acc.thought, calls: [], dropped: [] };
-        }
-        async #roundFromSse(body, signal, expectation) {
-            return this.#consumeStream(readSseJson(body, signal), expectation);
-        }
-        async #roundFromSseText(text, signal, expectation) {
-            async function* fromText() {
-                const bytes = new TextEncoder().encode(text);
-                const stream = new ReadableStream({
-                    start(controller) {
-                        controller.enqueue(bytes);
-                        controller.close();
-                    },
-                });
-                yield* readSseJson(stream, signal);
-            }
-            return this.#consumeStream(fromText(), expectation);
-        }
-        async #consumeStream(chunks, expectation) {
-            const session = createStreamSession({
-                mode: "repair",
-                tools: catalogToolDefs(expectation),
-                argAliases: ARG_ALIASES,
-                modelHint: this.#effectiveModel(),
-            });
-            let thoughtAcc = "";
-            let textAcc = "";
-            const calls = [];
-            const dropped = [];
-            const onEvent = (ev) => {
-                switch (ev.type) {
-                    case "reasoning_delta": {
-                        if (!ev.text)
-                            break;
-                        thoughtAcc += ev.text;
-                        this.#emit?.({ text: textAcc, thought: thoughtAcc });
-                        break;
-                    }
-                    case "text_delta": {
-                        if (!ev.text)
-                            break;
-                        textAcc += ev.text;
-                        this.#emit?.({ text: textAcc, thought: thoughtAcc });
-                        break;
-                    }
-                    case "tool_call_end": {
-                        if (!ev.name || ev.arguments == null || !ev.id)
-                            break;
-                        calls.push({
-                            id: ev.id,
-                            type: "function",
-                            function: { name: ev.name, arguments: ev.arguments },
-                        });
-                        break;
-                    }
-                    case "tool_call_drop": {
-                        dropped.push({
-                            name: ev.name ?? "(unknown)",
-                            reason: ev.reason ?? "dropped",
-                        });
-                        break;
-                    }
-                    default:
-                        break;
-                }
-            };
-            for await (const raw of chunks) {
-                this.#stampConsumed(expectation, raw);
-                const chunk = asChatChunk(raw);
-                if (!chunk)
-                    continue;
-                for (const ev of session.ingest(chunk))
-                    onEvent(ev);
-            }
-            for (const ev of session.close())
-                onEvent(ev);
-            return {
-                content: textAcc,
-                reasoning: thoughtAcc,
-                calls,
-                dropped,
-            };
-        }
-        async #emitSpeech(parts) {
-            const { content, reasoning } = parts;
-            if (content.length === 0 && reasoning.length === 0)
-                return;
-            this.#emit?.({ text: content, thought: reasoning });
-        }
-        constructor() {
-            super(...arguments);
-            __runInitializers(this, _state_extraInitializers);
-        }
-    };
-})();
-export { OpenAiCompatDriverConnection };
-function speechPump() {
-    const queued = [];
-    let wake;
-    let done = false;
-    let error;
-    const poke = () => {
-        wake?.();
-        wake = undefined;
-    };
-    return {
-        push(frame) {
-            queued.push(frame);
-            poke();
-        },
-        fail(next) {
-            error = next;
-            done = true;
-            poke();
-        },
-        end() {
-            done = true;
-            poke();
-        },
-        async *values() {
-            for (;;) {
-                if (queued.length > 0) {
-                    yield queued.shift();
-                    continue;
-                }
-                if (error !== undefined)
-                    throw error;
-                if (done)
-                    return;
-                await new Promise((resolve) => {
-                    wake = resolve;
-                });
-            }
-        },
-    };
-}
-class OpenAiCompatActor extends ExpectationActor {
-    driverConnection;
-    constructor(expectation, driverConnection) {
-        super(expectation, driverConnection);
-        this.driverConnection = driverConnection;
-    }
-    async run() {
-        const connection = this.driverConnection;
-        this.invariant(connection.alive, "openai-compat connection not warmed");
-        const { model } = this.expectation;
-        const startedAt = Date.now();
-        let last = {
-            text: "",
-            thought: "",
-            startedAt,
-        };
-        if (this.signal.aborted)
-            return;
-        try {
-            this.report(last);
-            for await (const frame of connection.complete(this.expectation, {
-                signal: this.signal,
-                model,
-            })) {
-                if (this.signal.aborted)
-                    return;
-                last = { text: frame.text, thought: frame.thought, startedAt };
-                this.report(last);
-            }
-            if (this.signal.aborted)
-                return;
-            this.complete(last.thought !== "" ? { text: last.text, thought: last.thought } : { text: last.text });
-        }
-        catch (error) {
-            if (this.signal.aborted)
-                return;
-            const reason = error instanceof Error ? error.message : String(error);
-            this.expectation.failReason = reason;
-            this.fail(reason);
-        }
-    }
-}
-export default OpenAiCompatDriverConnection;
-//# sourceMappingURL=openai-compat-driver.js.map