@opencode/ai 0.0.0-reserved → 2.0.1

package/dist/cache-policy.d.ts

@@ -0,0 +1,2 @@
+import { LLMRequest } from "./schema/messages.js";
+export declare const applyCachePolicy: (request: LLMRequest) => LLMRequest;

package/dist/cache-policy.js

@@ -0,0 +1,129 @@
+// Apply an `LLMRequest.cache` policy by injecting `CacheHint`s onto the parts
+// the policy designates. Runs once at compile time, before the per-protocol
+// body builder, so the existing inline-hint lowering path handles the rest.
+//
+// The default `"auto"` shape places breakpoints at the last tool definition,
+// the first and last distinct system parts, and the conversation tail. This
+// exposes reusable tool, base-agent, project, and session prefixes while
+// advancing the tail after each tool result keeps recent conversation prefixes
+// reusable during long agent runs.
+//
+// Manual `cache: CacheHint` placements on individual parts are preserved and
+// count against the four-breakpoint budget; auto only fills remaining slots.
+import { CacheHint } from "./schema/options.js";
+import { LLMRequest, Message, ToolDefinition } from "./schema/messages.js";
+const AUTO = {
+    tools: true,
+    system: true,
+    messages: { tail: 1 },
+};
+const NONE = {};
+const BREAKPOINT_CAP = 4;
+// Resolution rules:
+//   - undefined   → "auto" — caching is on by default.
+//   - "auto"      → tools + first/last system + final message boundary.
+//   - "none"      → no auto placement; manual `CacheHint`s still flow.
+//   - object form → exactly what the caller asked for.
+const resolve = (policy) => {
+    if (policy === undefined || policy === "auto")
+        return AUTO;
+    if (policy === "none")
+        return NONE;
+    return policy;
+};
+// Protocols whose wire format ignores inline cache markers (OpenAI's implicit
+// prefix caching, Gemini's implicit + out-of-band CachedContent). Skip the
+// whole policy pass for these — emitting hints would be harmless but pointless.
+const RESPECTS_INLINE_HINTS = new Set([
+    "anthropic-messages",
+    "google-vertex-messages",
+    "bedrock-converse",
+    "openrouter",
+]);
+const makeHint = (ttlSeconds) => ttlSeconds !== undefined ? new CacheHint({ type: "ephemeral", ttlSeconds }) : new CacheHint({ type: "ephemeral" });
+const markLastTool = (tools, hint, budget) => {
+    const target = tools.at(-1);
+    if (target === undefined)
+        return tools;
+    if (target.type === "namespace") {
+        const nested = markLastTool(target.tools, hint, budget);
+        return nested === target.tools ? tools : [...tools.slice(0, -1), { ...target, tools: nested }];
+    }
+    if (target.cache || budget.remaining === 0)
+        return tools;
+    budget.remaining -= 1;
+    return [...tools.slice(0, -1), new ToolDefinition({ ...target, cache: hint })];
+};
+const countToolHints = (tools) => tools.reduce((count, tool) => count + (tool.type === "tool" ? (tool.cache === undefined ? 0 : 1) : countToolHints(tool.tools)), 0);
+const markSystemBoundaries = (system, hint, budget) => {
+    if (system.length === 0)
+        return system;
+    let changed = false;
+    const next = system.map((part, index) => {
+        if ((index !== 0 && index !== system.length - 1) || part.cache || budget.remaining === 0)
+            return part;
+        budget.remaining -= 1;
+        changed = true;
+        return { ...part, cache: hint };
+    });
+    return changed ? next : system;
+};
+const lastIndexOfRole = (messages, role) => messages.findLastIndex((m) => m.role === role);
+// Mark the last text part of `messages[index]`. If no text part exists, mark
+// the last content part regardless of type — that's the breakpoint position
+// in tool-result-only messages too.
+const markMessageAt = (messages, index, hint, budget) => {
+    if (index < 0 || index >= messages.length)
+        return messages;
+    const target = messages[index];
+    if (target.content.length === 0)
+        return messages;
+    const lastTextIndex = target.content.findLastIndex((part) => part.type === "text");
+    const markAt = lastTextIndex >= 0 ? lastTextIndex : target.content.length - 1;
+    const existing = target.content[markAt];
+    if (("cache" in existing && existing.cache) || budget.remaining === 0)
+        return messages;
+    budget.remaining -= 1;
+    const nextContent = target.content.map((part, i) => (i === markAt ? { ...part, cache: hint } : part));
+    const next = new Message({ ...target, content: nextContent });
+    // Single pass over `messages`, substituting the one updated entry. Long
+    // conversations call this on every request, so avoid `.map()` here — its
+    // closure dispatch and identity copies show up in profiling.
+    const result = messages.slice();
+    result[index] = next;
+    return result;
+};
+const markMessages = (messages, strategy, hint, budget) => {
+    if (messages.length === 0)
+        return messages;
+    if (strategy === "latest-user-message")
+        return markMessageAt(messages, lastIndexOfRole(messages, "user"), hint, budget);
+    if (strategy === "latest-assistant")
+        return markMessageAt(messages, lastIndexOfRole(messages, "assistant"), hint, budget);
+    const start = Math.max(0, messages.length - strategy.tail);
+    let next = messages;
+    for (let i = start; i < messages.length; i++)
+        next = markMessageAt(next, i, hint, budget);
+    return next;
+};
+const countHints = (request) => countToolHints(request.tools) +
+    request.system.reduce((count, part) => count + (part.cache === undefined ? 0 : 1), 0) +
+    request.messages.reduce((count, message) => count +
+        message.content.reduce((contentCount, part) => contentCount + ("cache" in part && part.cache !== undefined ? 1 : 0), 0), 0);
+export const applyCachePolicy = (request) => {
+    if (!RESPECTS_INLINE_HINTS.has(request.model.route.id))
+        return request;
+    if (request.model.route.id === "openrouter" && (request.cache === undefined || request.cache === "auto"))
+        return request;
+    const policy = resolve(request.cache);
+    if (!policy.tools && !policy.system && !policy.messages)
+        return request;
+    const hint = makeHint(policy.ttlSeconds);
+    const budget = { remaining: Math.max(0, BREAKPOINT_CAP - countHints(request)) };
+    const tools = policy.tools ? markLastTool(request.tools, hint, budget) : request.tools;
+    const system = policy.system ? markSystemBoundaries(request.system, hint, budget) : request.system;
+    const messages = policy.messages ? markMessages(request.messages, policy.messages, hint, budget) : request.messages;
+    if (tools === request.tools && system === request.system && messages === request.messages)
+        return request;
+    return LLMRequest.update(request, { tools, system, messages });
+};

package/dist/image-client.d.ts

@@ -0,0 +1,19 @@
+import { Context, Effect, Layer } from "effect";
+import { RequestExecutor } from "./route/executor.js";
+import { type AIError } from "./schema/index.js";
+import type { ImageOptions, ImageRequestFor, ImageResponse } from "./image.js";
+export type Execute = RequestExecutor.Interface["execute"];
+export interface Interface {
+    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, AIError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/ImageClient", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, AIError, Service>;
+export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+export declare const ImageClient: {
+    readonly Service: typeof Service;
+    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, AIError, Service>;
+};
+export {};

package/dist/image-client.js

@@ -0,0 +1,28 @@
+import { Context, Effect, Layer } from "effect";
+import { RequestExecutor } from "./route/executor.js";
+import { mergeHttpOptions } from "./schema/index.js";
+import { sanitizeSurrogates } from "./utils/sanitize.js";
+export class Service extends Context.Service()("@opencode/ImageClient") {
+}
+export const generate = (request) => Effect.gen(function* () {
+    const client = yield* Service;
+    return yield* client.generate(request);
+});
+export const layer = Layer.effect(Service, Effect.gen(function* () {
+    const executor = yield* RequestExecutor.Service;
+    return Service.of({
+        generate: (request) => request.model.route.generate({
+            ...sanitizeSurrogates({
+                ...request,
+                model: undefined,
+                http: mergeHttpOptions(request.model.http, request.http),
+            }),
+            model: request.model,
+        }, executor.execute),
+    });
+}));
+export const ImageClient = {
+    Service,
+    layer,
+    generate,
+};

package/dist/image.d.ts

@@ -0,0 +1,110 @@
+import { Effect, Schema } from "effect";
+import { HttpOptions, AIError, ModelID, ProviderID, Usage } from "./schema/index.js";
+import { Service, type Execute as ImageExecute } from "./image-client.js";
+export interface ImageRoute<Options extends ImageOptions = ImageOptions> {
+    readonly id: string;
+    readonly generate: (request: ImageRequestFor<Options>, execute: ImageExecute) => Effect.Effect<ImageResponse, AIError>;
+}
+export type ImageOptions = Record<string, unknown>;
+export declare class ImageModel<Options extends ImageOptions = ImageOptions> {
+    protected readonly _Options: (options: Options) => Options;
+    readonly id: ModelID;
+    readonly provider: ProviderID;
+    readonly route: ImageRoute<Options>;
+    readonly http?: HttpOptions;
+    constructor(input: ImageModel.Input<Options>);
+    static make<Options extends ImageOptions = ImageOptions>(input: ImageModel.MakeInput<Options>): ImageModel<Options>;
+}
+export declare namespace ImageModel {
+    interface Input<Options extends ImageOptions = ImageOptions> {
+        readonly id: ModelID;
+        readonly provider: ProviderID;
+        readonly route: ImageRoute<Options>;
+        readonly http?: HttpOptions;
+    }
+    interface MakeInput<Options extends ImageOptions = ImageOptions> extends Omit<Input<Options>, "id" | "provider"> {
+        readonly id: string | ModelID;
+        readonly provider: string | ProviderID;
+    }
+}
+export declare const ImageModelSchema: Schema.declare<ImageModel<ImageOptions>, ImageModel<ImageOptions>>;
+export declare const ImageInputSchema: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"bytes">;
+    readonly data: Schema.Uint8Array;
+    readonly mediaType: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"url">;
+    readonly url: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"file-id">;
+    readonly id: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"file-uri">;
+    readonly uri: Schema.String;
+    readonly mediaType: Schema.String;
+}>]>;
+export type ImageInput = Schema.Schema.Type<typeof ImageInputSchema>;
+export declare const ImageInput: {
+    readonly bytes: (data: Uint8Array, mediaType: string) => ImageInput;
+    readonly url: (url: string) => ImageInput;
+    readonly file: (id: string) => ImageInput;
+    readonly fileUri: (uri: string, mediaType: string) => ImageInput;
+};
+declare const ImageRequest_base: Schema.Class<ImageRequest, Schema.Struct<{
+    readonly model: Schema.declare<ImageModel<ImageOptions>, ImageModel<ImageOptions>>;
+    readonly prompt: Schema.String;
+    readonly images: Schema.optional<Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"bytes">;
+        readonly data: Schema.Uint8Array;
+        readonly mediaType: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"url">;
+        readonly url: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"file-id">;
+        readonly id: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"file-uri">;
+        readonly uri: Schema.String;
+        readonly mediaType: Schema.String;
+    }>]>>>;
+    readonly options: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly http: Schema.optional<typeof HttpOptions>;
+}>, {}>;
+export declare class ImageRequest extends ImageRequest_base {
+    protected readonly _ImageRequest: void;
+}
+export type ImageRequestFor<Options extends ImageOptions = ImageOptions> = Omit<ImageRequest, "model" | "options"> & {
+    readonly model: ImageModel<Options>;
+    readonly options?: Options;
+};
+export type ImageModelOptions<Model> = Model extends ImageModel<infer Options> ? Options : never;
+export type ImageRequestInput<Model extends object = ImageModel> = Omit<ConstructorParameters<typeof ImageRequest>[0], "model" | "options" | "http"> & {
+    readonly model: Model;
+    readonly options?: NoInfer<ImageModelOptions<Model>>;
+    readonly http?: HttpOptions.Input;
+} & (Model extends ImageModel<ImageModelOptions<Model>> ? unknown : never);
+declare const GeneratedImage_base: Schema.Class<GeneratedImage, Schema.Struct<{
+    readonly mediaType: Schema.String;
+    readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array]>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>, {}>;
+export declare class GeneratedImage extends GeneratedImage_base {
+}
+declare const ImageResponse_base: Schema.Class<ImageResponse, Schema.Struct<{
+    readonly images: Schema.$Array<typeof GeneratedImage>;
+    readonly usage: Schema.optional<typeof Usage>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>, {}>;
+export declare class ImageResponse extends ImageResponse_base {
+    get image(): GeneratedImage;
+}
+export declare function request<const Model extends object>(input: ImageRequestInput<Model>): ImageRequestFor<ImageModelOptions<Model>>;
+export declare function request(input: ImageRequest): ImageRequest;
+export declare function generate<const Model extends object>(input: ImageRequestInput<Model>): Effect.Effect<ImageResponse, AIError, Service>;
+export declare function generate(input: ImageRequest): Effect.Effect<ImageResponse, AIError, Service>;
+export declare const Image: {
+    readonly request: typeof request;
+    readonly generate: typeof generate;
+};
+export {};

package/dist/image.js

@@ -0,0 +1,103 @@
+import { Effect, Schema } from "effect";
+import { HttpOptions, InvalidRequestError, AIError, ModelID, ProviderID, ProviderMetadata, Usage, } from "./schema/index.js";
+import { ImageClient, Service } from "./image-client.js";
+export class ImageModel {
+    id;
+    provider;
+    route;
+    http;
+    constructor(input) {
+        this.id = input.id;
+        this.provider = input.provider;
+        this.route = input.route;
+        this.http = input.http;
+    }
+    static make(input) {
+        return new ImageModel({
+            id: ModelID.make(input.id),
+            provider: ProviderID.make(input.provider),
+            route: input.route,
+            http: input.http,
+        });
+    }
+}
+export const ImageModelSchema = Schema.declare((value) => value instanceof ImageModel, {
+    expected: "Image.Model",
+});
+const ImageBytesInput = Schema.Struct({
+    type: Schema.Literal("bytes"),
+    data: Schema.Uint8Array,
+    mediaType: Schema.String,
+});
+const ImageUrlInput = Schema.Struct({
+    type: Schema.Literal("url"),
+    url: Schema.String,
+});
+const ImageFileIDInput = Schema.Struct({
+    type: Schema.Literal("file-id"),
+    id: Schema.String,
+});
+const ImageFileURIInput = Schema.Struct({
+    type: Schema.Literal("file-uri"),
+    uri: Schema.String,
+    mediaType: Schema.String,
+});
+export const ImageInputSchema = Schema.Union([
+    ImageBytesInput,
+    ImageUrlInput,
+    ImageFileIDInput,
+    ImageFileURIInput,
+]).pipe(Schema.toTaggedUnion("type"));
+export const ImageInput = {
+    bytes: (data, mediaType) => ({ type: "bytes", data, mediaType }),
+    url: (url) => ({ type: "url", url }),
+    file: (id) => ({ type: "file-id", id }),
+    fileUri: (uri, mediaType) => ({ type: "file-uri", uri, mediaType }),
+};
+export class ImageRequest extends Schema.Class("Image.Request")({
+    model: ImageModelSchema,
+    prompt: Schema.String,
+    images: Schema.optional(Schema.Array(ImageInputSchema)),
+    options: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    http: Schema.optional(HttpOptions),
+}) {
+}
+export class GeneratedImage extends Schema.Class("Image.Generated")({
+    mediaType: Schema.String,
+    data: Schema.Union([Schema.String, Schema.Uint8Array]),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}) {
+}
+export class ImageResponse extends Schema.Class("Image.Response")({
+    images: Schema.Array(GeneratedImage),
+    usage: Schema.optional(Usage),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}) {
+    get image() {
+        return this.images[0];
+    }
+}
+export function request(input) {
+    if (input instanceof ImageRequest)
+        return input;
+    return new ImageRequest({
+        ...input,
+        model: input.model,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+}
+export function generate(input) {
+    return Effect.try({
+        try: () => (input instanceof ImageRequest ? input : request(input)),
+        catch: (error) => new AIError({
+            reason: new InvalidRequestError({
+                message: error instanceof Error ? error.message : String(error),
+                cause: error,
+            }),
+        }),
+    }).pipe(Effect.flatMap((request) => ImageClient.generate(request)));
+}
+export const Image = {
+    request,
+    generate,
+};

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { LLMClient } from "./route/client.js";
+export { ImageClient } from "./image-client.js";
+export { Auth } from "./route/auth.js";
+export { Provider } from "./provider.js";
+export { ProviderPackage } from "./provider-package.js";
+export { isContextOverflow, isContextOverflowFailure } from "./provider-error.js";
+export type { RouteLanguageModelInput, RouteRoutedLanguageModelInput, Interface as LLMClientShape, Service as LLMClientService, } from "./route/client.js";
+export * from "./schema/index.js";
+export { GeneratedImage, ImageInput, ImageInputSchema, ImageModel, ImageRequest, ImageResponse } from "./image.js";
+export type { ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute } from "./image.js";
+export { Image } from "./image.js";
+export { Tool, ToolFailure, toDefinitions } from "./tool.js";
+export { ToolRuntime } from "./tool-runtime.js";
+export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime.js";
+export type { AnyExecutableTool, AnyTool, ExecutableTool, ExecutableTools, Definition as ToolShape, ToolExecute, ToolExecuteContext, ToolModelOutputInput, Tools, ToolSchema, ToolToModelOutput, } from "./tool.js";
+export * as LLM from "./llm.js";
+export type { Definition as ProviderDefinition, LanguageModelFactory as ProviderLanguageModelFactory, LanguageModelOptions as ProviderLanguageModelOptions, } from "./provider.js";
+export type { Definition as ProviderPackageDefinition, Settings as ProviderPackageSettings, } from "./provider-package.js";

package/dist/index.js

@@ -0,0 +1,12 @@
+export { LLMClient } from "./route/client.js";
+export { ImageClient } from "./image-client.js";
+export { Auth } from "./route/auth.js";
+export { Provider } from "./provider.js";
+export { ProviderPackage } from "./provider-package.js";
+export { isContextOverflow, isContextOverflowFailure } from "./provider-error.js";
+export * from "./schema/index.js";
+export { GeneratedImage, ImageInput, ImageInputSchema, ImageModel, ImageRequest, ImageResponse } from "./image.js";
+export { Image } from "./image.js";
+export { Tool, ToolFailure, toDefinitions } from "./tool.js";
+export { ToolRuntime } from "./tool-runtime.js";
+export * as LLM from "./llm.js";