@opencode/ai 0.0.0-dev-21801 → 0.0.0-dev-21803

package/dist/promise.js

@@ -1,106 +0,0 @@
-import { Effect, Layer, ManagedRuntime, Stream } from "effect";
-import { AIClient } from "./ai-client.js";
-import { Decision } from "./decision.js";
-import { Image } from "./image.js";
-import { LLM } from "./index.js";
-import { Media } from "./media.js";
-import { RequestExecutor } from "./route/executor.js";
-import { AIError, InvalidRequestError, LanguageModel } from "./schema/index.js";
-import { Speech } from "./speech.js";
-import { Transcription, } from "./transcription.js";
-import { fileMediaType } from "./utils/media-type.js";
-import { Video } from "./video.js";
-// Fails with `signal.reason` so aborted calls reject and aborted streams throw like `fetch`: an `AbortError` by default.
-const abortEffect = (signal) => signal === undefined
-    ? Effect.never
-    : Effect.callback((resume) => {
-        if (signal.aborted) {
-            resume(Effect.fail(signal.reason));
-            return;
-        }
-        const onAbort = () => resume(Effect.fail(signal.reason));
-        signal.addEventListener("abort", onAbort, { once: true });
-        return Effect.sync(() => signal.removeEventListener("abort", onAbort));
-    });
-export const make = (options = {}) => {
-    const runtime = ManagedRuntime.make(AIClient.layerWith(options.layer ?? RequestExecutor.fetchLayer));
-    /** Run any package Effect (for example `LLMClient.compact(...)`) inside this runtime. */
-    const run = (effect, options) => runtime.runPromise(Effect.raceFirst(effect, abortEffect(options?.signal)));
-    const iterate = (stream, options) => Stream.toAsyncIterable(Stream.unwrap(runtime.contextEffect.pipe(Effect.map((context) => stream.pipe(Stream.interruptWhen(abortEffect(options?.signal)), Stream.provideContext(context))))));
-    const handle = (generation) => ({
-        ...generation.snapshot,
-        token: generation.token,
-        await: (options) => run(generation.await({ poll: options?.poll }), options),
-        events: (options) => iterate(generation.events({ poll: options?.poll }), options),
-        result: (options) => run(generation.result(), options),
-        refresh: (options) => run(generation.refresh(), options).then(handle),
-        cancel: (options) => run(generation.cancel(), options),
-    });
-    return {
-        run,
-        /** Decoded asset bytes, downloading `url` sources through the executor. */
-        bytes: (asset, options) => run(asset.bytes(), options),
-        base64: (asset, options) => run(asset.base64(), options),
-        /** Pull a `url` asset into owned bytes before the provider URL expires. */
-        materialize: (asset, options) => run(asset.materialize(), options),
-        /** Read a file into an asset like `Media.file`: sniffed media type, then the extension's. */
-        file: async (path, options) => {
-            const { readFile } = await import("node:fs/promises");
-            return run(Effect.tryPromise({
-                try: (signal) => readFile(path, { signal }),
-                catch: (cause) => fileError(`Failed to read media file ${path}`, cause),
-            }).pipe(Effect.map((buffer) => {
-                const data = new Uint8Array(buffer);
-                return Media.bytes(data, fileMediaType(data, path), options);
-            })), options);
-        },
-        /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
-        write: async (asset, path, options) => {
-            const { writeFile } = await import("node:fs/promises");
-            return run(asset.bytes().pipe(Effect.flatMap((data) => Effect.tryPromise({
-                try: (signal) => writeFile(path, data, { signal }),
-                catch: (cause) => fileError(`Failed to write media file ${path}`, cause),
-            }))), options);
-        },
-        llm: {
-            request: LLM.request,
-            generate: (input, options) => run(LLM.generate(input), options),
-            stream: (input, options) => iterate(LLM.stream(input), options),
-        },
-        image: {
-            request: Image.request,
-            generate: (input, options) => run(Image.generate(input, { poll: options?.poll }), options),
-            stream: (input, options) => iterate(Image.stream(input, { poll: options?.poll }), options),
-            start: (input, options) => run(Image.start(input), options).then(handle),
-            resume: (model, token, options) => run(Image.resume(model, token), options).then(handle),
-        },
-        video: {
-            request: Video.request,
-            start: (input, options) => run(Video.start(input), options).then(handle),
-            generate: (input, options) => run(Video.generate(input, { poll: options?.poll }), options),
-            resume: (model, token, options) => run(Video.resume(model, token), options).then(handle),
-            stream: (input, options) => iterate(Video.stream(input, { poll: options?.poll }), options),
-        },
-        speech: {
-            request: Speech.request,
-            generate: (input, options) => run(Speech.generate(input), options),
-            stream: (input, options) => iterate(Speech.stream(input), options),
-        },
-        transcription: {
-            request: Transcription.request,
-            generate: (input, options) => run(Transcription.generate(input, { poll: options?.poll }), options),
-            stream: (input, options) => iterate(Transcription.stream(input, { poll: options?.poll }), options),
-            start: (input, options) => run(Transcription.start(input), options).then(handle),
-            resume: (model, token, options) => run(Transcription.resume(model, token), options).then(handle),
-        },
-        decision: {
-            request: Decision.request,
-            generate: (input, options) => run(Decision.generate(input), options),
-        },
-        dispose: () => runtime.dispose(),
-    };
-};
-const fileError = (message, cause) => new AIError({ reason: new InvalidRequestError({ message, cause }) });
-/** Default client over `RequestExecutor.fetchLayer` for scripts; the runtime builds its layer on first use. */
-export const ai = make();
-export * as AI from "./promise.js";