@opencode/ai 0.0.0-beta-19275

package/dist/llm.d.ts

@@ -0,0 +1,252 @@
+import { Effect, JsonSchema, Schema } from "effect";
+import { Service } from "./route/client.js";
+import { GenerationOptions, HttpOptions, AIError, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, type ContentPart, type LanguageModelProviderOptions, type ToolEntryInput } 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<ToolEntryInput>;
+    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<SelectedLanguageModel>;
+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: "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: "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,74 @@
+import { Effect, JsonSchema, Schema } from "effect";
+import { LLMClient, Service } from "./route/client.js";
+import { GenerationOptions, HttpOptions, InvalidProviderOutputError, AIError, LLMEvent, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, ToolEntry, } 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(ToolEntry.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({
+            reason: new InvalidProviderOutputError({
+                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({
+        reason: new InvalidProviderOutputError({
+            message: `generateObject: tool input failed schema decode: ${error.message}`,
+            cause: error,
+        }),
+    })));
+    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,
+    }));
+}