@poe-platform/safe-bash 0.1.789 → 0.1.790

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

@@ -1,118 +1,2 @@
-async function abortable(operation, signal) {
-    signal.throwIfAborted();
-    let onAbort;
-    const aborted = new Promise((_resolve, reject) => {
-        onAbort = () => reject(signal.reason);
-        signal.addEventListener("abort", onAbort, { once: true });
-    });
-    try {
-        return await Promise.race([Promise.resolve().then(() => { signal.throwIfAborted(); return operation(); }), aborted]);
-    }
-    finally {
-        signal.removeEventListener("abort", onAbort);
-    }
-}
-export async function* streamElevenLabs(transport, request, limit = Infinity) {
-    const { signal } = request;
-    signal.throwIfAborted();
-    let iterator;
-    let finished = false;
-    let failed = false;
-    let closed = false;
-    let size = 0;
-    const cleanups = new Map();
-    const runCleanup = (entry) => {
-        return entry.pending ??= Promise.resolve().then(entry.run);
-    };
-    const register = (cleanup, receiver) => {
-        if (cleanups.has(cleanup))
-            return;
-        const entry = { run: () => cleanup.call(receiver) };
-        cleanups.set(cleanup, entry);
-        if (closed)
-            void runCleanup(entry).catch(() => { });
-    };
-    const dispose = async () => {
-        closed = true;
-        let seen = 0;
-        const failures = [];
-        while (seen < cleanups.size) {
-            const entries = [...cleanups.values()].slice(seen);
-            seen = cleanups.size;
-            const results = await Promise.allSettled(entries.map(runCleanup));
-            for (const result of results)
-                if (result.status === "rejected")
-                    failures.push(result.reason);
-        }
-        if (failures.length)
-            throw failures[0];
-    };
-    const close = async () => {
-        const failures = [];
-        try {
-            await dispose();
-        }
-        catch (error) {
-            failures.push(error);
-        }
-        if (!finished && iterator?.return) {
-            const closing = Promise.resolve().then(() => iterator.return());
-            if (signal.aborted)
-                void closing.catch(() => { });
-            else {
-                try {
-                    await closing;
-                }
-                catch (error) {
-                    failures.push(error);
-                }
-            }
-        }
-        if (!failed) {
-            signal.throwIfAborted();
-            if (failures.length)
-                throw failures[0];
-        }
-    };
-    const onAbort = () => { void dispose().catch(() => { }); };
-    signal.addEventListener("abort", onAbort, { once: true });
-    try {
-        const acquired = await abortable(async () => {
-            signal.throwIfAborted();
-            const response = await transport({ ...request, registerCleanup: register });
-            register(response.dispose, response);
-            if (signal.aborted) {
-                await dispose();
-                signal.throwIfAborted();
-            }
-            return response;
-        }, signal);
-        signal.throwIfAborted();
-        if (acquired.status < 200 || acquired.status >= 300)
-            throw new Error(`ElevenLabs HTTP ${acquired.status}: ${acquired.statusText}`);
-        iterator = acquired.body[Symbol.asyncIterator]();
-        while (true) {
-            const next = await abortable(() => iterator.next(), signal);
-            signal.throwIfAborted();
-            if (next.done) {
-                finished = true;
-                return;
-            }
-            if (!(next.value instanceof Uint8Array))
-                throw new TypeError("ElevenLabs audio stream must yield Uint8Array chunks");
-            size += next.value.byteLength;
-            if (size > limit)
-                throw new RangeError("Provider response byte limit exceeded");
-            yield Uint8Array.from(next.value);
-        }
-    }
-    catch (error) {
-        failed = true;
-        throw error;
-    }
-    finally {
-        signal.removeEventListener("abort", onAbort);
-        await close();
-    }
-}
+export * from "../../../safe-bash-command-llm/elevenlabs-stream.js";
 //# sourceMappingURL=elevenlabs-stream.js.map

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

@@ -1,16 +1,2 @@
-import type { HttpTransport } from "../network/types.js";
-import type { LlmModel, LlmProvider } from "./types.js";
-import { type LlmProviderLimits } from "./providers/shared.js";
-export interface ElevenLabsModel extends LlmModel {
-    readonly endpoint: "tts" | "music";
-    readonly defaultVoiceId?: string;
-}
-export interface ElevenLabsProviderOptions {
-    readonly transport: HttpTransport;
-    readonly apiKey: string;
-    readonly baseUrl?: string;
-    readonly models: readonly ElevenLabsModel[];
-    readonly limits?: Partial<LlmProviderLimits>;
-}
-export declare function createElevenLabsProvider(options: ElevenLabsProviderOptions): LlmProvider;
+export * from "../../../safe-bash-command-llm/elevenlabs.js";
 //# sourceMappingURL=elevenlabs.d.ts.map

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

@@ -1,124 +1,2 @@
-import { streamElevenLabs } from "./elevenlabs-stream.js";
-import { acceptsMimeType } from "./mime.js";
-import { credential, providerLimits, jsonBody } from "./providers/shared.js";
-const outputFormats = new Map([
-    ["audio/mpeg", "mp3_44100_128"],
-    ["audio/wav", "wav_44100"],
-    ["audio/x-wav", "wav_44100"],
-    ["audio/pcm", "pcm_44100"],
-    ["audio/basic", "ulaw_8000"],
-    ["audio/opus", "opus_48000_128"],
-    ["audio/ogg", "opus_48000_128"],
-]);
-const optionTypes = {
-    tts: new Map([
-        ["stability", "number"], ["similarity_boost", "number"], ["style", "number"],
-        ["speed", "number"], ["use_speaker_boost", "boolean"],
-    ]),
-    music: new Map([
-        ["music_length_ms", "integer"], ["seed", "integer"], ["force_instrumental", "boolean"],
-        ["respect_sections_durations", "boolean"], ["store_for_inpainting", "boolean"],
-        ["sign_with_c2pa", "boolean"],
-    ]),
-};
-function parseOptions(options, endpoint) {
-    return Object.fromEntries(Object.entries(options).map(([key, value]) => {
-        const type = optionTypes[endpoint].get(key);
-        if (!type)
-            return [key, value];
-        if (type === "boolean") {
-            if (typeof value === "boolean")
-                return [key, value];
-            if (value === "true" || value === "false")
-                return [key, value === "true"];
-        }
-        else {
-            const number = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : NaN;
-            if (Number.isFinite(number) && (type !== "integer" || Number.isSafeInteger(number)))
-                return [key, number];
-        }
-        throw new Error(`Invalid ElevenLabs option ${key}: expected ${type}`);
-    }));
-}
-export function createElevenLabsProvider(options) {
-    const transport = options.transport;
-    if (typeof transport !== "function")
-        throw new TypeError("Provider transport is required");
-    const apiKey = credential(options.apiKey);
-    const limits = providerLimits(options.limits);
-    const baseUrl = new URL(options.baseUrl ?? "https://api.elevenlabs.io");
-    if (!["https:", "http:"].includes(baseUrl.protocol) || baseUrl.username || baseUrl.password || baseUrl.search || baseUrl.hash) {
-        throw new Error("Invalid ElevenLabs baseUrl: expected an HTTP(S) URL without credentials, query, or fragment");
-    }
-    if (!baseUrl.pathname.endsWith("/"))
-        baseUrl.pathname += "/";
-    const models = options.models.map(model => Object.freeze({
-        ...model,
-        ...(model.aliases === undefined ? {} : { aliases: Object.freeze([...model.aliases]) }),
-        ...(model.attachmentTypes === undefined ? {} : { attachmentTypes: Object.freeze([...model.attachmentTypes]) }),
-    }));
-    const byId = new Map();
-    for (const model of models) {
-        if (model.endpoint !== "tts" && model.endpoint !== "music")
-            throw new Error(`Invalid ElevenLabs endpoint: ${model.endpoint}`);
-        if (!model.outputType)
-            throw new TypeError("ElevenLabs models require an audio outputType");
-        const mimeType = model.outputType.split(";", 1)[0].trim().toLowerCase();
-        const format = outputFormats.get(mimeType);
-        if (!format || !acceptsMimeType([mimeType], model.outputType) || (model.endpoint === "music" && format.startsWith("wav_"))) {
-            throw new Error(`Unsupported ElevenLabs outputType for ${model.endpoint}: ${model.outputType}`);
-        }
-        if (model.attachmentTypes?.length)
-            throw new Error(`ElevenLabs model ${model.id} does not accept attachments`);
-        if (!model.id || byId.has(model.id))
-            throw new Error(`Duplicate or empty ElevenLabs model: ${model.id}`);
-        byId.set(model.id, { model, format });
-    }
-    return {
-        name: "elevenlabs",
-        models: Object.freeze(models),
-        async *complete(request) {
-            request.signal.throwIfAborted();
-            const entry = byId.get(request.model);
-            if (!entry)
-                throw new Error(`Unknown model: ${request.model}`);
-            const { model, format } = entry;
-            if (request.attachments.length)
-                throw new Error(`Model ${model.id} does not accept ${request.attachments[0].mimeType} attachments`);
-            if (request.messages?.length || request.schema !== undefined)
-                throw new TypeError("ElevenLabs reference endpoints do not accept messages or schemas");
-            if (request.system !== undefined)
-                throw new TypeError("ElevenLabs reference endpoints do not accept system prompts");
-            const { output_format: requestedFormat, ...requestOptions } = request.options;
-            if (requestedFormat !== undefined && requestedFormat !== format)
-                throw new TypeError("output_format conflicts with model outputType");
-            let path;
-            let body;
-            if (model.endpoint === "tts") {
-                const { voice_id: suppliedVoice, ...settings } = requestOptions;
-                const voice = suppliedVoice ?? model.defaultVoiceId;
-                if (typeof voice !== "string" || !voice.trim())
-                    throw new Error(`ElevenLabs model ${model.id} requires voice_id or a configured defaultVoiceId`);
-                if (voice === "." || voice === "..")
-                    throw new Error("Invalid ElevenLabs voice_id: dot segments are not allowed");
-                path = `v1/text-to-speech/${encodeURIComponent(voice)}`;
-                body = { text: request.prompt, model_id: model.id, voice_settings: parseOptions(settings, model.endpoint) };
-            }
-            else {
-                path = "v1/music";
-                body = { ...parseOptions(requestOptions, model.endpoint), prompt: request.prompt, model_id: model.id };
-            }
-            const url = new URL(path, baseUrl);
-            url.searchParams.set("output_format", format);
-            const payload = jsonBody(body, limits.maxRequestBytes);
-            yield* streamElevenLabs(transport, {
-                url: url.href,
-                method: "POST",
-                headers: [["xi-api-key", apiKey], ...payload.headers, ["accept", model.outputType]],
-                body: payload.body,
-                signal: request.signal,
-            }, limits.maxResponseBytes);
-        },
-    };
-}
+export * from "../../../safe-bash-command-llm/elevenlabs.js";
 //# sourceMappingURL=elevenlabs.js.map

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

@@ -1,24 +1,29 @@
 import {
+  createElevenLabsProvider,
+  createLlmCommand,
   createLlmCommands,
+  createLlmConfiguration,
   createLlmService,
-  llmCommands
-} from "../../chunks/chunk-2MUJ7RLZ.js";
-import "../../chunks/chunk-2G2T5MEM.js";
-import "../../chunks/chunk-VUVKC6HV.js";
-import "../../chunks/chunk-LAPF2XE6.js";
-import "../../chunks/chunk-H7MMJS26.js";
-import "../../chunks/chunk-T3VDYWKZ.js";
-import "../../chunks/chunk-GJWUEOT6.js";
-import {
-  createElevenLabsProvider,
-  createOpenAiProvider
-} from "../../chunks/chunk-S2LSZFZ6.js";
-import "../../chunks/chunk-LD76P7AG.js";
-import "../../chunks/chunk-Q45QCA4J.js";
+  createLlmTemplateStore,
+  createOpenAiProvider,
+  evaluateLlmTemplate,
+  llmCommands,
+  parseLlmSchemaDsl,
+  validateLlmTemplateParameters,
+  validateModelOptions
+} from "../../chunks/chunk-GAYRKQM6.js";
+import "../../chunks/chunk-I3KSESCR.js";
 export {
   createElevenLabsProvider,
+  createLlmCommand,
   createLlmCommands,
+  createLlmConfiguration,
   createLlmService,
+  createLlmTemplateStore,
   createOpenAiProvider,
-  llmCommands
+  evaluateLlmTemplate,
+  llmCommands,
+  parseLlmSchemaDsl,
+  validateLlmTemplateParameters,
+  validateModelOptions
 };

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

@@ -1,7 +1,2 @@
-export { createLlmCommands, llmCommands } from "./command.js";
-export { createLlmService, type LlmService, type LlmServiceOptions, type LlmServiceModel, type LlmStreamEvent, type LlmServiceRequest } from "./service.js";
-export type { LlmOption, LlmCapability, LlmResponseMetadata, LlmEmbeddingRequest, LlmEmbeddingResponse, LlmCommandsOptions, LlmProvider, LlmModel, LlmRequest } from "./types.js";
-export { createOpenAiProvider, type OpenAiModel, type OpenAiProviderOptions } from "./openai.js";
-export { createElevenLabsProvider, type ElevenLabsModel, type ElevenLabsProviderOptions } from "./elevenlabs.js";
-export type { LlmProviderLimits } from "./providers/shared.js";
+export * from "../../../safe-bash-command-llm/index.js";
 //# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,3 +1,2 @@
-export declare function sniffMimeType(path: string, bytes: Uint8Array): string;
-export declare function acceptsMimeType(types: readonly string[], mimeType: string): boolean;
+export * from "../../../safe-bash-command-llm/mime.js";
 //# sourceMappingURL=mime.d.ts.map

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

@@ -1,137 +1,2 @@
-import { classify } from "../../../safe-bash-command-file/classify.js";
-const extensions = {
-    png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp",
-    avif: "image/avif", heic: "image/heic", heif: "image/heif", bmp: "image/bmp", tif: "image/tiff", tiff: "image/tiff", svg: "image/svg+xml",
-    mp3: "audio/mpeg", wav: "audio/wav", ogg: "audio/ogg", oga: "audio/ogg", opus: "audio/ogg", flac: "audio/flac", aac: "audio/aac", m4a: "audio/mp4", aiff: "audio/aiff",
-    mp4: "video/mp4", m4v: "video/mp4", mov: "video/quicktime", webm: "video/webm", mkv: "video/x-matroska", avi: "video/x-msvideo", ogv: "video/ogg", mpeg: "video/mpeg", mpg: "video/mpeg",
-    pdf: "application/pdf", json: "application/json", zip: "application/zip", gz: "application/gzip",
-    txt: "text/plain", md: "text/markdown", csv: "text/csv", html: "text/html", xml: "application/xml",
-};
-function ebmlInteger(bytes, offset, retainMarker = false) {
-    const first = bytes[offset];
-    if (!first)
-        return undefined;
-    let marker = 128, width = 1;
-    while (!(first & marker)) {
-        marker >>= 1;
-        width++;
-    }
-    if (offset + width > bytes.length)
-        return undefined;
-    let value = retainMarker ? first : first & (marker - 1);
-    for (let index = 1; index < width; index++)
-        value = value * 256 + bytes[offset + index];
-    if (!Number.isSafeInteger(value) || !retainMarker && value === 2 ** (7 * width) - 1)
-        return undefined;
-    return { value, width };
-}
-function ebmlMimeType(bytes) {
-    const header = ebmlInteger(bytes, 4);
-    if (!header)
-        return undefined;
-    let offset = 4 + header.width;
-    const end = Math.min(bytes.length, offset + header.value, 4096);
-    while (offset < end) {
-        const identifier = ebmlInteger(bytes, offset, true);
-        if (!identifier)
-            return undefined;
-        offset += identifier.width;
-        const size = ebmlInteger(bytes, offset);
-        if (!size)
-            return undefined;
-        offset += size.width;
-        if (size.value > end - offset)
-            return undefined;
-        if (identifier.value === 0x4282) {
-            const docType = new TextDecoder().decode(bytes.subarray(offset, offset + size.value)).split("\0", 1)[0];
-            if (docType === "webm")
-                return "video/webm";
-            if (docType === "matroska")
-                return "video/x-matroska";
-            return undefined;
-        }
-        offset += size.value;
-    }
-    return undefined;
-}
-export function sniffMimeType(path, bytes) {
-    const matches = (signature, offset = 0) => bytes.length >= offset + signature.length && signature.every((byte, index) => bytes[offset + index] === byte);
-    const ascii = (offset, text) => bytes.length >= offset + text.length && [...text].every((character, index) => bytes[offset + index] === character.charCodeAt(0));
-    if (matches([137, 80, 78, 71, 13, 10, 26, 10]))
-        return "image/png";
-    if (matches([255, 216, 255]))
-        return "image/jpeg";
-    if (ascii(0, "GIF87a") || ascii(0, "GIF89a"))
-        return "image/gif";
-    if (ascii(0, "RIFF")) {
-        if (ascii(8, "WEBP"))
-            return "image/webp";
-        if (ascii(8, "WAVE"))
-            return "audio/wav";
-        if (ascii(8, "AVI "))
-            return "video/x-msvideo";
-    }
-    if (ascii(0, "fLaC"))
-        return "audio/flac";
-    if (ascii(0, "OggS")) {
-        const packet = 27 + (bytes[26] ?? 0);
-        if (bytes[26] && bytes[packet] === 0x80 && ascii(packet + 1, "theora"))
-            return "video/ogg";
-        return "audio/ogg";
-    }
-    if (ascii(0, "ID3") || bytes.length >= 2 && bytes[0] === 255 && (bytes[1] & 0xe0) === 0xe0 && (bytes[1] & 0x06) !== 0)
-        return "audio/mpeg";
-    if (bytes.length >= 2 && bytes[0] === 255 && (bytes[1] & 0xf6) === 0xf0)
-        return "audio/aac";
-    if (ascii(0, "FORM") && (ascii(8, "AIFF") || ascii(8, "AIFC")))
-        return "audio/aiff";
-    if (ascii(4, "ftyp")) {
-        if (ascii(8, "avif") || ascii(8, "avis"))
-            return "image/avif";
-        if (ascii(8, "heic") || ascii(8, "heix"))
-            return "image/heic";
-        if (ascii(8, "mif1") || ascii(8, "msf1"))
-            return "image/heif";
-        if (ascii(8, "M4A ") || ascii(8, "M4B "))
-            return "audio/mp4";
-        if (ascii(8, "qt  "))
-            return "video/quicktime";
-        return "video/mp4";
-    }
-    if (matches([0x1a, 0x45, 0xdf, 0xa3])) {
-        const mimeType = ebmlMimeType(bytes);
-        if (mimeType)
-            return mimeType;
-    }
-    if (ascii(0, "%PDF-"))
-        return "application/pdf";
-    if (matches([0x50, 0x4b, 3, 4]) || matches([0x50, 0x4b, 5, 6]))
-        return "application/zip";
-    if (matches([0x1f, 0x8b]))
-        return "application/gzip";
-    if (matches([0x49, 0x49, 42, 0]) || matches([0x4d, 0x4d, 0, 42]))
-        return "image/tiff";
-    if (ascii(0, "BM"))
-        return "image/bmp";
-    const prefix = bytes.subarray(0, 512);
-    const classified = classify(prefix, bytes.length <= prefix.length).mime;
-    if (!["application/octet-stream", "text/plain", "inode/x-empty"].includes(classified))
-        return classified;
-    const filename = path.slice(path.lastIndexOf("/") + 1);
-    const dot = filename.lastIndexOf(".");
-    const extension = dot < 0 ? "" : filename.slice(dot + 1).toLowerCase();
-    return Object.hasOwn(extensions, extension) ? extensions[extension] : classified === "inode/x-empty" ? "application/octet-stream" : classified;
-}
-export function acceptsMimeType(types, mimeType) {
-    if ([...mimeType].some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127))
-        return false;
-    const mime = mimeType.split(";", 1)[0].trim().toLowerCase();
-    const parts = mime.split("/");
-    if (parts.length !== 2 || parts.some(part => !part || [...part].some(character => !(character >= "a" && character <= "z" || character >= "0" && character <= "9" || "!#$%&'+-.^_`|~".includes(character)))))
-        return false;
-    return types.some(type => {
-        const accepted = type.toLowerCase();
-        return accepted === mime || accepted.endsWith("/*") && accepted.slice(0, -2) === parts[0];
-    });
-}
+export * from "../../../safe-bash-command-llm/mime.js";
 //# sourceMappingURL=mime.js.map

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

@@ -1,9 +1,2 @@
-import type { ByteSource } from "../../contracts/index.js";
-import type { HttpRequest, HttpResponse, HttpTransport } from "../network/types.js";
-export declare function openAiAbortable<Value>(pending: PromiseLike<Value>, signal: AbortSignal): Promise<Value>;
-export declare function openAiBytes(source: ByteSource, signal: AbortSignal, limit?: number): ByteSource;
-export declare function openAiJson(response: HttpResponse, signal: AbortSignal, maxBytes?: number): Promise<Record<string, unknown>>;
-export declare function openAiRecord(value: unknown): value is Record<string, unknown>;
-export declare function openAiError(value: unknown): string | undefined;
-export declare function openAiResponse(transport: HttpTransport, input: HttpRequest, maxResponseBytes: number): AsyncIterable<HttpResponse>;
+export * from "../../../safe-bash-command-llm/openai-http.js";
 //# sourceMappingURL=openai-http.d.ts.map

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

@@ -1,144 +1,2 @@
-export function openAiAbortable(pending, signal) {
-    return new Promise((resolve, reject) => {
-        const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason); };
-        signal.addEventListener("abort", abort, { once: true });
-        Promise.resolve(pending).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();
-    });
-}
-export async function* openAiBytes(source, signal, limit = Infinity) {
-    signal.throwIfAborted();
-    const iterator = source[Symbol.asyncIterator]();
-    let failed = false, finished = false;
-    let size = 0;
-    try {
-        while (true) {
-            signal.throwIfAborted();
-            const next = await openAiAbortable(iterator.next(), signal);
-            if (next.done) {
-                finished = true;
-                return;
-            }
-            if (!(next.value instanceof Uint8Array))
-                throw new Error("OpenAI returned a non-byte response chunk");
-            size += next.value.byteLength;
-            if (size > limit)
-                throw new RangeError("Provider response byte limit exceeded");
-            yield Uint8Array.from(next.value);
-        }
-    }
-    catch (error) {
-        failed = true;
-        throw signal.aborted ? signal.reason : error;
-    }
-    finally {
-        if (!finished) {
-            const returned = Promise.resolve().then(() => iterator.return?.());
-            if (signal.aborted)
-                void returned.catch(() => undefined);
-            else
-                await openAiAbortable(returned, signal).catch(error => { if (!failed)
-                    throw error; });
-        }
-    }
-}
-export async function openAiJson(response, signal, maxBytes = Infinity) {
-    const decoder = new TextDecoder("utf-8", { fatal: true });
-    let text = "", length = 0;
-    for await (const chunk of openAiBytes(response.body, signal, maxBytes)) {
-        length += chunk.byteLength;
-        if (length > maxBytes)
-            throw new Error("OpenAI JSON response exceeds buffer limit");
-        text += decoder.decode(chunk, { stream: true });
-    }
-    text += decoder.decode();
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        throw new Error("OpenAI returned malformed JSON");
-    }
-    if (!openAiRecord(value))
-        throw new Error("OpenAI returned a non-object JSON response");
-    return value;
-}
-export function openAiRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-export function openAiError(value) {
-    if (typeof value === "string" && value)
-        return value.slice(0, 1024);
-    if (openAiRecord(value) && typeof value.message === "string")
-        return value.message.slice(0, 1024);
-    return undefined;
-}
-export async function* openAiResponse(transport, input, maxResponseBytes) {
-    input.signal.throwIfAborted();
-    const cleanups = new Map();
-    let closed = false, failed = false;
-    const run = (cleanup) => {
-        cleanup.pending ??= Promise.resolve().then(cleanup.run);
-        return cleanup.pending;
-    };
-    const register = (cleanup, receiver) => {
-        if (cleanups.has(cleanup))
-            return;
-        const entry = { run: () => cleanup.call(receiver) };
-        cleanups.set(cleanup, entry);
-        if (closed)
-            void run(entry).catch(() => undefined);
-    };
-    const close = async () => {
-        closed = true;
-        const results = await Promise.allSettled([...cleanups.values()].map(run));
-        const rejected = results.find(result => result.status === "rejected");
-        if (rejected?.status === "rejected")
-            throw rejected.reason;
-    };
-    const abort = () => { void close().catch(() => undefined); };
-    input.signal.addEventListener("abort", abort, { once: true });
-    try {
-        const pending = Promise.resolve().then(() => {
-            input.signal.throwIfAborted();
-            return transport({ ...input, registerCleanup: register });
-        }).then(response => {
-            register(response.dispose, response);
-            return response;
-        });
-        const response = await openAiAbortable(pending, input.signal);
-        if (!Number.isInteger(response.status) || response.status < 200 || response.status >= 300) {
-            let detail;
-            try {
-                detail = openAiError((await openAiJson(response, input.signal, maxResponseBytes)).error);
-            }
-            catch {
-                input.signal.throwIfAborted();
-            }
-            throw new Error(`OpenAI HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
-        }
-        yield response;
-    }
-    catch (error) {
-        failed = true;
-        throw input.signal.aborted ? input.signal.reason : error;
-    }
-    finally {
-        input.signal.removeEventListener("abort", abort);
-        await close().catch(error => { if (!failed && !input.signal.aborted)
-            throw error; });
-        if (!failed)
-            input.signal.throwIfAborted();
-    }
-}
+export * from "../../../safe-bash-command-llm/openai-http.js";
 //# sourceMappingURL=openai-http.js.map

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

@@ -1,4 +1,2 @@
-import type { LlmResponseMetadata } from "./types.js";
-import type { ByteSource } from "../../contracts/index.js";
-export declare function openAiChat(source: ByteSource, signal: AbortSignal, limit?: number, responseLimit?: number): AsyncGenerator<string, LlmResponseMetadata>;
+export * from "../../../safe-bash-command-llm/openai-sse.js";
 //# sourceMappingURL=openai-sse.d.ts.map