@inhuman.tools/harness 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,843 @@
+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