@compose-market/sdk 0.6.95 → 0.6.97

package/dist/resources/inference.js

@@ -571,6 +571,9 @@ async function* streamResponses(client, ctx, params, options) {
     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 })) {
@@ -607,6 +610,40 @@ async function* streamResponses(client, ctx, params, options) {
             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") {
@@ -681,14 +718,18 @@ async function* streamResponses(client, ctx, params, options) {
         }
         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: Math.floor(Date.now() / 1000),
+                created_at: created?.created_at ?? Math.floor(Date.now() / 1000),
                 status: "completed",
                 model: lastCompleted.model,
-                output: [],
+                output: compactOutput,
                 ...(lastCompleted.usage
                     ? {
                         usage: {
@@ -699,7 +740,9 @@ async function* streamResponses(client, ctx, params, options) {
                     }
                     : {}),
             }
-            : null;
+            : 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())
@@ -952,355 +995,10 @@ 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;
@@ -1308,8 +1006,6 @@ 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);
@@ -1317,124 +1013,5 @@ 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