@compose-market/sdk 0.1.1 → 0.3.0

package/dist/resources/inference.js

@@ -0,0 +1,740 @@
+import { BadRequestError, ComposeError } from "../errors.js";
+import { parseSSEStream } from "../streaming/sse.js";
+import { parseReceiptEvent } from "../streaming/receipt.js";
+import { instrumentBillableResponse, } from "./instrumentation.js";
+function buildCallHeaders(options, ctxWallet, ctxToken) {
+    // When the caller explicitly passes `composeKey: 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 && "composeKey" in options
+        ? options.composeKey
+        : ctxToken;
+    return {
+        userAddress: options?.userAddress ?? ctxWallet.address ?? undefined,
+        chainId: options?.chainId ?? ctxWallet.chainId ?? undefined,
+        composeKey: tokenResolved ?? undefined,
+        paymentSignature: options?.paymentSignature,
+        x402MaxAmountWei: options?.x402MaxAmountWei,
+        idempotencyKey: options?.idempotencyKey,
+        composeRunId: options?.composeRunId,
+    };
+}
+/**
+ * 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 `ComposeCompletion<T>` shape.
+ */
+function toComposeCompletion(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
+ * `compose.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 "../streaming/budget.js";
+/**
+ * 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 ComposeStreamIterator {
+    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
+// ---------------------------------------------------------------------------
+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 this.client.request({
+            method: "POST",
+            path: "/v1/chat/completions",
+            body: { ...params, stream: false },
+            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
+            signal: options?.signal,
+            timeoutMs: options?.timeoutMs,
+        }).withResponse();
+        return toComposeCompletion(this.ctx, response, data);
+    }
+    stream(params, options) {
+        const iterator = streamChatCompletions(this.client, this.ctx, params, options);
+        return new ComposeStreamIterator(iterator);
+    }
+}
+async function* streamChatCompletions(client, ctx, params, options) {
+    const response = await client.request({
+        method: "POST",
+        path: "/v1/chat/completions",
+        body: { ...params, stream: true },
+        headers: buildCallHeaders(options, ctx.getWalletMaybe(), ctx.getTokenMaybe()),
+        signal: options?.signal,
+        timeoutMs: options?.timeoutMs,
+        expectStream: true,
+    }).asResponse();
+    if (!response.body) {
+        throw new ComposeError({
+            code: "upstream_error",
+            message: "Streaming response had no body",
+        });
+    }
+    let receipt = null;
+    const aggregator = buildChatCompletionAggregator(params.model);
+    let streamError = null;
+    try {
+        for await (const frame of parseSSEStream(response.body, { signal: options?.signal })) {
+            if (frame.event === "compose.receipt") {
+                try {
+                    receipt = parseReceiptEvent(frame.data);
+                }
+                catch { /* ignore */ }
+                continue;
+            }
+            if (frame.event === "compose.error") {
+                try {
+                    const parsed = JSON.parse(frame.data);
+                    streamError = new ComposeError({
+                        code: parsed.code ?? "upstream_error",
+                        message: parsed.message ?? "Stream error",
+                        details: parsed.details,
+                    });
+                }
+                catch { /* ignore */ }
+                continue;
+            }
+            if (frame.data === "[DONE]") {
+                break;
+            }
+            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);
+            yield parsed;
+        }
+        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);
+                }
+            }
+        },
+        finalize() {
+            return {
+                id,
+                object: "chat.completion",
+                created,
+                model,
+                choices: [
+                    {
+                        index: 0,
+                        message: {
+                            role: role ?? "assistant",
+                            content,
+                            ...(toolCalls.size > 0 ? { tool_calls: Array.from(toolCalls.values()) } : {}),
+                            ...(reasoningContent.length > 0 ? { reasoning_content: reasoningContent } : {}),
+                        },
+                        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 this.client.request({
+            method: "POST",
+            path: "/v1/responses",
+            body: { ...params, stream: false },
+            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
+            signal: options?.signal,
+            timeoutMs: options?.timeoutMs,
+        }).withResponse();
+        return toComposeCompletion(this.ctx, response, data);
+    }
+    stream(params, options) {
+        const iterator = streamResponses(this.client, this.ctx, params, options);
+        return new ComposeStreamIterator(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 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 client.request({
+        method: "POST",
+        path: "/v1/responses",
+        body: { ...params, stream: true },
+        headers: buildCallHeaders(options, ctx.getWalletMaybe(), ctx.getTokenMaybe()),
+        signal: options?.signal,
+        timeoutMs: options?.timeoutMs,
+        expectStream: true,
+    }).asResponse();
+    if (!response.body) {
+        throw new ComposeError({ code: "upstream_error", message: "Streaming response had no body" });
+    }
+    let receipt = null;
+    let lastCompleted = null;
+    let streamError = null;
+    try {
+        for await (const frame of parseSSEStream(response.body, { signal: options?.signal })) {
+            if (frame.event === "compose.receipt") {
+                try {
+                    receipt = parseReceiptEvent(frame.data);
+                }
+                catch { /* ignore */ }
+                continue;
+            }
+            if (frame.event === "compose.error") {
+                try {
+                    const parsed = JSON.parse(frame.data);
+                    streamError = new ComposeError({
+                        code: parsed.code ?? "upstream_error",
+                        message: parsed.message ?? "Stream error",
+                    });
+                }
+                catch { /* ignore */ }
+                continue;
+            }
+            if (frame.data === "[DONE]") {
+                break;
+            }
+            if (frame.event !== "message")
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(frame.data);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.type === "response.completed") {
+                lastCompleted = parsed;
+            }
+            yield parsed;
+        }
+        if (streamError)
+            throw streamError;
+        const finalResponse = lastCompleted
+            ? {
+                id: lastCompleted.response_id,
+                object: "response",
+                created_at: Math.floor(Date.now() / 1000),
+                status: "completed",
+                model: lastCompleted.model,
+                output: [],
+                ...(lastCompleted.usage
+                    ? {
+                        usage: {
+                            input_tokens: lastCompleted.usage.input_tokens,
+                            output_tokens: lastCompleted.usage.output_tokens,
+                            total_tokens: lastCompleted.usage.total_tokens,
+                        },
+                    }
+                    : {}),
+            }
+            : null;
+        const requestId = response.headers.get("x-request-id") ?? response.headers.get("X-Request-Id");
+        const { budget, sessionInvalidReason } = emitStreamingEvents(ctx, response, receipt, requestId);
+        return {
+            response: finalResponse,
+            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 this.client.request({
+            method: "POST",
+            path: "/v1/embeddings",
+            body: params,
+            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
+            signal: options?.signal,
+            timeoutMs: options?.timeoutMs,
+        }).withResponse();
+        return toComposeCompletion(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 this.client.request({
+            method: "POST",
+            path: "/v1/images/generations",
+            body: params,
+            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
+            signal: options?.signal,
+            timeoutMs: options?.timeoutMs,
+        }).withResponse();
+        return toComposeCompletion(this.ctx, response, data);
+    }
+    async edit(params, options) {
+        const { data, response } = await this.client.request({
+            method: "POST",
+            path: "/v1/images/edits",
+            body: params,
+            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
+            signal: options?.signal,
+            timeoutMs: options?.timeoutMs,
+        }).withResponse();
+        return toComposeCompletion(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 this.client.request({
+            method: "POST",
+            path: "/v1/audio/speech",
+            body: params,
+            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
+            signal: options?.signal,
+            timeoutMs: options?.timeoutMs,
+            expectStream: true,
+        }).asResponse();
+        // 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. 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.
+     */
+    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 this.client.request({
+                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,
+            }).withResponse();
+            return toComposeCompletion(this.ctx, response, data);
+        }
+        const { data, response } = await this.client.request({
+            method: "POST",
+            path: "/v1/audio/transcriptions",
+            body: params,
+            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
+            signal: options?.signal,
+            timeoutMs: options?.timeoutMs,
+        }).withResponse();
+        return toComposeCompletion(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 this.client.request({
+            method: "POST",
+            path: "/v1/videos/generations",
+            body: params,
+            headers: buildCallHeaders(options, this.ctx.getWalletMaybe(), this.ctx.getTokenMaybe()),
+            signal: options?.signal,
+            timeoutMs: options?.timeoutMs,
+        }).withResponse();
+        return toComposeCompletion(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 ComposeStreamIterator(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 ComposeError({ code: "upstream_error", message: "Streaming response had no body" });
+    }
+    let lastStatus = null;
+    try {
+        for await (const frame of parseSSEStream(response.body, { signal: opts.signal })) {
+            if (frame.data === "[DONE]") {
+                yield { type: "done" };
+                break;
+            }
+            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,
+                    };
+                    yield { type: "compose.video.status", ...parsed };
+                }
+                catch { /* skip malformed frame */ }
+                continue;
+            }
+            if (frame.event === "compose.error") {
+                try {
+                    const parsed = JSON.parse(frame.data);
+                    yield { type: "compose.error", code: parsed.code ?? "upstream_error", message: parsed.message ?? "Stream error", details: parsed.details };
+                }
+                catch { /* skip */ }
+                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