@compose-market/sdk 0.8.1 → 0.8.2

package/dist/resources/inference.js

@@ -1,1049 +0,0 @@
-import { AuthenticationError, BadRequestError, Error, PaymentRequiredError } from "../errors.js";
-import { parseSSEStream } from "@compose-market/core/transport";
-import { parseReceiptEvent } from "@compose-market/core/sse/receipt";
-import { decode as decodeModelEvent } from "@compose-market/core/model";
-import { encodePaymentSignature } from "./x402.js";
-import { instrumentBillableResponse, } from "./instrumentation.js";
-export function buildCallHeaders(options, ctxWallet, ctxToken) {
-    // When the caller explicitly passes `key: null`, force the raw x402
-    // path by suppressing the instance-level token. Any other value (string or
-    // undefined) falls back to the instance token.
-    const tokenResolved = options?.paymentMode === "x402"
-        ? null
-        : options && "key" in options
-            ? options.key
-            : ctxToken;
-    return {
-        userAddress: options?.userAddress ?? ctxWallet.address ?? undefined,
-        chainId: options?.chainId ?? ctxWallet.chainId ?? undefined,
-        key: tokenResolved ?? undefined,
-        paymentSignature: options?.paymentSignature ? encodePaymentSignature(options.paymentSignature) : undefined,
-        x402MaxAmountWei: options?.x402MaxAmountWei,
-        idempotencyKey: options?.idempotencyKey,
-        runId: options?.runId,
-    };
-}
-function resolvePaymentMode(options) {
-    return options?.paymentMode ?? "auto";
-}
-function resolveX402Signer(ctx, options) {
-    return options?.x402Signer ?? ctx.getX402SignerMaybe?.() ?? null;
-}
-async function buildX402RetryConfig(error, config, ctx, options) {
-    if (!(error instanceof PaymentRequiredError) || !error.paymentRequired) {
-        return null;
-    }
-    if (resolvePaymentMode(options) === "key") {
-        return null;
-    }
-    const signer = resolveX402Signer(ctx, options);
-    if (!signer) {
-        return null;
-    }
-    const wallet = ctx.getWalletMaybe();
-    const signed = await signer({
-        paymentRequired: error.paymentRequired,
-        paymentRequiredHeader: error.paymentRequiredHeader,
-        method: config.method,
-        path: config.path,
-        url: error.paymentRequired.resource.url,
-        body: config.body,
-        userAddress: options?.userAddress ?? wallet.address,
-        chainId: options?.chainId ?? wallet.chainId,
-        maxAmountWei: options?.x402MaxAmountWei,
-    });
-    return {
-        ...config,
-        headers: {
-            ...(config.headers ?? {}),
-            key: null,
-            paymentSignature: encodePaymentSignature(signed),
-        },
-    };
-}
-function shouldRetryInvalidKeyAsX402(error, ctx, options) {
-    return error instanceof AuthenticationError
-        && resolvePaymentMode(options) === "auto"
-        && Boolean(ctx.getTokenMaybe())
-        && Boolean(resolveX402Signer(ctx, options));
-}
-function suppressKey(config) {
-    return {
-        ...config,
-        headers: {
-            ...(config.headers ?? {}),
-            key: null,
-            paymentSignature: undefined,
-        },
-    };
-}
-async function requestJsonWithPayment(client, ctx, config, options) {
-    try {
-        return await client.request(config).withResponse();
-    }
-    catch (error) {
-        const retryConfig = await buildX402RetryConfig(error, config, ctx, options);
-        if (retryConfig)
-            return client.request(retryConfig).withResponse();
-        if (shouldRetryInvalidKeyAsX402(error, ctx, options)) {
-            const challengeConfig = suppressKey(config);
-            try {
-                return await client.request(challengeConfig).withResponse();
-            }
-            catch (challengeError) {
-                const signedRetryConfig = await buildX402RetryConfig(challengeError, challengeConfig, ctx, options);
-                if (signedRetryConfig)
-                    return client.request(signedRetryConfig).withResponse();
-                throw challengeError;
-            }
-        }
-        throw error;
-    }
-}
-export async function requestResponseWithPayment(client, ctx, config, options) {
-    try {
-        return await client.request(config).asResponse();
-    }
-    catch (error) {
-        const retryConfig = await buildX402RetryConfig(error, config, ctx, options);
-        if (retryConfig)
-            return client.request(retryConfig).asResponse();
-        if (shouldRetryInvalidKeyAsX402(error, ctx, options)) {
-            const challengeConfig = suppressKey(config);
-            try {
-                return await client.request(challengeConfig).asResponse();
-            }
-            catch (challengeError) {
-                const signedRetryConfig = await buildX402RetryConfig(challengeError, challengeConfig, ctx, options);
-                if (signedRetryConfig)
-                    return client.request(signedRetryConfig).asResponse();
-                throw challengeError;
-            }
-        }
-        throw error;
-    }
-}
-function isReceiptEvent(event) {
-    return event === "receipt" || event === "compose.receipt";
-}
-/**
- * Read the response header / body pair produced by a billable call, extract
- * receipt + budget + invalid-reason, emit them on the SDK event bus, and
- * return the public `Completion<T>` shape.
- */
-function toCompletion(ctx, response, data) {
-    const result = instrumentBillableResponse(ctx, response, data);
-    return {
-        data: result.data,
-        receipt: result.receipt,
-        requestId: result.requestId,
-        response: result.response,
-        budget: result.budget,
-        sessionInvalidReason: result.sessionInvalidReason,
-    };
-}
-/**
- * Emit budget / receipt / invalid events for a streaming response. The receipt
- * is attached optionally because streaming calls produce it via the in-band
- * `receipt` SSE frame, not necessarily via the header.
- */
-function emitStreamingEvents(ctx, response, receipt, requestId) {
-    const walletCtx = ctx.getWalletMaybe();
-    // Budget / session-invalid headers are set on the initial SSE response
-    // (before the stream body), so extracting them from `response` is fine.
-    const { extractSessionBudgetFromResponse } = budgetExtractor;
-    const { budget, sessionInvalidReason } = extractSessionBudgetFromResponse(response);
-    if (receipt) {
-        ctx.events.emit("receipt", {
-            userAddress: walletCtx.address,
-            chainId: walletCtx.chainId,
-            receipt,
-            requestId,
-            source: "stream",
-        });
-    }
-    if (budget) {
-        ctx.events.emit("budget", {
-            userAddress: walletCtx.address,
-            chainId: walletCtx.chainId,
-            snapshot: budget,
-            requestId,
-        });
-    }
-    if (sessionInvalidReason) {
-        ctx.events.emit("sessionInvalid", {
-            userAddress: walletCtx.address,
-            chainId: walletCtx.chainId,
-            reason: sessionInvalidReason,
-            requestId,
-        });
-    }
-    return { budget, sessionInvalidReason };
-}
-// Lazy-loaded to avoid a circular import through instrumentation.ts -> budget.ts
-// (budget.ts is a pure leaf, so we just import it directly).
-import * as budgetExtractor from "@compose-market/core/sse/budget";
-function bytesToBase64(bytes) {
-    if (typeof Buffer !== "undefined") {
-        return Buffer.from(bytes).toString("base64");
-    }
-    let binary = "";
-    const chunkSize = 0x8000;
-    for (let offset = 0; offset < bytes.length; offset += chunkSize) {
-        const chunk = bytes.subarray(offset, offset + chunkSize);
-        binary += String.fromCharCode(...chunk);
-    }
-    return globalThis.btoa(binary);
-}
-function isByteArray(value) {
-    return value instanceof Uint8Array
-        || Boolean(value
-            && typeof value === "object"
-            && "byteLength" in value
-            && "buffer" in value
-            && typeof value.byteLength === "number");
-}
-async function encodeAudioFile(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    if (typeof Blob !== "undefined" && value instanceof Blob) {
-        return bytesToBase64(new Uint8Array(await value.arrayBuffer()));
-    }
-    if (isByteArray(value)) {
-        return bytesToBase64(value);
-    }
-    throw new BadRequestError({ message: "audio transcriptions: unsupported file type" });
-}
-/**
- * Async iterable returned by `inference.chat.completions.stream(...)` and
- * `inference.responses.stream(...)`. Exposes `.final()` for consumers that
- * want the reassembled final object + receipt without iterating manually.
- *
- * `for await (const chunk of stream) { ... }` consumes chunks; the generator's
- * return value is captured internally so a subsequent `await stream.final()`
- * resolves to the typed final object even when the caller drove iteration.
- */
-export class StreamIterator {
-    iterator;
-    finalResult = null;
-    finalSettled = false;
-    finalPromise = null;
-    constructor(iterator) {
-        this.iterator = iterator;
-    }
-    [Symbol.asyncIterator]() {
-        const self = this;
-        return {
-            next: async () => {
-                const r = await self.iterator.next();
-                if (r.done) {
-                    self.finalResult = r.value;
-                    self.finalSettled = true;
-                    return { done: true, value: undefined };
-                }
-                return { done: false, value: r.value };
-            },
-            return: async () => {
-                const r = await self.iterator.return(undefined);
-                if (r.done) {
-                    self.finalResult = r.value;
-                    self.finalSettled = true;
-                }
-                return { done: true, value: undefined };
-            },
-        };
-    }
-    async final() {
-        if (this.finalSettled)
-            return this.finalResult;
-        if (this.finalPromise)
-            return this.finalPromise;
-        this.finalPromise = (async () => {
-            let last;
-            do {
-                last = await this.iterator.next();
-            } while (!last.done);
-            this.finalResult = last.value;
-            this.finalSettled = true;
-            return last.value;
-        })();
-        return this.finalPromise;
-    }
-}
-// ---------------------------------------------------------------------------
-// Chat completions
-// ---------------------------------------------------------------------------
-function cleanse(params) {
-    const { provider: _provider, ...body } = params;
-    return body;
-}
-class ChatCompletionsNamespace {
-    client;
-    ctx;
-    constructor(client, ctx) {
-        this.client = client;
-        this.ctx = ctx;
-    }
-    async create(params, options) {
-        if (params.stream === true) {
-            throw new BadRequestError({
-                message: "Pass stream: true only to chat.completions.stream(). Use create() for non-streaming calls.",
-            });
-        }
-        const { data, response } = await requestJsonWithPayment(this.client, this.ctx, {
-            method: "POST",
-            path: "/v1/chat/completions",
-            body: { ...cleanse(params), stream: false },
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        }, options);
-        return toCompletion(this.ctx, response, data);
-    }
-    stream(params, options) {
-        const iterator = streamChatCompletions(this.client, this.ctx, params, options);
-        return new StreamIterator(iterator);
-    }
-}
-async function* streamChatCompletions(client, ctx, params, options) {
-    const response = await requestResponseWithPayment(client, ctx, {
-        method: "POST",
-        path: "/v1/chat/completions",
-        body: { ...cleanse(params), stream: true },
-        headers: buildCallHeaders(options, ctx.getWalletMaybe(), ctx.getTokenMaybe()),
-        signal: options?.signal,
-        timeoutMs: options?.timeoutMs,
-        expectStream: true,
-    }, options);
-    if (!response.body) {
-        throw new Error({
-            code: "upstream_error",
-            message: "Streaming response had no body",
-        });
-    }
-    let receipt = null;
-    const aggregator = buildChatCompletionAggregator(params.model);
-    const emittedToolStarts = new Set();
-    let streamError = null;
-    let sawDone = false;
-    try {
-        for await (const frame of parseSSEStream(response.body, { signal: options?.signal })) {
-            if (isReceiptEvent(frame.event)) {
-                try {
-                    receipt = parseReceiptEvent(frame.data);
-                }
-                catch { /* ignore */ }
-                continue;
-            }
-            if (frame.event === "compose.error") {
-                try {
-                    const parsed = JSON.parse(frame.data);
-                    streamError = new Error({
-                        code: parsed.code ?? "upstream_error",
-                        message: parsed.message ?? "Stream error",
-                        details: parsed.details,
-                    });
-                }
-                catch { /* ignore */ }
-                const decoded = decodeModelEvent(frame, { runId: options?.runId });
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (frame.data === "[DONE]") {
-                sawDone = true;
-                continue;
-            }
-            if (sawDone)
-                continue;
-            if (frame.event !== "message") {
-                // Unknown Compose-specific frames: surface nothing to the chunk stream.
-                continue;
-            }
-            let parsed;
-            try {
-                parsed = JSON.parse(frame.data);
-            }
-            catch {
-                continue;
-            }
-            aggregator.absorb(parsed);
-            // Unified tool-call lifecycle events. The chat stream reports
-            // tool_call deltas; each delta with an `id` signals a new call
-            // (or continues an existing one). We emit toolCallStart on first
-            // sight and toolCallEnd when the chunk's finish_reason is set.
-            const walletCtx = ctx.getWalletMaybe();
-            const requestId = response.headers.get("x-request-id") ?? response.headers.get("X-Request-Id");
-            const deltaToolCalls = parsed.choices?.[0]?.delta?.tool_calls;
-            if (Array.isArray(deltaToolCalls)) {
-                for (const toolCall of deltaToolCalls) {
-                    if (toolCall.id && !emittedToolStarts.has(toolCall.id)) {
-                        emittedToolStarts.add(toolCall.id);
-                        ctx.events.emit("toolCallStart", {
-                            userAddress: walletCtx.address,
-                            chainId: walletCtx.chainId,
-                            requestId,
-                            source: "chat",
-                            toolCallId: toolCall.id,
-                            toolName: toolCall.function?.name ?? "",
-                            arguments: toolCall.function?.arguments,
-                        });
-                    }
-                }
-            }
-            const finishReason = parsed.choices?.[0]?.finish_reason;
-            if (finishReason === "tool_calls") {
-                const finalTools = aggregator.snapshotToolCalls();
-                for (const tc of finalTools) {
-                    ctx.events.emit("toolCallEnd", {
-                        userAddress: walletCtx.address,
-                        chainId: walletCtx.chainId,
-                        requestId,
-                        source: "chat",
-                        toolCallId: tc.id,
-                        toolName: tc.function.name,
-                        arguments: tc.function.arguments,
-                        failed: false,
-                    });
-                }
-            }
-            const decoded = decodeModelEvent(parsed, { runId: options?.runId, responseId: parsed.id, model: parsed.model });
-            if (decoded)
-                yield decoded;
-        }
-        if (streamError)
-            throw streamError;
-        const requestId = response.headers.get("x-request-id") ?? response.headers.get("X-Request-Id");
-        const { budget, sessionInvalidReason } = emitStreamingEvents(ctx, response, receipt, requestId);
-        return {
-            chatCompletion: aggregator.finalize(),
-            receipt,
-            requestId,
-            budget,
-            sessionInvalidReason,
-        };
-    }
-    finally {
-        try {
-            response.body?.cancel();
-        }
-        catch { /* best-effort */ }
-    }
-}
-function buildChatCompletionAggregator(modelHint) {
-    let id = "";
-    let created = 0;
-    let model = modelHint;
-    let role = undefined;
-    let content = "";
-    let reasoningContent = "";
-    let finishReason = "stop";
-    const toolCalls = new Map();
-    let usage;
-    return {
-        absorb(chunk) {
-            id = id || chunk.id;
-            created = created || chunk.created;
-            model = model || chunk.model;
-            if (chunk.usage)
-                usage = chunk.usage;
-            const choice = chunk.choices?.[0];
-            if (!choice)
-                return;
-            if (choice.finish_reason)
-                finishReason = choice.finish_reason;
-            const delta = choice.delta;
-            if (delta?.role)
-                role = delta.role;
-            if (typeof delta?.content === "string")
-                content += delta.content;
-            if (typeof delta?.reasoning_content === "string")
-                reasoningContent += delta.reasoning_content;
-            if (Array.isArray(delta?.tool_calls)) {
-                for (const toolCall of delta.tool_calls) {
-                    const idx = toolCall.index ?? 0;
-                    const existing = toolCalls.get(idx) ?? {
-                        id: toolCall.id ?? `call_${idx}`,
-                        type: "function",
-                        function: { name: "", arguments: "" },
-                    };
-                    if (toolCall.id)
-                        existing.id = toolCall.id;
-                    if (toolCall.function?.name)
-                        existing.function.name += toolCall.function.name;
-                    if (toolCall.function?.arguments)
-                        existing.function.arguments += toolCall.function.arguments;
-                    toolCalls.set(idx, existing);
-                }
-            }
-        },
-        snapshotToolCalls() {
-            return Array.from(toolCalls.values());
-        },
-        finalize() {
-            const message = {
-                role: role ?? "assistant",
-                content,
-            };
-            if (toolCalls.size > 0) {
-                message.tool_calls = Array.from(toolCalls.values());
-            }
-            if (reasoningContent.length > 0) {
-                message.reasoning_content = reasoningContent;
-            }
-            return {
-                id,
-                object: "chat.completion",
-                created,
-                model,
-                choices: [
-                    {
-                        index: 0,
-                        message,
-                        finish_reason: finishReason,
-                    },
-                ],
-                usage: usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
-            };
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// Responses API
-// ---------------------------------------------------------------------------
-class ResponsesNamespace {
-    client;
-    ctx;
-    constructor(client, ctx) {
-        this.client = client;
-        this.ctx = ctx;
-    }
-    async create(params, options) {
-        if (params.stream === true) {
-            throw new BadRequestError({
-                message: "Pass stream: true only to responses.stream(). Use create() for non-streaming calls.",
-            });
-        }
-        const { data, response } = await requestJsonWithPayment(this.client, this.ctx, {
-            method: "POST",
-            path: "/v1/responses",
-            body: { ...cleanse(params), stream: false },
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        }, options);
-        return toCompletion(this.ctx, response, data);
-    }
-    stream(params, options) {
-        const iterator = streamResponses(this.client, this.ctx, params, options);
-        return new StreamIterator(iterator);
-    }
-    async get(responseId, options) {
-        return this.client.request({
-            method: "GET",
-            path: `/v1/responses/${encodeURIComponent(responseId)}`,
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        });
-    }
-    async inputItems(responseId, options) {
-        return this.client.request({
-            method: "GET",
-            path: `/v1/responses/${encodeURIComponent(responseId)}/input_items`,
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        });
-    }
-    async append(responseId, params, options) {
-        const body = params && typeof params === "object" && !Array.isArray(params)
-            ? params
-            : { input: params };
-        return this.client.request({
-            method: "POST",
-            path: `/v1/responses/${encodeURIComponent(responseId)}/input_items`,
-            body,
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        });
-    }
-    async cancel(responseId, options) {
-        return this.client.request({
-            method: "POST",
-            path: `/v1/responses/${encodeURIComponent(responseId)}/cancel`,
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        });
-    }
-}
-async function* streamResponses(client, ctx, params, options) {
-    const response = await requestResponseWithPayment(client, ctx, {
-        method: "POST",
-        path: "/v1/responses",
-        body: { ...cleanse(params), stream: true },
-        headers: buildCallHeaders(options, ctx.getWalletMaybe(), ctx.getTokenMaybe()),
-        signal: options?.signal,
-        timeoutMs: options?.timeoutMs,
-        expectStream: true,
-    }, options);
-    if (!response.body) {
-        throw new Error({ code: "upstream_error", message: "Streaming response had no body" });
-    }
-    let receipt = null;
-    let lastCompleted = null;
-    let streamError = null;
-    let sawDone = false;
-    let created = null;
-    let textOutput = "";
-    const outputItems = [];
-    const toolCallAggregator = new Map();
-    try {
-        for await (const frame of parseSSEStream(response.body, { signal: options?.signal })) {
-            if (isReceiptEvent(frame.event)) {
-                try {
-                    receipt = parseReceiptEvent(frame.data);
-                }
-                catch { /* ignore */ }
-                continue;
-            }
-            if (frame.event === "compose.error") {
-                try {
-                    const parsed = JSON.parse(frame.data);
-                    streamError = new Error({
-                        code: parsed.code ?? "upstream_error",
-                        message: parsed.message ?? "Stream error",
-                    });
-                }
-                catch { /* ignore */ }
-                const decoded = decodeModelEvent(frame, { runId: options?.runId });
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-            if (frame.data === "[DONE]") {
-                sawDone = true;
-                continue;
-            }
-            if (sawDone)
-                continue;
-            if (frame.event !== "message")
-                continue;
-            let parsed;
-            try {
-                parsed = JSON.parse(frame.data);
-            }
-            catch {
-                continue;
-            }
-            if (parsed.type === "response.created") {
-                created = parsed.response;
-            }
-            if (parsed.type === "response.output_text.delta") {
-                textOutput += parsed.delta;
-            }
-            if (parsed.type === "response.image_generation_call.completed") {
-                const url = `data:${parsed.mime_type || "image/png"};base64,${parsed.image_b64}`;
-                outputItems.push({
-                    type: "output_image",
-                    role: "assistant",
-                    image_url: url,
-                    mime_type: parsed.mime_type || "image/png",
-                    ...(parsed.revised_prompt ? { text: parsed.revised_prompt } : {}),
-                });
-            }
-            if (parsed.type === "response.output_item.completed") {
-                outputItems[parsed.output_index] = parsed.item;
-            }
-            if (parsed.type === "response.output_video.status" && parsed.status === "completed" && parsed.url) {
-                const existingIndex = outputItems.findIndex((item) => item.type === "output_video" && item.job_id === parsed.job_id);
-                const item = {
-                    type: "output_video",
-                    role: "assistant",
-                    job_id: parsed.job_id,
-                    status: parsed.status,
-                    video_url: parsed.url,
-                    ...(typeof parsed.progress === "number" ? { progress: parsed.progress } : {}),
-                };
-                if (existingIndex >= 0)
-                    outputItems[existingIndex] = { ...outputItems[existingIndex], ...item };
-                else
-                    outputItems.push(item);
-            }
-            // Assemble tool_call + tool_call.delta frames so the final result
-            // carries ready-to-consume `{id,name,arguments}` entries.
-            if (parsed.type === "response.tool_call") {
-                const tc = parsed.tool_call;
-                if (tc && tc.id) {
-                    const existing = toolCallAggregator.get(tc.id) ?? {
-                        id: tc.id,
-                        name: tc.name ?? "",
-                        arguments: tc.arguments ?? "",
-                        index: toolCallAggregator.size,
-                    };
-                    if (tc.name)
-                        existing.name = tc.name;
-                    if (tc.arguments)
-                        existing.arguments = tc.arguments;
-                    toolCallAggregator.set(tc.id, existing);
-                    const walletCtx = ctx.getWalletMaybe();
-                    ctx.events.emit("toolCallStart", {
-                        userAddress: walletCtx.address,
-                        chainId: walletCtx.chainId,
-                        requestId: response.headers.get("x-request-id") ?? response.headers.get("X-Request-Id"),
-                        source: "responses",
-                        toolCallId: existing.id,
-                        toolName: existing.name,
-                        summary: existing.arguments,
-                        arguments: existing.arguments,
-                    });
-                }
-            }
-            if (parsed.type === "response.tool_call.delta") {
-                const delta = parsed.delta;
-                if (delta) {
-                    const idx = parsed.index;
-                    const key = delta.id ?? String(idx);
-                    const existing = toolCallAggregator.get(key) ?? {
-                        id: delta.id ?? `call_${idx}`,
-                        name: "",
-                        arguments: "",
-                        index: idx,
-                    };
-                    if (delta.id)
-                        existing.id = delta.id;
-                    if (delta.name)
-                        existing.name += delta.name;
-                    if (delta.arguments)
-                        existing.arguments += delta.arguments;
-                    toolCallAggregator.set(key, existing);
-                }
-            }
-            if (parsed.type === "response.completed") {
-                lastCompleted = parsed;
-                // Emit toolCallEnd for every aggregated tool call — responses
-                // API doesn't have a per-tool end event, so the completion
-                // frame is the natural terminal point.
-                const walletCtx = ctx.getWalletMaybe();
-                const requestId = response.headers.get("x-request-id") ?? response.headers.get("X-Request-Id");
-                for (const aggregated of toolCallAggregator.values()) {
-                    ctx.events.emit("toolCallEnd", {
-                        userAddress: walletCtx.address,
-                        chainId: walletCtx.chainId,
-                        requestId,
-                        source: "responses",
-                        toolCallId: aggregated.id,
-                        toolName: aggregated.name,
-                        summary: aggregated.arguments,
-                        arguments: aggregated.arguments,
-                        failed: false,
-                    });
-                }
-            }
-            const responseId = "response_id" in parsed ? parsed.response_id : "response" in parsed ? parsed.response.id : undefined;
-            const model = "model" in parsed ? parsed.model : "response" in parsed ? parsed.response.model : undefined;
-            const decoded = decodeModelEvent(parsed, { runId: options?.runId, responseId, model });
-            if (decoded)
-                yield decoded;
-        }
-        if (streamError)
-            throw streamError;
-        const compactOutput = outputItems.filter((item) => Boolean(item));
-        if (textOutput && !compactOutput.some((item) => item.type === "output_text")) {
-            compactOutput.unshift({ type: "output_text", role: "assistant", text: textOutput });
-        }
-        const finalResponse = lastCompleted
-            ? {
-                id: lastCompleted.response_id,
-                object: "response",
-                created_at: created?.created_at ?? Math.floor(Date.now() / 1000),
-                status: "completed",
-                model: lastCompleted.model,
-                output: compactOutput,
-                ...(lastCompleted.usage
-                    ? {
-                        usage: {
-                            input_tokens: lastCompleted.usage.input_tokens,
-                            output_tokens: lastCompleted.usage.output_tokens,
-                            total_tokens: lastCompleted.usage.total_tokens,
-                        },
-                    }
-                    : {}),
-            }
-            : created
-                ? { ...created, output: compactOutput }
-                : null;
-        const requestId = response.headers.get("x-request-id") ?? response.headers.get("X-Request-Id");
-        const { budget, sessionInvalidReason } = emitStreamingEvents(ctx, response, receipt, requestId);
-        const toolCalls = Array.from(toolCallAggregator.values())
-            .sort((a, b) => a.index - b.index)
-            .map(({ id, name, arguments: args }) => ({ id, name, arguments: args }));
-        return {
-            response: finalResponse,
-            toolCalls,
-            receipt,
-            requestId,
-            budget,
-            sessionInvalidReason,
-        };
-    }
-    finally {
-        try {
-            response.body?.cancel();
-        }
-        catch { /* best-effort */ }
-    }
-}
-// ---------------------------------------------------------------------------
-// Embeddings
-// ---------------------------------------------------------------------------
-class EmbeddingsNamespace {
-    client;
-    ctx;
-    constructor(client, ctx) {
-        this.client = client;
-        this.ctx = ctx;
-    }
-    async create(params, options) {
-        const { data, response } = await requestJsonWithPayment(this.client, this.ctx, {
-            method: "POST",
-            path: "/v1/embeddings",
-            body: cleanse(params),
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        }, options);
-        return toCompletion(this.ctx, response, data);
-    }
-}
-// ---------------------------------------------------------------------------
-// Images
-// ---------------------------------------------------------------------------
-class ImagesNamespace {
-    client;
-    ctx;
-    constructor(client, ctx) {
-        this.client = client;
-        this.ctx = ctx;
-    }
-    async generate(params, options) {
-        const { data, response } = await requestJsonWithPayment(this.client, this.ctx, {
-            method: "POST",
-            path: "/v1/images/generations",
-            body: cleanse(params),
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        }, options);
-        return toCompletion(this.ctx, response, data);
-    }
-    async edit(params, options) {
-        const { data, response } = await requestJsonWithPayment(this.client, this.ctx, {
-            method: "POST",
-            path: "/v1/images/edits",
-            body: cleanse(params),
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        }, options);
-        return toCompletion(this.ctx, response, data);
-    }
-}
-// ---------------------------------------------------------------------------
-// Audio
-// ---------------------------------------------------------------------------
-class AudioNamespace {
-    client;
-    ctx;
-    constructor(client, ctx) {
-        this.client = client;
-        this.ctx = ctx;
-    }
-    /**
-     * Text-to-speech. Returns the raw audio `Response` (stream the body via
-     * `response.body` or `await response.arrayBuffer()`), plus any receipt
-     * extracted from response headers, plus the live budget snapshot.
-     */
-    async speech(params, options) {
-        const response = await requestResponseWithPayment(this.client, this.ctx, {
-            method: "POST",
-            path: "/v1/audio/speech",
-            body: cleanse(params),
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-            expectStream: true,
-        }, options);
-        // No JSON body to mirror; receipt comes from the header only.
-        const result = instrumentBillableResponse(this.ctx, response, undefined);
-        return {
-            response,
-            receipt: result.receipt,
-            requestId: result.requestId,
-            budget: result.budget,
-            sessionInvalidReason: result.sessionInvalidReason,
-        };
-    }
-    /**
-     * Speech-to-text. The native API accepts JSON with `file` as base64 audio.
-     * Blob, File, and Uint8Array inputs are converted locally before sending.
-     */
-    async transcriptions(params, options) {
-        const { file, provider: _provider, ...rest } = params;
-        const body = {
-            ...rest,
-            file: await encodeAudioFile(file),
-        };
-        const { data, response } = await requestJsonWithPayment(this.client, this.ctx, {
-            method: "POST",
-            path: "/v1/audio/transcriptions",
-            body,
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        }, options);
-        return toCompletion(this.ctx, response, data);
-    }
-}
-// ---------------------------------------------------------------------------
-// Videos
-// ---------------------------------------------------------------------------
-class VideosNamespace {
-    client;
-    ctx;
-    constructor(client, ctx) {
-        this.client = client;
-        this.ctx = ctx;
-    }
-    async generate(params, options) {
-        const { data, response } = await requestJsonWithPayment(this.client, this.ctx, {
-            method: "POST",
-            path: "/v1/videos/generations",
-            body: cleanse(params),
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        }, options);
-        return toCompletion(this.ctx, response, data);
-    }
-    get(videoId, options) {
-        return Promise.resolve(this.client.request({
-            method: "GET",
-            path: `/v1/videos/${encodeURIComponent(videoId)}`,
-            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-            signal: options?.signal,
-            timeoutMs: options?.timeoutMs,
-        }));
-    }
-    /**
-     * Server-driven polling via SSE. Subscribes to `/v1/videos/:id/stream`
-     * and yields each status update as it arrives, terminating on the
-     * `completed` or `failed` state.
-     */
-    stream(videoId, opts = {}) {
-        const iterator = streamVideoStatus(this.client, this.ctx, videoId, opts);
-        return new StreamIterator(iterator);
-    }
-    /**
-     * Convenience helper: resolves once the video job hits a terminal state,
-     * driven by the server-side SSE poller. Aborts after `timeoutMs` elapses.
-     */
-    async waitUntilDone(videoId, opts = {}) {
-        const stream = this.stream(videoId, opts);
-        for await (const event of stream) {
-            opts.onStatus?.(event);
-        }
-        const { final } = await stream.final();
-        return final;
-    }
-}
-async function* streamVideoStatus(client, ctx, videoId, opts) {
-    const query = {};
-    if (opts.pollIntervalMs !== undefined)
-        query.pollIntervalMs = String(opts.pollIntervalMs);
-    if (opts.timeoutMs !== undefined)
-        query.timeoutMs = String(opts.timeoutMs);
-    const response = await client.request({
-        method: "GET",
-        path: `/v1/videos/${encodeURIComponent(videoId)}/stream`,
-        query,
-        headers: buildCallHeaders(opts, ctx.getWalletMaybe(), ctx.getTokenMaybe()),
-        signal: opts.signal,
-        timeoutMs: opts.timeoutMs,
-        expectStream: true,
-    }).asResponse();
-    if (!response.body) {
-        throw new Error({ code: "upstream_error", message: "Streaming response had no body" });
-    }
-    let lastStatus = null;
-    let emittedDone = false;
-    try {
-        for await (const frame of parseSSEStream(response.body, { signal: opts.signal })) {
-            if (frame.data === "[DONE]") {
-                if (!emittedDone) {
-                    emittedDone = true;
-                }
-                continue;
-            }
-            if (emittedDone && frame.event !== "compose.error")
-                continue;
-            if (frame.event === "compose.video.status") {
-                try {
-                    const parsed = JSON.parse(frame.data);
-                    lastStatus = {
-                        id: parsed.jobId,
-                        object: "video.generation",
-                        status: parsed.status,
-                        url: parsed.url,
-                        error: parsed.error,
-                        progress: parsed.progress,
-                    };
-                    const decoded = decodeModelEvent({ type: "compose.video.status", ...parsed }, { runId: opts.runId, responseId: videoId });
-                    if (decoded)
-                        yield decoded;
-                }
-                catch { /* skip malformed frame */ }
-                continue;
-            }
-            if (frame.event === "compose.error") {
-                const decoded = decodeModelEvent(frame, { runId: opts.runId, responseId: videoId });
-                if (decoded)
-                    yield decoded;
-                continue;
-            }
-        }
-        return {
-            final: lastStatus,
-            requestId: response.headers.get("x-request-id") ?? response.headers.get("X-Request-Id"),
-        };
-    }
-    finally {
-        try {
-            response.body?.cancel();
-        }
-        catch { /* best-effort */ }
-    }
-}
-// ---------------------------------------------------------------------------
-// Top-level inference resource
-// ---------------------------------------------------------------------------
-export class InferenceResource {
-    chat;
-    responses;
-    embeddings;
-    images;
-    audio;
-    videos;
-    constructor(client, ctx) {
-        this.chat = { completions: new ChatCompletionsNamespace(client, ctx) };
-        this.responses = new ResponsesNamespace(client, ctx);
-        this.embeddings = new EmbeddingsNamespace(client, ctx);
-        this.images = new ImagesNamespace(client, ctx);
-        this.audio = new AudioNamespace(client, ctx);
-        this.videos = new VideosNamespace(client, ctx);
-    }
-}
-//# sourceMappingURL=inference.js.map