@compose-market/sdk 0.6.94 → 0.6.95

package/dist/resources/inference.js

@@ -952,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;
@@ -963,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);
@@ -970,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