@opencode-ai/ai 0.0.0-bootstrap.0 → 0.0.0-dev-17471

package/dist/image.js

@@ -0,0 +1,102 @@
+import { Effect, Schema } from "effect";
+import { HttpOptions, InvalidRequestReason, 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({
+            module: "Image",
+            method: "generate",
+            reason: new InvalidRequestReason({ message: error instanceof Error ? error.message : String(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";

package/dist/llm.d.ts

@@ -0,0 +1,230 @@
+import { Effect, JsonSchema, Schema } from "effect";
+import { Service } from "./route/client.js";
+import { GenerationOptions, HttpOptions, AIError, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, ToolDefinition, type ContentPart, type LanguageModelProviderOptions } from "./schema/index.js";
+import { type ToolSchema } from "./tool.js";
+/** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */
+export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<ConstructorParameters<typeof LLMRequest>[0], "model" | "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"> & {
+    readonly model: SelectedLanguageModel;
+    readonly system?: string | SystemPart | ReadonlyArray<SystemPart>;
+    readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>;
+    readonly messages?: ReadonlyArray<Message | Message.Input>;
+    readonly tools?: ReadonlyArray<ToolDefinition.Input>;
+    readonly toolChoice?: ToolChoice.Input;
+    readonly generation?: GenerationOptions.Input;
+    readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const generate: typeof import("./route/client.js").generate;
+export declare const stream: typeof import("./route/client.js").stream;
+export declare const request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest;
+type GenerateObjectBase<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<RequestInput<SelectedLanguageModel>, "tools" | "toolChoice">;
+export declare class GenerateObjectResponse<T> {
+    readonly object: T;
+    readonly response: LLMResponse;
+    constructor(object: T, response: LLMResponse);
+    get events(): readonly ({
+        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 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 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 providerExecuted?: boolean | undefined;
+    } | {
+        readonly type: "tool-input-delta";
+        readonly id: string;
+        readonly name: string;
+        readonly text: string;
+    } | {
+        readonly id: string;
+        readonly type: "tool-input-end";
+        readonly name: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly type: "tool-input-error";
+        readonly id: string;
+        readonly name: string;
+        readonly raw: string;
+    } | {
+        readonly id: string;
+        readonly type: "tool-call";
+        readonly name: string;
+        readonly input: unknown;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | 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 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 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("./schema/events.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("./schema/events.js").Usage | undefined;
+    } | {
+        readonly type: "provider-error";
+        readonly message: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly classification?: "context-overflow" | "payload-too-large" | undefined;
+    })[];
+    get usage(): import("./schema/events.js").Usage | undefined;
+}
+export interface GenerateObjectOptions<S extends ToolSchema<any>, SelectedLanguageModel extends LanguageModel = LanguageModel> extends GenerateObjectBase<SelectedLanguageModel> {
+    readonly schema: S;
+}
+export interface GenerateObjectDynamicOptions<SelectedLanguageModel extends LanguageModel = LanguageModel> extends GenerateObjectBase<SelectedLanguageModel> {
+    /** Raw JSON Schema object describing the expected output shape. */
+    readonly jsonSchema: JsonSchema.JsonSchema;
+}
+/**
+ * Run a model and decode its output against `schema`. Works on every protocol
+ * because it forces a synthetic tool call internally — provider-native JSON
+ * modes are intentionally avoided so behaviour is uniform.
+ *
+ * Two input modes:
+ *
+ * 1. `schema: EffectSchema<T>` — `.object` is decoded and typed as `T`.
+ *    Decode failures surface as `AIError`.
+ * 2. `jsonSchema: JsonSchema.JsonSchema` — `.object` is `unknown`. Use when
+ *    the schema is only available at runtime (MCP, plugin manifests). Caller validates.
+ */
+export declare function generateObject<const SelectedLanguageModel extends LanguageModel, S extends ToolSchema<any>>(options: GenerateObjectOptions<S, SelectedLanguageModel>): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, AIError, Service>;
+export declare function generateObject<const SelectedLanguageModel extends LanguageModel>(options: GenerateObjectDynamicOptions<SelectedLanguageModel>): Effect.Effect<GenerateObjectResponse<unknown>, AIError, Service>;
+export {};

package/dist/llm.js

@@ -0,0 +1,77 @@
+import { Effect, JsonSchema, Schema } from "effect";
+import { LLMClient, Service } from "./route/client.js";
+import { GenerationOptions, HttpOptions, InvalidProviderOutputReason, AIError, LLMEvent, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, ToolDefinition, } from "./schema/index.js";
+import { make as makeTool, toDefinitions } from "./tool.js";
+export const generate = LLMClient.generate;
+export const stream = LLMClient.stream;
+export const request = (input) => {
+    const { system: requestSystem, prompt, messages, tools, toolChoice: requestToolChoice, generation: requestGeneration, providerOptions: requestProviderOptions, http: requestHttp, ...rest } = input;
+    return new LLMRequest({
+        ...rest,
+        system: SystemPart.content(requestSystem),
+        messages: [...(messages?.map(Message.make) ?? []), ...(prompt === undefined ? [] : [Message.user(prompt)])],
+        tools: tools?.map(ToolDefinition.make) ?? [],
+        toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined,
+        generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration),
+        providerOptions: requestProviderOptions,
+        http: requestHttp === undefined ? undefined : HttpOptions.make(requestHttp),
+    });
+};
+const GENERATE_OBJECT_TOOL_NAME = "generate_object";
+const GENERATE_OBJECT_TOOL_DESCRIPTION = "Return the structured result by calling this tool.";
+export class GenerateObjectResponse {
+    object;
+    response;
+    constructor(object, response) {
+        this.object = object;
+        this.response = response;
+    }
+    get events() {
+        return this.response.events;
+    }
+    get usage() {
+        return this.response.usage;
+    }
+}
+const runGenerateObject = Effect.fn("LLM.generateObject")(function* (options, tool) {
+    const baseRequest = request(options);
+    const generateRequest = LLMRequest.update(baseRequest, {
+        tools: toDefinitions({ [GENERATE_OBJECT_TOOL_NAME]: tool }),
+        toolChoice: ToolChoice.named(GENERATE_OBJECT_TOOL_NAME),
+    });
+    const response = yield* LLMClient.generate(generateRequest);
+    const call = response.toolCalls.find((event) => LLMEvent.is.toolCall(event) && event.name === GENERATE_OBJECT_TOOL_NAME);
+    if (!call || !LLMEvent.is.toolCall(call))
+        return yield* new AIError({
+            module: "LLM",
+            method: "generateObject",
+            reason: new InvalidProviderOutputReason({
+                message: `generateObject: model did not call the forced \`${GENERATE_OBJECT_TOOL_NAME}\` tool`,
+            }),
+        });
+    const object = yield* tool._decode(call.input).pipe(Effect.mapError((error) => new AIError({
+        module: "LLM",
+        method: "generateObject",
+        reason: new InvalidProviderOutputReason({
+            message: `generateObject: tool input failed schema decode: ${error.message}`,
+        }),
+    })));
+    return new GenerateObjectResponse(object, response);
+});
+export function generateObject(options) {
+    if ("schema" in options) {
+        const { schema, ...rest } = options;
+        return runGenerateObject(rest, makeTool({
+            description: GENERATE_OBJECT_TOOL_DESCRIPTION,
+            parameters: schema,
+            success: Schema.Unknown,
+            execute: () => Effect.void,
+        }));
+    }
+    const { jsonSchema, ...rest } = options;
+    return runGenerateObject(rest, makeTool({
+        description: GENERATE_OBJECT_TOOL_DESCRIPTION,
+        jsonSchema,
+        execute: () => Effect.void,
+    }));
+}