@compose-market/sdk 0.6.91 → 0.6.95

package/dist/resources/inference.js

@@ -179,6 +179,38 @@ function emitStreamingEvents(ctx, response, receipt, requestId) {
 // 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 "../streaming/budget.js";
+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
@@ -437,6 +469,16 @@ function buildChatCompletionAggregator(modelHint) {
             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",
@@ -445,12 +487,7 @@ function buildChatCompletionAggregator(modelHint) {
                 choices: [
                     {
                         index: 0,
-                        message: {
-                            role: role ?? "assistant",
-                            content,
-                            ...(toolCalls.size > 0 ? { tool_calls: Array.from(toolCalls.values()) } : {}),
-                            ...(reasoningContent.length > 0 ? { reasoning_content: reasoningContent } : {}),
-                        },
+                        message,
                         finish_reason: finishReason,
                     },
                 ],
@@ -775,54 +812,19 @@ class AudioNamespace {
         };
     }
     /**
-     * Speech-to-text. Supports both multipart/form-data (preferred, OpenAI-
-     * compatible) when `file` is a `Blob`/`File`/`Uint8Array`, and base64-in-
-     * JSON (Compose legacy) when `file` is a string.
+     * 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 useMultipart = typeof File !== "undefined" && params.file instanceof File
-            || typeof Blob !== "undefined" && params.file instanceof Blob
-            || (params.file && typeof params.file === "object" && "byteLength" in params.file);
-        if (useMultipart) {
-            const form = new FormData();
-            form.append("model", params.model);
-            const { file, filename, model: _model, ...rest } = params;
-            void _model;
-            const name = filename ?? "audio";
-            let blob;
-            if (typeof File !== "undefined" && file instanceof File)
-                blob = file;
-            else if (typeof Blob !== "undefined" && file instanceof Blob)
-                blob = file;
-            else if (file.byteLength !== undefined) {
-                const bytes = file;
-                const copy = new Uint8Array(new ArrayBuffer(bytes.byteLength));
-                copy.set(bytes);
-                blob = new Blob([copy.buffer]);
-            }
-            else
-                throw new BadRequestError({ message: "audio transcriptions: unsupported file type" });
-            form.append("file", blob, name);
-            for (const [key, value] of Object.entries(rest)) {
-                if (value === undefined)
-                    continue;
-                form.append(key, typeof value === "string" ? value : JSON.stringify(value));
-            }
-            const { data, response } = await requestJsonWithPayment(this.client, this.ctx, {
-                method: "POST",
-                path: "/v1/audio/transcriptions",
-                rawBody: form,
-                bodyType: "form-data",
-                headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
-                signal: options?.signal,
-                timeoutMs: options?.timeoutMs,
-            }, options);
-            return toComposeCompletion(this.ctx, response, data);
-        }
+        const { file, ...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: params,
+            body,
             headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
             signal: options?.signal,
             timeoutMs: options?.timeoutMs,
@@ -950,10 +952,355 @@ async function* streamVideoStatus(client, ctx, videoId, opts) {
         catch { /* best-effort */ }
     }
 }
+function lower(value) {
+    return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function list(value) {
+    if (Array.isArray(value)) {
+        return value.map(lower).filter(Boolean);
+    }
+    const single = lower(value);
+    return single ? [single] : [];
+}
+function ops(info) {
+    const raw = info?.operations;
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return raw.filter((item) => (Boolean(item)
+        && typeof item === "object"
+        && typeof item.modality === "string"
+        && typeof item.operation === "string"));
+}
+function fields(info) {
+    return {
+        input: list(info?.input),
+        output: list(info?.output),
+    };
+}
+function part(value, signal) {
+    if (!value || typeof value !== "object") {
+        if (typeof value === "string" && value.trim())
+            signal.text = true;
+        return;
+    }
+    if (typeof Blob !== "undefined" && value instanceof Blob) {
+        const type = lower(value.type);
+        if (type.startsWith("audio/"))
+            signal.audio = true;
+        else if (type.startsWith("image/"))
+            signal.image = true;
+        else if (type.startsWith("video/"))
+            signal.video = true;
+        return;
+    }
+    if (isByteArray(value)) {
+        signal.audio = true;
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            part(item, signal);
+        return;
+    }
+    const record = value;
+    const type = lower(record.type ?? record.kind ?? record.mediaType ?? record.media_type);
+    const mime = lower(record.mimeType ?? record.mime_type ?? record.contentType ?? record.content_type);
+    const url = lower(record.url ?? record.uri ?? record.href ?? record.image_url ?? record.audio_url ?? record.video_url);
+    if (type.includes("audio") || mime.startsWith("audio/") || /\.(mp3|m4a|wav|ogg|opus|flac|aac)(?:[?#].*)?$/.test(url))
+        signal.audio = true;
+    if (type.includes("image") || mime.startsWith("image/") || /\.(png|jpe?g|gif|webp|avif|heic|svg)(?:[?#].*)?$/.test(url))
+        signal.image = true;
+    if (type.includes("video") || mime.startsWith("video/") || /\.(mp4|mov|webm|mkv|avi)(?:[?#].*)?$/.test(url))
+        signal.video = true;
+    if (typeof record.text === "string" || typeof record.content === "string")
+        signal.text = true;
+    for (const key of ["content", "input", "messages", "attachments", "attachment"]) {
+        if (record[key] !== undefined)
+            part(record[key], signal);
+    }
+}
+function sig(input) {
+    const signal = {
+        text: Boolean(input.prompt || typeof input.input === "string"),
+        image: false,
+        audio: Boolean(input.file),
+        video: false,
+    };
+    part(input.input, signal);
+    part(input.messages, signal);
+    part(input.attachments, signal);
+    part(input.attachment, signal);
+    return signal;
+}
+function first(values) {
+    return values.length > 0 ? values[0] : undefined;
+}
+function op(input, info) {
+    const wanted = lower(input.operation);
+    const wantedModality = input.modality;
+    const catalog = ops(info);
+    const signal = sig(input);
+    if (wanted) {
+        const exact = catalog.filter((item) => lower(item.operation) === wanted);
+        const selected = first(wantedModality ? exact.filter((item) => item.modality === wantedModality) : exact) ?? exact[0];
+        if (selected)
+            return { modality: selected.modality, operation: selected.operation };
+        if (wantedModality)
+            return { modality: wantedModality, operation: wanted };
+    }
+    if (wantedModality) {
+        const matches = catalog.filter((item) => item.modality === wantedModality);
+        const unique = [...new Map(matches.map((item) => [`${item.modality}:${item.operation}`, item])).values()];
+        if (unique.length === 1)
+            return { modality: unique[0].modality, operation: unique[0].operation };
+    }
+    if (catalog.length === 1) {
+        return { modality: catalog[0].modality, operation: catalog[0].operation };
+    }
+    if (catalog.length > 1) {
+        const matches = catalog.filter((item) => {
+            const inputKinds = list(item.input);
+            return (signal.audio && inputKinds.includes("audio"))
+                || (signal.image && inputKinds.includes("image"))
+                || (signal.video && inputKinds.includes("video"))
+                || (signal.text && inputKinds.includes("text"));
+        });
+        const unique = [...new Map(matches.map((item) => [`${item.modality}:${item.operation}`, item])).values()];
+        if (unique.length === 1)
+            return { modality: unique[0].modality, operation: unique[0].operation };
+    }
+    const io = fields(info);
+    if (io.output.includes("embedding"))
+        return { modality: "embedding", operation: "embedding" };
+    if (io.output.includes("video"))
+        return { modality: "video", operation: io.input.includes("image") ? "image-to-video" : "text-to-video" };
+    if (io.output.includes("image"))
+        return { modality: "image", operation: io.input.includes("image") ? "image-to-image" : "text-to-image" };
+    if (io.output.includes("audio")) {
+        if (io.input.includes("audio") && !io.input.includes("text"))
+            return { modality: "audio", operation: "speech-to-speech" };
+        return { modality: "audio", operation: "text-to-speech" };
+    }
+    if (io.input.includes("audio") && io.output.includes("text"))
+        return { modality: "audio", operation: "speech-to-text" };
+    return { modality: "text", operation: "text-generation" };
+}
+function endpoint(plan, input) {
+    const name = lower(plan.operation);
+    const signal = sig(input);
+    if (plan.modality === "embedding" || name.includes("embedding"))
+        return "embeddings";
+    if (name === "speech-to-text" || name.includes("transcription") || name.includes("speech-recognition")) {
+        return input.file ? "audio-transcriptions" : "responses";
+    }
+    if (name === "text-to-speech"
+        || name === "text-to-audio"
+        || name === "music-generation"
+        || name === "sound-effects"
+        || name === "text-to-sound-effects") {
+        return "audio-speech";
+    }
+    if (plan.modality === "audio") {
+        if (signal.audio && !signal.text)
+            return input.file ? "audio-transcriptions" : "responses";
+        if (signal.text && !signal.audio)
+            return "audio-speech";
+        return "responses";
+    }
+    if (plan.modality === "video")
+        return "videos";
+    if (plan.modality === "image")
+        return "images";
+    return input.messages ? "chat" : "responses";
+}
+function text(input) {
+    if (typeof input.prompt === "string")
+        return input.prompt;
+    if (typeof input.input === "string")
+        return input.input;
+    if (Array.isArray(input.messages)) {
+        return input.messages
+            .map((message) => typeof message.content === "string" ? message.content : "")
+            .filter(Boolean)
+            .join("\n");
+    }
+    return "";
+}
+function merge(input) {
+    return {
+        ...(input.params ?? {}),
+        ...(input.customParams ? { custom_params: input.customParams } : {}),
+    };
+}
+function attach(input) {
+    return {
+        ...(input.attachments ? { attachments: input.attachments } : {}),
+        ...(input.attachment ? { attachment: input.attachment } : {}),
+    };
+}
+function url(input, kind) {
+    const values = [input.attachment, ...(input.attachments ?? [])];
+    for (const value of values) {
+        if (!value || typeof value === "string")
+            continue;
+        const record = value;
+        const type = lower(record.type ?? record.kind);
+        const direct = kind === "image" ? record.image_url : kind === "audio" ? record.audio_url : record.video_url;
+        const candidate = typeof direct === "string"
+            ? direct
+            : typeof record.url === "string"
+                ? record.url
+                : typeof record.uri === "string"
+                    ? record.uri
+                    : undefined;
+        if (candidate && (type.includes(kind) || lower(record.mimeType ?? record.mime_type).startsWith(`${kind}/`))) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function firstOutput(data, kind) {
+    return data.output.find((item) => lower(item.type).includes(kind));
+}
+function dataurl(value) {
+    if (!value)
+        return {};
+    const match = value.match(/^data:([^;,]+)?;base64,(.*)$/i);
+    if (match) {
+        return {
+            ...(match[1] ? { mimeType: match[1] } : {}),
+            base64: match[2],
+        };
+    }
+    return { url: value };
+}
+function common(plan, value) {
+    return {
+        plan,
+        receipt: value.receipt,
+        requestId: value.requestId,
+        budget: value.budget,
+        sessionInvalidReason: value.sessionInvalidReason,
+    };
+}
+function chat(plan, value) {
+    return {
+        type: "text",
+        ...common(plan, value),
+        text: value.data.choices[0]?.message?.content ?? "",
+        data: value.data,
+    };
+}
+function response(plan, value) {
+    if (plan.modality === "embedding") {
+        const embeddings = value.data.output
+            .map((item) => item.embedding)
+            .filter((item) => Array.isArray(item) && item.every((entry) => typeof entry === "number"));
+        return { type: "embedding", ...common(plan, value), embeddings, data: value.data };
+    }
+    if (plan.modality === "image") {
+        const item = firstOutput(value.data, "image");
+        const parsed = dataurl(typeof item?.image_url === "string" ? item.image_url : undefined);
+        return { type: "image", ...common(plan, value), ...parsed, data: value.data };
+    }
+    if (plan.modality === "audio") {
+        const item = firstOutput(value.data, "audio");
+        const parsed = dataurl(typeof item?.audio_url === "string" ? item.audio_url : undefined);
+        return { type: "audio", ...common(plan, value), ...parsed, data: value.data };
+    }
+    if (plan.modality === "video") {
+        const item = firstOutput(value.data, "video");
+        const parsed = dataurl(typeof item?.video_url === "string" ? item.video_url : undefined);
+        return {
+            type: "video",
+            ...common(plan, value),
+            jobId: typeof value.data.job_id === "string" ? value.data.job_id : undefined,
+            status: value.data.status,
+            url: parsed.url,
+            data: value.data,
+        };
+    }
+    const item = firstOutput(value.data, "text");
+    return {
+        type: "text",
+        ...common(plan, value),
+        text: typeof item?.text === "string" ? item.text : "",
+        data: value.data,
+    };
+}
+function image(plan, value) {
+    const item = value.data.data[0] ?? {};
+    return {
+        type: "image",
+        ...common(plan, value),
+        url: item.url,
+        base64: item.b64_json,
+        mimeType: item.b64_json ? "image/png" : undefined,
+        data: value.data,
+    };
+}
+function embedding(plan, value) {
+    return {
+        type: "embedding",
+        ...common(plan, value),
+        embeddings: value.data.data.map((item) => item.embedding),
+        data: value.data,
+    };
+}
+function transcript(plan, value) {
+    return {
+        type: "text",
+        ...common(plan, value),
+        text: value.data.text,
+        data: value.data,
+    };
+}
+function videoid(data) {
+    if ("job_id" in data && typeof data.job_id === "string")
+        return data.job_id;
+    if ("id" in data && typeof data.id === "string")
+        return data.id;
+    return undefined;
+}
+function video(plan, value, final) {
+    const firstVideo = value.data.data?.[0];
+    return {
+        type: "video",
+        ...common(plan, value),
+        jobId: videoid(value.data),
+        status: final?.status ?? value.data.status,
+        url: final?.url ?? firstVideo?.url,
+        final,
+        data: value.data,
+    };
+}
+async function speech(plan, value) {
+    const cloned = value.response.clone();
+    const arrayBuffer = await cloned.arrayBuffer();
+    const mimeType = value.response.headers.get("content-type")?.split(";")[0]?.trim() || "audio/mpeg";
+    const bytes = new Uint8Array(arrayBuffer);
+    const blob = typeof Blob !== "undefined" ? new Blob([bytes], { type: mimeType }) : undefined;
+    const objectUrl = blob && typeof URL !== "undefined" && typeof URL.createObjectURL === "function"
+        ? URL.createObjectURL(blob)
+        : undefined;
+    return {
+        type: "audio",
+        ...common(plan, value),
+        mimeType,
+        blob,
+        objectUrl,
+        arrayBuffer,
+        base64: bytesToBase64(bytes),
+        response: value.response,
+    };
+}
 // ---------------------------------------------------------------------------
 // Top-level inference resource
 // ---------------------------------------------------------------------------
 export class InferenceResource {
+    client;
+    ctx;
     chat;
     responses;
     embeddings;
@@ -961,6 +1308,8 @@ export class InferenceResource {
     audio;
     videos;
     constructor(client, ctx) {
+        this.client = client;
+        this.ctx = ctx;
         this.chat = { completions: new ChatCompletionsNamespace(client, ctx) };
         this.responses = new ResponsesNamespace(client, ctx);
         this.embeddings = new EmbeddingsNamespace(client, ctx);
@@ -968,5 +1317,124 @@ export class InferenceResource {
         this.audio = new AudioNamespace(client, ctx);
         this.videos = new VideosNamespace(client, ctx);
     }
+    async plan(input, options) {
+        const info = input.modelInfo ?? await this.client.request({
+            method: "GET",
+            path: `/v1/models/${encodeURIComponent(input.model)}`,
+            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
+            signal: options?.signal,
+            timeoutMs: options?.timeoutMs,
+        });
+        const selected = op(input, info);
+        const plan = {
+            model: input.model,
+            ...(input.provider ?? info.provider ? { provider: input.provider ?? info.provider } : {}),
+            modality: selected.modality,
+            operation: selected.operation,
+            endpoint: endpoint(selected, input),
+        };
+        return plan;
+    }
+    async run(input, options) {
+        const plan = await this.plan(input, options);
+        const extra = merge(input);
+        const attachments = attach(input);
+        const prompt = text(input);
+        if (plan.endpoint === "chat") {
+            if (!input.messages)
+                throw new BadRequestError({ message: "messages are required for chat inference" });
+            return chat(plan, await this.chat.completions.create({
+                model: input.model,
+                messages: input.messages,
+                provider: input.provider,
+                ...attachments,
+                ...extra,
+            }, options));
+        }
+        if (plan.endpoint === "embeddings") {
+            const embeddingInput = Array.isArray(input.input) && input.input.every((item) => typeof item === "string")
+                ? input.input
+                : prompt;
+            if (!embeddingInput || (Array.isArray(embeddingInput) && embeddingInput.length === 0)) {
+                throw new BadRequestError({ message: "input is required for embedding inference" });
+            }
+            return embedding(plan, await this.embeddings.create({
+                model: input.model,
+                input: embeddingInput,
+                provider: input.provider,
+                ...attachments,
+                ...extra,
+            }, options));
+        }
+        if (plan.endpoint === "images") {
+            if (!prompt)
+                throw new BadRequestError({ message: "prompt is required for image inference" });
+            const imageUrl = url(input, "image");
+            const body = {
+                model: input.model,
+                prompt,
+                provider: input.provider,
+                ...(imageUrl ? { image: imageUrl } : {}),
+                ...attachments,
+                ...extra,
+            };
+            return image(plan, imageUrl
+                ? await this.images.edit(body, options)
+                : await this.images.generate(body, options));
+        }
+        if (plan.endpoint === "audio-speech") {
+            if (!prompt)
+                throw new BadRequestError({ message: "input text is required for audio generation" });
+            return speech(plan, await this.audio.speech({
+                model: input.model,
+                input: prompt,
+                provider: input.provider,
+                ...attachments,
+                ...extra,
+            }, options));
+        }
+        if (plan.endpoint === "audio-transcriptions") {
+            if (!input.file)
+                throw new BadRequestError({ message: "file is required for audio transcription" });
+            return transcript(plan, await this.audio.transcriptions({
+                model: input.model,
+                file: input.file,
+                provider: input.provider,
+                ...attachments,
+                ...extra,
+            }, options));
+        }
+        if (plan.endpoint === "videos") {
+            if (!prompt)
+                throw new BadRequestError({ message: "prompt is required for video inference" });
+            const created = await this.videos.generate({
+                model: input.model,
+                prompt,
+                provider: input.provider,
+                ...(url(input, "image") ? { image_url: url(input, "image") } : {}),
+                ...attachments,
+                ...extra,
+            }, options);
+            const id = videoid(created.data);
+            const final = input.wait && id
+                ? await this.videos.waitUntilDone(id, {
+                    ...options,
+                    pollIntervalMs: input.pollIntervalMs,
+                    timeoutMs: input.waitTimeoutMs ?? options?.timeoutMs,
+                    onStatus: input.onStatus,
+                })
+                : null;
+            return video(plan, created, final);
+        }
+        const body = {
+            model: input.model,
+            input: input.input ?? prompt,
+            modalities: [plan.modality],
+            provider: input.provider,
+            ...attachments,
+            ...extra,
+        };
+        return response(plan, await this.responses.create(body, options));
+    }
 }
 //# sourceMappingURL=inference.js.map