@opencode/ai 2.0.14 → 2.0.15

package/dist/promise.d.ts

@@ -0,0 +1,554 @@
+import { Effect, Layer } from "effect";
+import { ImageModel, ImageRequest, type ImageRequestInput } from "./image.js";
+import { ImageClient } from "./image-client.js";
+import { LLMClient } from "./route/client.js";
+import { RequestExecutor } from "./route/executor.js";
+import { LanguageModel, LLMRequest } from "./schema/index.js";
+import type { RequestInput } from "./llm.js";
+/**
+ * Promise-first entrypoint for scripts and non-Effect callers. One `ManagedRuntime` hosts the LLM and image clients
+ * over a request executor; every method runs the corresponding Effect API and rethrows `AIError` unchanged.
+ */
+export interface Options {
+    /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or middleware here. */
+    readonly layer?: Layer.Layer<RequestExecutor.Service>;
+}
+export interface RunOptions {
+    readonly signal?: AbortSignal;
+}
+export type Services = Layer.Success<typeof LLMClient.layer> | Layer.Success<typeof ImageClient.layer> | RequestExecutor.Service;
+export declare const make: (options?: Options) => {
+    run: <A, E>(effect: Effect.Effect<A, E, Services>, options?: RunOptions) => Promise<A>;
+    llm: {
+        request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
+        generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => Promise<import("./index.js").LLMResponse>;
+        stream: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => AsyncIterable<({
+            readonly type: "compaction";
+            readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+            readonly id?: string | undefined;
+            readonly text?: string | null | undefined;
+            readonly encrypted?: string | undefined;
+        } & ({
+            readonly encrypted: string;
+            readonly text?: never;
+        } | {
+            readonly text: string | null;
+            readonly encrypted?: never;
+        })) | {
+            readonly type: "step-start";
+            readonly index: number;
+        } | {
+            readonly id: string;
+            readonly type: "text-start";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "text-delta";
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "text-end";
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-start";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-delta";
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-end";
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-start";
+            readonly name: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-delta";
+            readonly name: string;
+            readonly text: string;
+            readonly input?: unknown;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-end";
+            readonly name: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-error";
+            readonly name: string;
+            readonly raw: string;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-call";
+            readonly name: string;
+            readonly input: unknown;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-result";
+            readonly name: string;
+            readonly result: {
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            };
+            readonly output?: {
+                readonly structured: unknown;
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            } | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-error";
+            readonly name: string;
+            readonly message: string;
+            readonly error?: unknown;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly type: "media";
+            readonly media: import("./media.js").Asset;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "step-finish";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
+            readonly index: number;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: import("./index.js").Usage | undefined;
+        } | {
+            readonly type: "finish";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: import("./index.js").Usage | undefined;
+        } | {
+            readonly type: "provider-error";
+            readonly message: string;
+            readonly classification?: "context-overflow" | "payload-too-large" | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }>;
+    };
+    image: {
+        request: typeof import("./image.js").request;
+        generate: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<import("./image.js").ImageResponse>;
+        stream: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => AsyncIterable<{
+            readonly type: "image";
+            readonly index: number;
+            readonly image: import("./media.js").Asset;
+        } | {
+            readonly type: "finish";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "other" | "moderated" | "filtered";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+        }>;
+    };
+    dispose: () => Promise<void>;
+};
+export type Client = ReturnType<typeof make>;
+/** Default client over `RequestExecutor.fetchLayer` for scripts; the runtime builds its layer on first use. */
+export declare const ai: {
+    run: <A, E>(effect: Effect.Effect<A, E, Services>, options?: RunOptions) => Promise<A>;
+    llm: {
+        request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
+        generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => Promise<import("./index.js").LLMResponse>;
+        stream: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) => AsyncIterable<({
+            readonly type: "compaction";
+            readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+            readonly id?: string | undefined;
+            readonly text?: string | null | undefined;
+            readonly encrypted?: string | undefined;
+        } & ({
+            readonly encrypted: string;
+            readonly text?: never;
+        } | {
+            readonly text: string | null;
+            readonly encrypted?: never;
+        })) | {
+            readonly type: "step-start";
+            readonly index: number;
+        } | {
+            readonly id: string;
+            readonly type: "text-start";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "text-delta";
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "text-end";
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-start";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-delta";
+            readonly text: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "reasoning-end";
+            readonly text?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-start";
+            readonly name: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-delta";
+            readonly name: string;
+            readonly text: string;
+            readonly input?: unknown;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-end";
+            readonly name: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-input-error";
+            readonly name: string;
+            readonly raw: string;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-call";
+            readonly name: string;
+            readonly input: unknown;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-result";
+            readonly name: string;
+            readonly result: {
+                readonly type: "json";
+                readonly value: unknown;
+            } | {
+                readonly type: "text";
+                readonly value: unknown;
+            } | {
+                readonly type: "error";
+                readonly value: unknown;
+            } | {
+                readonly type: "content";
+                readonly value: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            };
+            readonly output?: {
+                readonly structured: unknown;
+                readonly content: readonly ({
+                    readonly type: "text";
+                    readonly text: string;
+                } | {
+                    readonly type: "file";
+                    readonly uri: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                })[];
+            } | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+            readonly providerExecuted?: boolean | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "tool-error";
+            readonly name: string;
+            readonly message: string;
+            readonly error?: unknown;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly namespace?: string | undefined;
+        } | {
+            readonly type: "media";
+            readonly media: import("./media.js").Asset;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        } | {
+            readonly type: "step-finish";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
+            readonly index: number;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: import("./index.js").Usage | undefined;
+        } | {
+            readonly type: "finish";
+            readonly reason: {
+                readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+                readonly raw?: string | undefined;
+            };
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: import("./index.js").Usage | undefined;
+        } | {
+            readonly type: "provider-error";
+            readonly message: string;
+            readonly classification?: "context-overflow" | "payload-too-large" | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }>;
+    };
+    image: {
+        request: typeof import("./image.js").request;
+        generate: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<import("./image.js").ImageResponse>;
+        stream: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => AsyncIterable<{
+            readonly type: "image";
+            readonly index: number;
+            readonly image: import("./media.js").Asset;
+        } | {
+            readonly type: "finish";
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly usage?: {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "other" | "moderated" | "filtered";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+        }>;
+    };
+    dispose: () => Promise<void>;
+};
+export * as AI from "./promise.js";

package/dist/promise.js

@@ -0,0 +1,44 @@
+import { Effect, Layer, ManagedRuntime, Stream } from "effect";
+import { Image, ImageModel, ImageRequest } from "./image.js";
+import { ImageClient } from "./image-client.js";
+import { LLM } from "./index.js";
+import { LLMClient } from "./route/client.js";
+import { RequestExecutor } from "./route/executor.js";
+import { LanguageModel, LLMRequest } from "./schema/index.js";
+const abortEffect = (signal) => signal === undefined
+    ? Effect.never
+    : Effect.callback((resume) => {
+        if (signal.aborted) {
+            resume(Effect.void);
+            return;
+        }
+        const onAbort = () => resume(Effect.void);
+        signal.addEventListener("abort", onAbort, { once: true });
+        return Effect.sync(() => signal.removeEventListener("abort", onAbort));
+    });
+export const make = (options = {}) => {
+    const runtime = ManagedRuntime.make(Layer.mergeAll(LLMClient.layer, ImageClient.layer).pipe(Layer.provideMerge(options.layer ?? RequestExecutor.fetchLayer)));
+    /** Run any package Effect (for example `asset.bytes()`) inside this runtime. */
+    const run = (effect, options) => runtime.runPromise(effect, { signal: 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))))));
+    // The typed `generate`/`stream` overloads take a concrete input or a request, not the union; normalize once here.
+    const llmRequest = (input) => (input instanceof LLMRequest ? input : LLM.request(input));
+    const imageRequest = (input) => input instanceof ImageRequest ? input : Image.request(input);
+    return {
+        run,
+        llm: {
+            request: LLM.request,
+            generate: (input, options) => run(LLM.generate(llmRequest(input)), options),
+            stream: (input, options) => iterate(LLM.stream(llmRequest(input)), options),
+        },
+        image: {
+            request: Image.request,
+            generate: (input, options) => run(Image.generate(imageRequest(input)), options),
+            stream: (input, options) => iterate(Image.stream(imageRequest(input)), options),
+        },
+        dispose: () => runtime.dispose(),
+    };
+};
+/** 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";

package/dist/protocols/anthropic-messages.js

@@ -537,7 +537,7 @@ const citationsFromMetadata = (metadata) => {
 };
 const isHttpUrl = (value) => /^https?:\/\//i.test(value.trim());
 const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, breakpoints) {
-    const mime = part.mediaType.toLowerCase();
+    const mime = part.media.mediaType.toLowerCase();
     const cacheControlValue = breakpoints ? cacheControl(breakpoints, part.cache) : undefined;
     const fileId = fileIdFromMetadata(part.metadata);
     // SDK file sources: FileImageSource:2350 / FileDocumentSource:2344 {type:"file", file_id}
@@ -564,9 +564,9 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, br
                 : { citations: citationsFromMetadata(part.metadata) }),
         };
     }
-    const rawString = typeof part.data === "string" ? part.data.trim() : undefined;
+    const rawString = ProviderShared.mediaUrl(part.media)?.trim();
     // SDK URL sources: URLImageSource:3817 / URLPDFSource:3823 {type:"url", url}
-    if (rawString && isHttpUrl(rawString) && !rawString.startsWith("data:")) {
+    if (rawString && isHttpUrl(rawString)) {
         if (mime.startsWith("image/"))
             return {
                 type: "image",
@@ -590,19 +590,10 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, br
                     : { citations: citationsFromMetadata(part.metadata) }),
             };
     }
+    const media = yield* ProviderShared.requireInlineMedia("Anthropic Messages", part.media);
     // SDK PlainTextSource:2716 {type:"text", media_type:"text/plain", data}
     if (mime === "text/plain") {
-        const textData = typeof part.data !== "string"
-            ? Buffer.from(part.data).toString("utf8")
-            : part.data.startsWith("data:")
-                ? (() => {
-                    const comma = part.data.indexOf(",");
-                    const payload = comma >= 0 ? part.data.slice(comma + 1) : part.data;
-                    return part.data.includes(";base64")
-                        ? Buffer.from(payload, "base64").toString("utf8")
-                        : decodeURIComponent(payload);
-                })()
-                : part.data;
+        const textData = Buffer.from(media.base64, "base64").toString("utf8");
         return {
             type: "document",
             source: { type: "text", media_type: "text/plain", data: textData },
@@ -616,7 +607,6 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, br
                 : { citations: citationsFromMetadata(part.metadata) }),
         };
     }
-    const media = ProviderShared.normalizeMedia(part);
     if (media.mime === "application/pdf")
         return {
             type: "document",
@@ -635,7 +625,7 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, br
                 : { citations: citationsFromMetadata(part.metadata) }),
         };
     if (!media.mime.startsWith("image/"))
-        return yield* invalid(`Anthropic Messages does not support media type ${part.mediaType}`);
+        return yield* invalid(`Anthropic Messages does not support media type ${part.media.mediaType}`);
     return {
         type: "image",
         source: {
@@ -654,7 +644,7 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, br
 const lowerToolResultContentItem = Effect.fnUntraced(function* (item) {
     if (item.type === "text")
         return { type: "text", text: item.text };
-    return yield* lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name });
+    return yield* lowerMedia(ProviderShared.toolFileMedia(item));
 });
 const lowerToolResultContent = Effect.fnUntraced(function* (part) {
     // Text / json / error results stay as a string for backward compatibility