@poe-platform/safe-bash 0.1.788 → 0.1.790

package/dist/safe-bash/commands/llm/openai.js

@@ -1,289 +1,2 @@
-import { openAiBytes, openAiError, openAiJson, openAiRecord, openAiResponse } from "./openai-http.js";
-import { openAiChat } from "./openai-sse.js";
-import { acceptsMimeType } from "./mime.js";
-import { credential, providerLimits, jsonBody, multipart } from "./providers/shared.js";
-const numericOptions = {
-    chat: new Map([
-        ["temperature", ["number", 0, 2]], ["top_p", ["number", 0, 1]],
-        ["frequency_penalty", ["number", -2, 2]], ["presence_penalty", ["number", -2, 2]],
-        ["max_tokens", ["integer", 1, Number.MAX_SAFE_INTEGER]], ["max_completion_tokens", ["integer", 1, Number.MAX_SAFE_INTEGER]],
-        ["n", ["integer", 1, Number.MAX_SAFE_INTEGER]], ["seed", ["integer", Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]], ["top_logprobs", ["integer", 0, 20]],
-    ]),
-    images: new Map([
-        ["n", ["integer", 1, 10]], ["output_compression", ["integer", 0, 100]], ["partial_images", ["integer", 0, 3]],
-    ]),
-};
-function jsonOptions(options, endpoint) {
-    return Object.fromEntries(Object.entries(options).map(([key, value]) => {
-        if ((endpoint === "chat" ? ["store", "parallel_tool_calls", "logprobs"] : ["stream"]).includes(key)) {
-            if (value !== "true" && value !== "false" && typeof value !== "boolean")
-                throw new Error(`Invalid OpenAI option ${key}: expected boolean`);
-            return [key, value === true || value === "true"];
-        }
-        const numeric = numericOptions[endpoint].get(key);
-        if (!numeric)
-            return [key, value];
-        const [type, minimum, maximum] = numeric;
-        const number = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : NaN;
-        if (!Number.isFinite(number) || type === "integer" && !Number.isSafeInteger(number)) {
-            throw new Error(`Invalid OpenAI option ${key}: expected a finite ${type === "integer" ? "safe integer" : "number"}`);
-        }
-        if (number < minimum || number > maximum)
-            throw new RangeError(`Invalid OpenAI option ${key}: expected ${minimum}..${maximum}`);
-        return [key, number];
-    }));
-}
-function base64(bytes) {
-    let binary = "";
-    for (let offset = 0; offset < bytes.length; offset += 8192) {
-        binary += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
-    }
-    return btoa(binary);
-}
-// Keep image JSON and decoded output within a Worker-sized budget even when
-// the general provider response allowance is larger (e.g. video downloads).
-function imageSize(value) {
-    if (typeof value !== "string" || value.length === 0)
-        throw new Error("OpenAI image response has no b64_json");
-    if (value.length % 4 !== 0)
-        throw new Error("OpenAI image response contains non-canonical base64");
-    return value.length / 4 * 3 - (value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0);
-}
-function imageSlab(value) {
-    let decoded;
-    try {
-        decoded = atob(value);
-    }
-    catch {
-        throw new Error("OpenAI image response contains invalid base64");
-    }
-    if (btoa(decoded) !== value)
-        throw new Error("OpenAI image response contains non-canonical base64");
-    return decoded;
-}
-function* imageBytes(value, signal) {
-    for (let offset = 0; offset < value.length; offset += 8192) {
-        signal.throwIfAborted();
-        const decoded = imageSlab(value.slice(offset, offset + 8192));
-        const bytes = new Uint8Array(decoded.length);
-        for (let index = 0; index < decoded.length; index++)
-            bytes[index] = decoded.charCodeAt(index);
-        yield bytes;
-    }
-}
-function waitForPoll(signal, interval) {
-    signal.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        const abort = () => { clearTimeout(timer); signal.removeEventListener("abort", abort); reject(signal.reason); };
-        const timer = setTimeout(() => { signal.removeEventListener("abort", abort); resolve(); }, interval);
-        signal.addEventListener("abort", abort, { once: true });
-        if (signal.aborted)
-            abort();
-    });
-}
-function job(value, expectedId) {
-    if (value.error != null)
-        throw new Error(`OpenAI video failed: ${openAiError(value.error) ?? "unknown error"}`);
-    if (typeof value.id !== "string" || value.id.length === 0 || value.id === "." || value.id === ".." || (expectedId !== undefined && value.id !== expectedId)) {
-        throw new Error("OpenAI video response has an invalid job id");
-    }
-    if (value.status !== "queued" && value.status !== "in_progress" && value.status !== "completed") {
-        throw new Error(`OpenAI video failed: ${typeof value.status === "string" ? value.status : "invalid status"}`);
-    }
-    return { id: value.id, status: value.status };
-}
-export function createOpenAiProvider(options) {
-    const { transport, apiKey } = options;
-    const limits = providerLimits(options.limits);
-    if (typeof transport !== "function")
-        throw new TypeError("OpenAI requires an injected HTTP transport");
-    if (typeof apiKey !== "string" || !apiKey.trim() || apiKey.includes("\r") || apiKey.includes("\n"))
-        throw new TypeError("OpenAI requires a valid API key");
-    credential(apiKey);
-    const base = new URL(options.baseUrl ?? "https://api.openai.com/v1");
-    if ((base.protocol !== "https:" && base.protocol !== "http:") || base.username || base.password || base.search || base.hash) {
-        throw new TypeError("OpenAI baseUrl must be an HTTP(S) URL without credentials, query or fragment");
-    }
-    const baseUrl = base.href.endsWith("/") ? base.href.slice(0, -1) : base.href;
-    const configured = options.models.map(model => Object.freeze({
-        ...model,
-        capabilities: Object.freeze(model.capabilities ?? (model.endpoint === "chat" ? ["messages"] : model.endpoint === "embeddings" ? ["embed"] : [])),
-        ...(model.aliases === undefined ? {} : { aliases: Object.freeze([...model.aliases]) }),
-        ...(model.attachmentTypes === undefined ? {} : { attachmentTypes: Object.freeze([...model.attachmentTypes]) }),
-    }));
-    const byId = new Map();
-    for (const model of configured) {
-        if (!model.id || byId.has(model.id))
-            throw new TypeError(`OpenAI duplicate or empty model id: ${model.id}`);
-        if (!["chat", "images", "videos", "embeddings"].includes(model.endpoint))
-            throw new TypeError(`OpenAI invalid endpoint for model: ${model.id}`);
-        if (model.endpoint === "images" && !acceptsMimeType(["image/png", "image/jpeg", "image/webp"], model.outputType ?? ""))
-            throw new TypeError("Image models require outputType image/png, image/jpeg or image/webp");
-        if (model.endpoint === "videos" && !acceptsMimeType(["video/mp4"], model.outputType ?? ""))
-            throw new TypeError("Video models require outputType video/mp4");
-        if (model.endpoint === "chat" && model.outputType !== undefined && !acceptsMimeType(["text/*"], model.outputType))
-            throw new TypeError("Chat models require a text outputType");
-        byId.set(model.id, model);
-    }
-    return {
-        name: "openai", models: Object.freeze(configured),
-        async embed(request) {
-            request.signal.throwIfAborted();
-            const model = byId.get(request.model);
-            if (!model || model.endpoint !== "embeddings")
-                throw new Error(`Model ${request.model} does not support embeddings`);
-            const values = {};
-            for (const [key, value] of Object.entries(request.options)) {
-                if (key === "dimensions") {
-                    const number = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : NaN;
-                    if (!Number.isSafeInteger(number) || number < 1)
-                        throw new TypeError("Invalid OpenAI dimensions: expected a positive integer");
-                    values[key] = number;
-                }
-                else if (key === "user" && typeof value === "string")
-                    values[key] = value;
-                else
-                    throw new TypeError(`Unsupported OpenAI embedding option: ${key}`);
-            }
-            for await (const response of openAiResponse(transport, {
-                url: `${baseUrl}/embeddings`, method: "POST", signal: request.signal,
-                ...jsonBody({ ...values, model: request.model, input: request.inputs }, limits.maxRequestBytes),
-                headers: [["authorization", `Bearer ${apiKey}`], ["content-type", "application/json"]],
-            }, limits.maxResponseBytes)) {
-                const body = await openAiJson(response, request.signal, limits.maxResponseBytes);
-                if (!Array.isArray(body.data) || body.data.length !== request.inputs.length)
-                    throw new TypeError("Invalid OpenAI embedding response");
-                const vectors = new Array(request.inputs.length);
-                for (const item of body.data) {
-                    if (!openAiRecord(item) || !Number.isSafeInteger(item.index) || item.index < 0 || item.index >= vectors.length || vectors[item.index] !== undefined || !Array.isArray(item.embedding) || !item.embedding.length || item.embedding.some(value => typeof value !== "number" || !Number.isFinite(value)))
-                        throw new TypeError("Invalid OpenAI embedding response");
-                    vectors[item.index] = item.embedding;
-                }
-                if (vectors.some(vector => vector.length !== vectors[0]?.length))
-                    throw new TypeError("Invalid OpenAI embedding dimensions");
-                return { model: request.model, vectors, ...(openAiRecord(body.usage) ? { usage: body.usage } : {}) };
-            }
-            throw new Error("OpenAI returned no embedding response");
-        },
-        async *complete(request) {
-            request.signal.throwIfAborted();
-            const model = byId.get(request.model);
-            if (!model)
-                throw new Error(`Unknown model: ${request.model}`);
-            if (model.endpoint === "embeddings")
-                throw new TypeError("Embedding models require embed()");
-            if (model.endpoint !== "chat" && (request.messages?.length || request.schema !== undefined))
-                throw new TypeError("Messages and schemas require a chat model");
-            if (request.attachments.some(attachment => !acceptsMimeType(["image/*"], attachment.mimeType))) {
-                throw new Error(`OpenAI ${model.endpoint} endpoint only supports image attachments`);
-            }
-            if (model.endpoint === "videos" && request.attachments.length > 1)
-                throw new Error("OpenAI videos accepts only one input_reference image");
-            if (request.attachments.reduce((size, file) => size + file.bytes.byteLength, 0) > limits.maxRequestBytes)
-                throw new RangeError("Provider request byte limit exceeded");
-            if (model.endpoint !== "chat" && request.system !== undefined)
-                throw new TypeError("System prompts are supported only by chat models");
-            if (request.schema !== undefined && request.options.response_format !== undefined)
-                throw new TypeError("OpenAI option response_format conflicts with request schema");
-            const reserved = model.endpoint === "chat" ? ["model", "messages", "stream"]
-                : model.endpoint === "images" ? ["model", "prompt", "image", "image[]"] : ["model", "prompt", "input_reference"];
-            for (const key of Object.keys(request.options)) {
-                if (reserved.includes(key))
-                    throw new Error(`OpenAI option ${key} is controlled by the provider`);
-            }
-            const send = (path, method, body) => openAiResponse(transport, {
-                url: `${baseUrl}${path}`, method, signal: request.signal,
-                ...body, headers: [["authorization", `Bearer ${apiKey}`], ...(body?.headers ?? [])],
-            }, limits.maxResponseBytes);
-            if (model.endpoint === "chat") {
-                const messages = [];
-                if (request.system !== undefined)
-                    messages.push({ role: "system", content: request.system });
-                messages.push(...request.messages ?? []);
-                messages.push({ role: "user", content: request.attachments.length === 0 ? request.prompt : [
-                        { type: "text", text: request.prompt },
-                        ...request.attachments.map(attachment => ({ type: "image_url", image_url: { url: `data:${attachment.mimeType};base64,${base64(attachment.bytes)}` } })),
-                    ] });
-                let details;
-                for await (const response of send("/chat/completions", "POST", jsonBody({ ...jsonOptions(request.options, "chat"), ...(request.schema === undefined ? {} : { response_format: { type: "json_schema", json_schema: { name: "response", schema: request.schema } } }), model: request.model, messages, stream: true }, limits.maxRequestBytes))) {
-                    details = yield* openAiChat(response.body, request.signal, limits.maxEventBytes, limits.maxResponseBytes);
-                }
-                return details;
-            }
-            else if (model.endpoint === "images") {
-                const editing = request.attachments.length > 0;
-                const outputFormat = model.outputType.split(";", 1)[0].trim().toLowerCase().slice("image/".length);
-                if (request.options.output_format !== undefined && request.options.output_format !== outputFormat)
-                    throw new TypeError("output_format conflicts with model outputType");
-                const values = { ...jsonOptions(request.options, "images"), output_format: outputFormat, model: request.model, prompt: request.prompt };
-                if (values.stream === true)
-                    throw new TypeError("Image event streaming is not supported by this reference provider");
-                const body = editing ? multipart({ ...values, ...request.options }, request.attachments.map(file => ({ ...file, field: "image[]" })), limits.maxRequestBytes) : jsonBody(values, limits.maxRequestBytes);
-                for await (const response of send(editing ? "/images/edits" : "/images/generations", "POST", body)) {
-                    const value = await openAiJson(response, request.signal, limits.maxResponseBytes);
-                    if (value.error != null)
-                        throw new Error(`OpenAI: ${openAiError(value.error) ?? "image generation failed"}`);
-                    if (!Array.isArray(value.data) || value.data.length === 0)
-                        throw new Error("OpenAI image response has no images");
-                    let size = 0;
-                    const images = [];
-                    for (const item of value.data) {
-                        request.signal.throwIfAborted();
-                        if (!openAiRecord(item))
-                            throw new Error("OpenAI image response contains a malformed image");
-                        size += imageSize(item.b64_json);
-                        if (size > limits.maxResponseBytes)
-                            throw new RangeError("Provider image byte limit exceeded");
-                        images.push(item.b64_json);
-                    }
-                    // Validate every slab before publishing any output, including padding
-                    // in the middle of an image or a malformed later image.
-                    for (const image of images) {
-                        for (let offset = 0; offset < image.length; offset += 8192) {
-                            request.signal.throwIfAborted();
-                            const slab = image.slice(offset, offset + 8192);
-                            if (offset + 8192 < image.length && slab.includes("="))
-                                throw new Error("OpenAI image response contains non-canonical base64");
-                            imageSlab(slab);
-                        }
-                    }
-                    for (const image of images)
-                        yield* imageBytes(image, request.signal);
-                }
-            }
-            else {
-                let current;
-                for await (const response of send("/videos", "POST", multipart({ ...request.options, model: request.model, prompt: request.prompt }, request.attachments.map(file => ({ ...file, field: "input_reference" })), limits.maxRequestBytes))) {
-                    current = job(await openAiJson(response, request.signal, limits.maxResponseBytes));
-                }
-                if (!current)
-                    throw new Error("OpenAI video creation returned no job");
-                const path = `/videos/${encodeURIComponent(current.id)}`;
-                let polls = 0;
-                while (current.status !== "completed") {
-                    if (polls++ >= limits.maxPolls)
-                        throw new RangeError("Provider video polling limit exceeded");
-                    await waitForPoll(request.signal, limits.pollIntervalMs);
-                    for await (const response of send(path, "GET"))
-                        current = job(await openAiJson(response, request.signal, limits.maxResponseBytes), current.id);
-                }
-                for await (const response of send(`${path}/content`, "GET")) {
-                    const contentType = response.headers.find(([name]) => name.toLowerCase() === "content-type")?.[1].split(";")[0]?.trim().toLowerCase();
-                    if (contentType && contentType !== "application/octet-stream" && !contentType.startsWith("video/")) {
-                        throw new Error(`OpenAI video download has unexpected content type: ${contentType}`);
-                    }
-                    let received = false;
-                    for await (const chunk of openAiBytes(response.body, request.signal, limits.maxResponseBytes)) {
-                        if (chunk.byteLength === 0)
-                            continue;
-                        received = true;
-                        yield chunk;
-                    }
-                    if (!received)
-                        throw new Error("OpenAI video download is empty");
-                }
-            }
-        },
-    };
-}
+export * from "../../../safe-bash-command-llm/openai.js";
 //# sourceMappingURL=openai.js.map

package/dist/safe-bash/commands/llm/providers/elevenlabs.d.ts

@@ -1,2 +1,2 @@
-export { createElevenLabsProvider, type ElevenLabsProviderOptions, type ElevenLabsModel } from "../elevenlabs.js";
+export * from "../../../../safe-bash-command-llm/providers/elevenlabs.js";
 //# sourceMappingURL=elevenlabs.d.ts.map

package/dist/safe-bash/commands/llm/providers/elevenlabs.js

@@ -1,2 +1,2 @@
-export { createElevenLabsProvider } from "../elevenlabs.js";
+export * from "../../../../safe-bash-command-llm/providers/elevenlabs.js";
 //# sourceMappingURL=elevenlabs.js.map

package/dist/safe-bash/commands/llm/providers/index.browser.js

@@ -1,10 +1,10 @@
-import "../../../chunks/chunk-VYW4Q6KF.js";
 import {
-  createElevenLabsProvider,
-  createOpenAiProvider
-} from "../../../chunks/chunk-S2LSZFZ6.js";
-import "../../../chunks/chunk-LD76P7AG.js";
-import "../../../chunks/chunk-Q45QCA4J.js";
+  init_platform
+} from "../../../chunks/chunk-I3KSESCR.js";
+
+// packages/safe-bash/src/commands/llm/providers/index.ts
+init_platform();
+import { createElevenLabsProvider, createOpenAiProvider } from "../../../../safe-bash-command-llm/providers/index.js";
 export {
   createElevenLabsProvider,
   createOpenAiProvider

package/dist/safe-bash/commands/llm/providers/index.d.ts

@@ -1,4 +1,2 @@
-export { createOpenAiProvider, type OpenAiProviderOptions, type OpenAiModel } from "./openai.js";
-export { createElevenLabsProvider, type ElevenLabsProviderOptions, type ElevenLabsModel } from "./elevenlabs.js";
-export type { LlmProviderLimits } from "./shared.js";
+export * from "../../../../safe-bash-command-llm/providers/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/safe-bash/commands/llm/providers/index.js

@@ -1,3 +1,2 @@
-export { createOpenAiProvider } from "./openai.js";
-export { createElevenLabsProvider } from "./elevenlabs.js";
+export * from "../../../../safe-bash-command-llm/providers/index.js";
 //# sourceMappingURL=index.js.map

package/dist/safe-bash/commands/llm/providers/openai.d.ts

@@ -1,2 +1,2 @@
-export { createOpenAiProvider, type OpenAiProviderOptions, type OpenAiModel } from "../openai.js";
+export * from "../../../../safe-bash-command-llm/providers/openai.js";
 //# sourceMappingURL=openai.d.ts.map

package/dist/safe-bash/commands/llm/providers/openai.js

@@ -1,2 +1,2 @@
-export { createOpenAiProvider } from "../openai.js";
+export * from "../../../../safe-bash-command-llm/providers/openai.js";
 //# sourceMappingURL=openai.js.map

package/dist/safe-bash/commands/llm/providers/shared.d.ts

@@ -1,24 +1,2 @@
-import type { ByteSource } from "../../../contracts/io.js";
-import type { HttpHeaders } from "../../network/types.js";
-export interface LlmProviderLimits {
-    readonly maxRequestBytes: number;
-    readonly maxResponseBytes: number;
-    readonly maxEventBytes: number;
-    readonly maxPolls: number;
-    readonly pollIntervalMs: number;
-}
-export declare function providerLimits(input?: Partial<LlmProviderLimits>): LlmProviderLimits;
-export declare function credential(value: string): string;
-export declare function jsonBody(value: unknown, limit: number): {
-    body: ByteSource;
-    headers: HttpHeaders;
-};
-export declare function multipart(options: Record<string, unknown>, files: readonly {
-    field: string;
-    mimeType: string;
-    bytes: Uint8Array;
-}[], limit: number): {
-    body: ByteSource;
-    headers: HttpHeaders;
-};
+export * from "../../../../safe-bash-command-llm/providers/shared.js";
 //# sourceMappingURL=shared.d.ts.map

package/dist/safe-bash/commands/llm/providers/shared.js

@@ -1,66 +1,2 @@
-export function providerLimits(input = {}) {
-    const limits = { maxRequestBytes: Infinity, maxResponseBytes: Infinity, maxEventBytes: Infinity, maxPolls: Infinity, pollIntervalMs: 1000, ...input };
-    for (const [name, value] of Object.entries(limits)) {
-        if (name !== "pollIntervalMs" && value === Infinity)
-            continue;
-        if (!Number.isSafeInteger(value) || value < (name === "maxPolls" || name === "pollIntervalMs" ? 0 : 1))
-            throw new RangeError(`Invalid provider limit: ${name}`);
-    }
-    return Object.freeze(limits);
-}
-export function credential(value) {
-    if (typeof value !== "string" || value.length === 0 || [...value].some(char => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127))
-        throw new TypeError("Invalid provider apiKey");
-    return value;
-}
-export function jsonBody(value, limit) {
-    const text = JSON.stringify(value);
-    if (text.length > limit)
-        throw new RangeError("Provider request byte limit exceeded");
-    const bytes = new TextEncoder().encode(text);
-    if (bytes.length > limit)
-        throw new RangeError("Provider request byte limit exceeded");
-    return { body: (async function* () { yield bytes; })(), headers: [["content-type", "application/json"]] };
-}
-export function multipart(options, files, limit) {
-    const encoder = new TextEncoder();
-    const parts = [];
-    const entries = Object.entries(options).map(([name, value]) => {
-        if (![...name].every(char => "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-".includes(char)))
-            throw new TypeError("Invalid multipart option name");
-        return [name, String(value)];
-    });
-    let size = files.reduce((sum, file) => sum + file.bytes.length, 0);
-    for (const [, value] of entries) {
-        if (value.length > limit)
-            throw new RangeError("Provider request byte limit exceeded");
-        size += encoder.encode(value).length;
-    }
-    if (size > limit)
-        throw new RangeError("Provider request byte limit exceeded");
-    let boundary = "safe-bash-llm-boundary";
-    const contains = (bytes, needle) => {
-        outer: for (let start = 0; start <= bytes.length - needle.length; start++) {
-            for (let index = 0; index < needle.length; index++)
-                if (bytes[start + index] !== needle[index])
-                    continue outer;
-            return true;
-        }
-        return false;
-    };
-    while (entries.some(([, value]) => value.includes(boundary)) || files.some(file => contains(file.bytes, encoder.encode(boundary)))) {
-        boundary += "x";
-    }
-    for (const [name, value] of entries)
-        parts.push(encoder.encode(`--${boundary}\r\nContent-Disposition: form-data; name="${name}"\r\n\r\n${value}\r\n`));
-    for (const [index, file] of files.entries()) {
-        if ([...file.mimeType].some(char => char.charCodeAt(0) < 32 || char.charCodeAt(0) > 126))
-            throw new TypeError("Invalid attachment MIME type");
-        parts.push(encoder.encode(`--${boundary}\r\nContent-Disposition: form-data; name="${file.field}"; filename="attachment-${index}"\r\nContent-Type: ${file.mimeType}\r\n\r\n`), Uint8Array.from(file.bytes), encoder.encode("\r\n"));
-    }
-    parts.push(encoder.encode(`--${boundary}--\r\n`));
-    if (parts.reduce((sum, part) => sum + part.length, 0) > limit)
-        throw new RangeError("Provider request byte limit exceeded");
-    return { body: (async function* () { yield* parts; })(), headers: [["content-type", `multipart/form-data; boundary=${boundary}`]] };
-}
+export * from "../../../../safe-bash-command-llm/providers/shared.js";
 //# sourceMappingURL=shared.js.map

package/dist/safe-bash/commands/llm/service.d.ts

@@ -1,38 +1,2 @@
-import type { LlmModel, LlmProvider, LlmRequest, LlmEmbeddingRequest, LlmEmbeddingResponse, LlmResponseMetadata } from "./types.js";
-export interface LlmServiceOptions {
-    readonly providers: readonly LlmProvider[];
-    readonly defaultModel?: string;
-}
-export interface LlmServiceModel {
-    readonly provider: LlmProvider;
-    readonly model: LlmModel;
-}
-export interface LlmServiceRequest extends Omit<LlmRequest, "model"> {
-    readonly model?: string;
-    readonly maxOutputBytes?: number;
-}
-export type LlmStreamEvent = {
-    readonly type: "text";
-    readonly text: string;
-} | {
-    readonly type: "bytes";
-    readonly data: Uint8Array;
-} | {
-    readonly type: "response";
-    readonly response: LlmResponseMetadata & {
-        readonly model: string;
-    };
-};
-/** Structured host API shared by shell and other language front ends. */
-export interface LlmService {
-    readonly version: 1;
-    readonly models: readonly LlmServiceModel[];
-    resolve(model?: string): LlmServiceModel;
-    complete(request: LlmServiceRequest): AsyncIterable<string | Uint8Array, LlmResponseMetadata | void>;
-    stream(request: LlmServiceRequest): AsyncIterable<LlmStreamEvent>;
-    embed(request: Omit<LlmEmbeddingRequest, "model"> & {
-        readonly model?: string;
-    }): Promise<LlmEmbeddingResponse>;
-}
-export declare function createLlmService(options: LlmServiceOptions): LlmService;
+export * from "../../../safe-bash-command-llm/service.js";
 //# sourceMappingURL=service.d.ts.map

package/dist/safe-bash/commands/llm/service.js

@@ -1,152 +1,2 @@
-import { acceptsMimeType } from "./mime.js";
-function abortable(start, signal) {
-    signal.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason); };
-        signal.addEventListener("abort", abort, { once: true });
-        Promise.resolve().then(() => { signal.throwIfAborted(); return start(); }).then(value => { signal.removeEventListener("abort", abort); if (signal.aborted)
-            reject(signal.reason);
-        else
-            resolve(value); }, error => { signal.removeEventListener("abort", abort); reject(signal.aborted ? signal.reason : error); });
-        if (signal.aborted)
-            abort();
-    });
-}
-function validateMetadata(value) {
-    for (const field of [value.usage, value.metadata]) {
-        if (field !== undefined && (!field || typeof field !== "object" || Array.isArray(field)))
-            throw new TypeError("Invalid LLM response metadata");
-    }
-}
-function validateOptions(options) {
-    for (const [key, value] of Object.entries(options)) {
-        if (!key || value !== null && !["string", "number", "boolean"].includes(typeof value) || typeof value === "number" && !Number.isFinite(value)) {
-            throw new TypeError(`Invalid model option ${key}: expected a finite scalar`);
-        }
-    }
-}
-export function createLlmService(options) {
-    const models = [];
-    const lookup = new Map();
-    const defaultModel = options.defaultModel;
-    for (const provider of options.providers) {
-        if (!provider.name || typeof provider.complete !== "function")
-            throw new TypeError("Providers require a name and complete function");
-        for (const declared of provider.models) {
-            if (!declared.id)
-                throw new TypeError("Models require a nonempty id");
-            const model = Object.freeze({ ...declared,
-                ...(declared.capabilities ? { capabilities: Object.freeze([...declared.capabilities]) } : {}),
-                ...(declared.aliases ? { aliases: Object.freeze([...declared.aliases]) } : {}),
-                ...(declared.attachmentTypes ? { attachmentTypes: Object.freeze([...declared.attachmentTypes]) } : {}),
-            });
-            const entry = Object.freeze({ provider, model });
-            for (const name of new Set([model.id, `${provider.name}/${model.id}`, ...model.aliases ?? []])) {
-                if (!name)
-                    throw new TypeError("Model aliases must not be empty");
-                if (lookup.has(name))
-                    throw new Error(`Duplicate model id or alias: ${name}`);
-                lookup.set(name, entry);
-            }
-            models.push(entry);
-        }
-    }
-    return Object.freeze({
-        version: 1,
-        models: Object.freeze(models),
-        resolve(model) {
-            const selected = model ?? defaultModel;
-            if (selected === undefined)
-                throw new Error("No model selected; use --model or configure defaultModel");
-            const entry = lookup.get(selected);
-            if (!entry)
-                throw new Error(`Unknown model: ${selected}`);
-            return entry;
-        },
-        complete(request) {
-            request.signal.throwIfAborted();
-            validateOptions(request.options);
-            if (typeof request.prompt !== "string" || request.system !== undefined && typeof request.system !== "string")
-                throw new TypeError("Invalid LLM prompt");
-            const entry = this.resolve(request.model);
-            if (request.messages?.length && !entry.model.capabilities?.includes("messages"))
-                throw new Error(`Model ${entry.model.id} does not support messages`);
-            if (request.messages?.some(message => !["system", "user", "assistant"].includes(message.role) || typeof message.content !== "string"))
-                throw new TypeError("Invalid LLM message");
-            if (request.schema !== undefined) {
-                if (!entry.model.capabilities?.includes("schema"))
-                    throw new Error(`Model ${entry.model.id} does not support schema`);
-                if (!request.schema || typeof request.schema !== "object" || Array.isArray(request.schema))
-                    throw new TypeError("Invalid LLM schema");
-            }
-            for (const attachment of request.attachments) {
-                if (!acceptsMimeType(entry.model.attachmentTypes ?? [], attachment.mimeType)) {
-                    throw new Error(`Model ${entry.model.id} does not accept ${attachment.mimeType}`);
-                }
-            }
-            const { maxOutputBytes: ignoredMaxOutputBytes, ...input } = request;
-            return entry.provider.complete({ ...input, model: entry.model.id });
-        },
-        async *stream(request) {
-            const limit = request.maxOutputBytes ?? Infinity;
-            if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 0))
-                throw new RangeError("Invalid LLM output limit");
-            const entry = this.resolve(request.model);
-            const iterator = this.complete(request)[Symbol.asyncIterator]();
-            let ended = false;
-            let size = 0;
-            try {
-                while (true) {
-                    request.signal.throwIfAborted();
-                    const result = await abortable(() => iterator.next(), request.signal);
-                    request.signal.throwIfAborted();
-                    if (result.done) {
-                        ended = true;
-                        const metadata = result.value;
-                        if (metadata !== undefined && (!metadata || typeof metadata !== "object" || Array.isArray(metadata)))
-                            throw new TypeError("Invalid LLM response metadata");
-                        const details = metadata;
-                        if (details)
-                            validateMetadata(details);
-                        yield { type: "response", response: { model: entry.model.id, ...(details?.usage ? { usage: details.usage } : {}), ...(details?.metadata ? { metadata: details.metadata } : {}) } };
-                        return;
-                    }
-                    const chunk = result.value;
-                    const text = (entry.model.outputType ?? "text/plain").toLowerCase().startsWith("text/");
-                    if (text ? typeof chunk !== "string" : !(chunk instanceof Uint8Array))
-                        throw new TypeError("Provider returned an incompatible LLM output chunk");
-                    size += typeof chunk === "string" ? new TextEncoder().encode(chunk).length : chunk.byteLength;
-                    if (size > limit)
-                        throw new RangeError("LLM output byte limit exceeded");
-                    yield typeof chunk === "string" ? { type: "text", text: chunk } : { type: "bytes", data: new Uint8Array(chunk) };
-                }
-            }
-            finally {
-                if (!ended) {
-                    const closing = Promise.resolve().then(() => iterator.return?.());
-                    if (request.signal.aborted)
-                        void closing.catch(() => undefined);
-                    else
-                        await closing;
-                }
-            }
-        },
-        async embed(request) {
-            request.signal.throwIfAborted();
-            validateOptions(request.options);
-            if (!Array.isArray(request.inputs) || Array.from(request.inputs).some(input => typeof input !== "string"))
-                throw new TypeError("Embedding inputs must be strings");
-            const entry = this.resolve(request.model);
-            if (!entry.model.capabilities?.includes("embed") || !entry.provider.embed)
-                throw new Error(`Model ${entry.model.id} does not support embeddings`);
-            const embed = entry.provider.embed.bind(entry.provider);
-            const result = await abortable(() => embed({ ...request, model: entry.model.id }), request.signal);
-            request.signal.throwIfAborted();
-            if (result.model !== entry.model.id || !Array.isArray(result.vectors) || result.vectors.length !== request.inputs.length || Array.from(result.vectors).some(vector => !Array.isArray(vector) || !vector.length || Array.from(vector).some(value => typeof value !== "number" || !Number.isFinite(value)) || vector.length !== result.vectors[0]?.length))
-                throw new TypeError("Invalid embedding response");
-            validateMetadata(result);
-            return result;
-        },
-    });
-}
+export * from "../../../safe-bash-command-llm/service.js";
 //# sourceMappingURL=service.js.map