@opencode/ai 0.0.0-dev-20136 → 0.0.0-dev-20138

package/README.md

@@ -9,15 +9,13 @@ import { OpenAI } from "@opencode/ai/providers"
 
 const openai = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY })
 
-const request = LLM.request({
-  model: openai.responses("gpt-4o-mini"), // `.chat(...)` selects the Chat Completions API instead
-  system: "You are concise.",
-  prompt: "Say hello in one short sentence.",
-  generation: { maxTokens: 40 },
-})
-
 const program = Effect.gen(function* () {
-  const response = yield* LLM.generate(request)
+  const response = yield* LLM.generate({
+    model: openai.responses("gpt-4o-mini"), // `.chat(...)` selects the Chat Completions API instead
+    system: "You are concise.",
+    prompt: "Say hello in one short sentence.",
+    generation: { maxTokens: 40 },
+  })
   console.log(response.text)
 })
 
@@ -25,7 +23,8 @@ const program = Effect.gen(function* () {
 await Effect.runPromise(program.pipe(Effect.provide(AIClient.layer)))
 ```
 
-Run `LLM.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses,
+Run `LLM.stream(...)` instead of `generate` when you want incremental `LLMEvent`s. Both accept input or a prebuilt
+`LLM.request(...)`. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses,
 Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
 
 The same configured facade names image, video, speech, and transcription models. `Image.generate` resolves the
@@ -72,11 +71,11 @@ helpers; `ai.file` and `ai.write` load `node:fs/promises` on first use, so no Ef
 import { AI } from "@opencode/ai/promise"
 
 const ai = AI.make()
-const request = ai.llm.request({ model: openai.responses("gpt-4o-mini"), prompt: "Say hello." })
-const text = await ai.llm.generate(request)
+const input = { model: openai.responses("gpt-4o-mini"), prompt: "Say hello." }
+const text = await ai.llm.generate(input)
 const generated = await ai.image.generate({ model: openai.image("gpt-image-2"), prompt: "A lighthouse" })
 await ai.write(generated.image, "./lighthouse.png") // also ai.file(path), ai.bytes(asset), ai.base64(asset), ai.materialize(asset)
-for await (const event of ai.llm.stream(request)) {
+for await (const event of ai.llm.stream(ai.llm.request(input))) {
   // LLMEvent
 }
 await ai.dispose()
@@ -937,7 +936,7 @@ const transcript = await generation.await({ poll: { interval: 3_000 } })
 ## Public API
 
 - **`LLM.request({...})`** — build a provider-neutral `LLMRequest`. Accepts ergonomic inputs (`system: string`, `prompt: string`) that normalize into the canonical Schema classes.
-- **`LLM.generate` / `LLM.stream`** — re-exported from `LLMClient` for one-import use.
+- **`LLM.generate` / `LLM.stream`** — run direct input or an `LLMRequest` through `LLMClient` for one-import use.
 - **`Message.user(...)` / `Message.assistant(...)` / `Message.tool(...)`** — message constructors from the canonical schema model.
 - **`LanguageModel.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model.
 - **`LLMEvent.is.*`** — typed guards (`is.textDelta`, `is.toolCall`, `is.finish`, …) for filtering streams.

package/dist/llm.d.ts

@@ -1,6 +1,6 @@
-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 { Effect, JsonSchema, Schema, Stream } from "effect";
+import { Service, type StreamOptions } from "./route/client.js";
+import { GenerationOptions, HttpOptions, AIError, LLMEvent, 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"> & {
@@ -14,9 +14,10 @@ export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageM
     readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>;
     readonly http?: HttpOptions.Input;
 };
-/** Run an `LLMRequest` built with `LLM.request(...)`. */
-export declare const generate: typeof import("./route/client.js").generate;
-export declare const stream: typeof import("./route/client.js").stream;
+export declare function generate<const Model extends LanguageModel>(input: RequestInput<Model>, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service>;
+export declare function generate(input: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service>;
+export declare function stream<const Model extends LanguageModel>(input: RequestInput<Model>, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service>;
+export declare function stream(input: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service>;
 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> {

package/dist/llm.js

@@ -1,10 +1,15 @@
-import { Effect, JsonSchema, Schema } from "effect";
+import { Effect, JsonSchema, Schema, Stream } from "effect";
+import { tryRequest } from "./media-model.js";
 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";
-/** Run an `LLMRequest` built with `LLM.request(...)`. */
-export const generate = LLMClient.generate;
-export const stream = LLMClient.stream;
+export function generate(input, options) {
+    return requestEffect(input).pipe(Effect.flatMap((request) => LLMClient.generate(request, options)));
+}
+export function stream(input, options) {
+    return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => LLMClient.stream(request, options))));
+}
+const requestEffect = (input) => input instanceof LLMRequest ? Effect.succeed(input) : tryRequest(() => request(input));
 export const request = (input) => {
     const { system: requestSystem, prompt, messages, tools, toolChoice: requestToolChoice, generation: requestGeneration, providerOptions: requestProviderOptions, http: requestHttp, ...rest } = input;
     return new LLMRequest({

package/dist/promise.d.ts

@@ -2,10 +2,10 @@ import { Effect, Layer } from "effect";
 import { AIClient } from "./ai-client.js";
 import type { AwaitOptions, Event, Snapshot } from "./generation.js";
 import { ImageModel, ImageRequest, type ImageOptions, type ImageRequestInput } from "./image.js";
-import { LLM } from "./index.js";
 import { Media } from "./media.js";
 import { RequestExecutor } from "./route/executor.js";
-import { type LLMRequest } from "./schema/index.js";
+import { LanguageModel, LLMRequest } from "./schema/index.js";
+import type { RequestInput } from "./llm.js";
 import { SpeechModel, SpeechRequest, type SpeechRequestInput } from "./speech.js";
 import { TranscriptionModel, TranscriptionRequest, type TranscriptionOptions, type TranscriptionRequestInput } from "./transcription.js";
 import { VideoModel, VideoRequest, type VideoOptions, type VideoRequestInput } from "./video.js";
@@ -49,9 +49,9 @@ export declare const make: (options?: Options) => {
     /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
     write: (asset: Media.Asset, path: string, options?: RunOptions) => Promise<void>;
     llm: {
-        request: <const SelectedLanguageModel extends import("./index.js").LanguageModel>(input: LLM.RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
-        generate: (request: LLMRequest, options?: RunOptions) => Promise<import("./index.js").LLMResponse>;
-        stream: (request: LLMRequest, options?: RunOptions) => AsyncIterable<({
+        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;
@@ -528,9 +528,9 @@ export declare const ai: {
     /** Write an asset's bytes like `Media.write`, downloading `url` sources through the executor. */
     write: (asset: Media.Asset, path: string, options?: RunOptions) => Promise<void>;
     llm: {
-        request: <const SelectedLanguageModel extends import("./index.js").LanguageModel>(input: LLM.RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
-        generate: (request: LLMRequest, options?: RunOptions) => Promise<import("./index.js").LLMResponse>;
-        stream: (request: LLMRequest, options?: RunOptions) => AsyncIterable<({
+        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;

package/dist/promise.js

@@ -3,8 +3,9 @@ import { AIClient } from "./ai-client.js";
 import { Image, ImageModel, ImageRequest } from "./image.js";
 import { LLM } from "./index.js";
 import { Media } from "./media.js";
+import { tryRequest } from "./media-model.js";
 import { RequestExecutor } from "./route/executor.js";
-import { AIError, InvalidRequestError } from "./schema/index.js";
+import { AIError, InvalidRequestError, LanguageModel, LLMRequest } from "./schema/index.js";
 import { Speech, SpeechModel, SpeechRequest } from "./speech.js";
 import { Transcription, TranscriptionModel, TranscriptionRequest, } from "./transcription.js";
 import { fileMediaType } from "./utils/media-type.js";
@@ -35,6 +36,7 @@ export const make = (options = {}) => {
         cancel: (options) => run(generation.cancel(), options),
     });
     // The typed `generate`/`stream` overloads take a concrete input or a request, not the union; normalize once here.
+    const llmRequest = (input) => input instanceof LLMRequest ? Effect.succeed(input) : tryRequest(() => LLM.request(input));
     const imageRequest = (input) => input instanceof ImageRequest ? input : Image.request(input);
     const videoRequest = (input) => input instanceof VideoRequest ? input : Video.request(input);
     const speechRequest = (input) => input instanceof SpeechRequest ? input : Speech.request(input);
@@ -67,8 +69,8 @@ export const make = (options = {}) => {
         },
         llm: {
             request: LLM.request,
-            generate: (request, options) => run(LLM.generate(request), options),
-            stream: (request, options) => iterate(LLM.stream(request), options),
+            generate: (input, options) => run(Effect.flatMap(llmRequest(input), LLM.generate), options),
+            stream: (input, options) => iterate(Stream.unwrap(Effect.map(llmRequest(input), LLM.stream)), options),
         },
         image: {
             request: Image.request,

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-20136",
+  "version": "0.0.0-dev-20138",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "0.0.0-dev-20136",
+    "@opencode/http-recorder": "0.0.0-dev-20138",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -44,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "0.0.0-dev-20136",
+    "@opencode/schema": "0.0.0-dev-20138",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"