mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-16 21:15:57 +03:00
fix(ai): match the Promise client to the Effect API (#60465)
This commit is contained in:
committed by
GitHub
Unverified
parent
6a3d7a7992
commit
a08b40eaea
@@ -7,6 +7,7 @@
|
||||
- **One canonical model.** The Schema classes in `src/schema/` are the data model. Do not add a parallel shape or a second construction path.
|
||||
- **Independent of Session.** Auth, permissions, plugins, and orchestration belong in Core. `LLM.stream`/`LLM.generate` run exactly one model call.
|
||||
- **Reuse protocols.** Providers compose existing protocols with `Route.make(...)` instead of cloning them.
|
||||
- **One API, two runtimes.** Every `LLM`, `Image` and `Decision` operation has an `ai.*` twin with the same name, overloads, input and options (plus `signal`); keep `test/promise-parity.types.ts` passing.
|
||||
|
||||
## Code style
|
||||
|
||||
|
||||
@@ -308,7 +308,6 @@ export function request(input: DecisionRequest | DecisionRequestInput) {
|
||||
export function generate<const Model extends DecisionModel, const Questions extends DecisionQuestions>(
|
||||
input: DecisionRequestInput<Model, Questions>,
|
||||
): Effect.Effect<DecisionResponseFor<Questions>, AIError, Service>
|
||||
export function generate(input: DecisionRequest): Effect.Effect<DecisionResponse, AIError, Service>
|
||||
export function generate(input: DecisionRequest | DecisionRequestInput) {
|
||||
return tryRequest(() => request(input)).pipe(Effect.flatMap(DecisionClient.generate))
|
||||
}
|
||||
|
||||
+20
-10
@@ -10,6 +10,7 @@ import {
|
||||
type CheckpointRequest,
|
||||
type CompactionRequest,
|
||||
type EndpointCompactOptions,
|
||||
type StreamOptions,
|
||||
type TriggerCompactOptions,
|
||||
} from "./route/client.js"
|
||||
import { RequestExecutor } from "./route/executor.js"
|
||||
@@ -63,6 +64,8 @@ export type Services = AIClient.Services
|
||||
* new handle rather than updating this one.
|
||||
*/
|
||||
export type GenerationHandle<Response> = Snapshot & {
|
||||
readonly snapshot: Snapshot
|
||||
readonly terminal: boolean
|
||||
/** Serializable JSON; pass it back to `resume` from another process. */
|
||||
readonly token: unknown
|
||||
readonly await: (options?: AwaitOptions & RunOptions) => Promise<Response>
|
||||
@@ -145,9 +148,11 @@ export const make = <R = never>(options: Options<R> = {}) => {
|
||||
|
||||
const handle = <Response>(generation: Generation<Response>): GenerationHandle<Response> => ({
|
||||
...generation.snapshot,
|
||||
snapshot: generation.snapshot,
|
||||
terminal: generation.terminal,
|
||||
token: generation.token,
|
||||
await: (options) => run(generation.await({ poll: options?.poll }), options),
|
||||
events: (options) => iterate(generation.events({ poll: options?.poll }), options),
|
||||
await: (options) => run(generation.await(options), options),
|
||||
events: (options) => iterate(generation.events(options), options),
|
||||
result: (options) => run(generation.result(), options),
|
||||
refresh: (options) => run(generation.refresh(), options).then(handle),
|
||||
cancel: (options) => run(generation.cancel(), options),
|
||||
@@ -193,28 +198,33 @@ export const make = <R = never>(options: Options<R> = {}) => {
|
||||
},
|
||||
llm: {
|
||||
request: LLM.request,
|
||||
generate: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) =>
|
||||
run(LLM.generate(input), options),
|
||||
stream: <const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: RunOptions) =>
|
||||
iterate(LLM.stream(input), options),
|
||||
generate: <const Model extends LanguageModel>(
|
||||
input: RequestInput<Model> | LLMRequest,
|
||||
options?: StreamOptions & RunOptions,
|
||||
) => run(LLM.generate(input, options), options),
|
||||
stream: <const Model extends LanguageModel>(
|
||||
input: RequestInput<Model> | LLMRequest,
|
||||
options?: StreamOptions & RunOptions,
|
||||
) => iterate(LLM.stream(input, options), options),
|
||||
/** Stream model calls, running their tool calls, until the model stops calling tools or `until` is true. */
|
||||
loop: <const Model extends LanguageModel>(input: LoopInput<Model>, options?: RunOptions) =>
|
||||
iterate(LLM.loop(input), options),
|
||||
loop: <const Model extends LanguageModel>(input: LoopInput<Model>, options?: StreamOptions & RunOptions) =>
|
||||
iterate(LLM.loop(input, options), options),
|
||||
/** Decode the model's output against `schema` (or `jsonSchema`, unvalidated) like `LLM.generateObject`. */
|
||||
generateObject,
|
||||
/** Compact a Responses request like `LLMClient.compact`: a replacement window, or a checkpoint with `mechanism: "trigger"`. */
|
||||
compact,
|
||||
canCompact: LLMClient.canCompact,
|
||||
},
|
||||
image: {
|
||||
request: Image.request,
|
||||
generate: <const Model extends ImageModel>(
|
||||
input: ImageRequestInput<Model> | ImageRequest,
|
||||
options?: AwaitOptions & RunOptions,
|
||||
) => run(Image.generate(input, { poll: options?.poll }), options),
|
||||
) => run(Image.generate(input, options), options),
|
||||
stream: <const Model extends ImageModel>(
|
||||
input: ImageRequestInput<Model> | ImageRequest,
|
||||
options?: AwaitOptions & RunOptions,
|
||||
) => iterate(Image.stream(input, { poll: options?.poll }), options),
|
||||
) => iterate(Image.stream(input, options), options),
|
||||
start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) =>
|
||||
run(Image.start(input), options).then(handle),
|
||||
resume: (model: ImageModel, token: unknown, options?: RunOptions) =>
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
import type { Effect, Stream } from "effect"
|
||||
import type { Client, GenerationHandle } from "../src/index.js"
|
||||
import type { Decision, Generation, Image, LLM, LLMClient } from "../src/effect.js"
|
||||
|
||||
// The Promise client mirrors the Effect API: same methods, same arguments, same results. The only allowed differences
|
||||
// are `signal` on the options bag, Promise for Effect, AsyncIterable for Stream and GenerationHandle for Generation.
|
||||
|
||||
type Equal<A, B> = [A, B] extends [B, A] ? true : false
|
||||
type Assert<T extends Record<string, true>> = T
|
||||
|
||||
/** The Effect operations each `ai.*` namespace mirrors. Adding an operation here, or on `LLM`, fails until `ai` has it. */
|
||||
export type Surface = {
|
||||
readonly llm: Operations<typeof LLM> & Pick<typeof LLMClient, "compact" | "canCompact">
|
||||
readonly image: typeof Image
|
||||
readonly decision: typeof Decision
|
||||
}
|
||||
|
||||
type Operations<M> = { [K in keyof M as M[K] extends (...args: never) => unknown ? K : never]: M[K] }
|
||||
|
||||
type Signatures<F> = F extends {
|
||||
(...args: infer A1): infer R1
|
||||
(...args: infer A2): infer R2
|
||||
(...args: infer A3): infer R3
|
||||
}
|
||||
? [A1, R1] | [A2, R2] | [A3, R3]
|
||||
: F extends { (...args: infer A1): infer R1; (...args: infer A2): infer R2 }
|
||||
? [A1, R1] | [A2, R2]
|
||||
: F extends (...args: infer A) => infer R
|
||||
? [A, R]
|
||||
: never
|
||||
|
||||
type Positional<P> = P extends readonly [infer A, ...infer Rest] ? [WithoutSignal<A>, ...Positional<Rest>] : []
|
||||
// Paired with its keys: an options bag of optional fields is otherwise assignable to `{}` and back.
|
||||
type Options<P> = P extends readonly [unknown, ...infer Rest]
|
||||
? Options<Rest>
|
||||
: P extends readonly [(infer O)?]
|
||||
? Keyed<WithoutSignal<NonNullable<O>>>
|
||||
: Keyed<{}>
|
||||
type Keyed<T> = [keyof T, T]
|
||||
type WithoutSignal<T> = T extends { readonly signal?: AbortSignal } ? Omit<T, "signal"> : T
|
||||
|
||||
type Promised<R> =
|
||||
R extends Effect.Effect<Generation<infer A>, infer _E, infer _R>
|
||||
? Promise<GenerationHandle<A>>
|
||||
: R extends Effect.Effect<infer A, infer _E, infer _R>
|
||||
? Promise<A>
|
||||
: R extends Stream.Stream<infer A, infer _E, infer _R>
|
||||
? AsyncIterable<A>
|
||||
: R
|
||||
|
||||
type EffectShape<F> =
|
||||
Signatures<F> extends infer S ? (S extends [infer A, infer R] ? [Positional<A>, Options<A>, Promised<R>] : never) : never
|
||||
type PromiseShape<F> =
|
||||
Signatures<F> extends infer S ? (S extends [infer A, infer R] ? [Positional<A>, Options<A>, R] : never) : never
|
||||
|
||||
export type Drift<Promise, Effect> = {
|
||||
readonly [K in keyof Promise | keyof Effect]: K extends keyof Promise
|
||||
? K extends keyof Effect
|
||||
? Equal<PromiseShape<Promise[K]>, EffectShape<Effect[K]>>
|
||||
: "missing in Effect"
|
||||
: "missing in Promise"
|
||||
}
|
||||
|
||||
type Same<A, B> = [Exclude<A, B> | Exclude<B, A>] extends [never] ? true : { readonly drift: Exclude<A, B> | Exclude<B, A> }
|
||||
|
||||
export type Checks = [
|
||||
Assert<{ handle: Same<keyof GenerationHandle<unknown>, Exclude<keyof Generation<unknown>, "route">> }>,
|
||||
Assert<Drift<Client["llm"], Surface["llm"]>>,
|
||||
Assert<Drift<Client["image"], Surface["image"]>>,
|
||||
Assert<Drift<Client["decision"], Surface["decision"]>>,
|
||||
]
|
||||
@@ -5,7 +5,7 @@ import { join } from "node:path"
|
||||
import { Effect, Layer, Schema } from "effect"
|
||||
import { HttpClientRequest } from "effect/http"
|
||||
import { AIError, LLMEvent, Media, SpeechEvent, TranscriptionEvent } from "../src/effect.js"
|
||||
import { RequestExecutor } from "../src/route.js"
|
||||
import { RequestExecutor, type StreamOptions } from "../src/route.js"
|
||||
import { AI } from "../src/index.js"
|
||||
import { AssemblyAI, OpenAI, Runway } from "../src/providers.js"
|
||||
import { handlerLayer, json } from "./lib/http.js"
|
||||
@@ -203,6 +203,41 @@ describe("AI promise client", () => {
|
||||
await ai.dispose()
|
||||
})
|
||||
|
||||
test("forwards per-call options to generate, stream, and loop, and checks compaction support", async () => {
|
||||
const seen: Array<string> = []
|
||||
const ai = AI.make({ layer: executor([]) })
|
||||
const options: StreamOptions = {
|
||||
http: (request, handler) => {
|
||||
seen.push(request.url)
|
||||
return handler(request)
|
||||
},
|
||||
}
|
||||
const request = { model: openai.chat("gpt-4o-mini"), prompt: "Say hello." }
|
||||
|
||||
expect((await ai.llm.generate(request, options)).text).toBe("Hello world")
|
||||
await Array.fromAsync(ai.llm.stream(request, options))
|
||||
await Array.fromAsync(ai.llm.loop({ ...request, tools: {} }, options))
|
||||
expect(seen).toEqual(Array(3).fill("https://openai.test/v1/chat/completions"))
|
||||
|
||||
const responses = ai.llm.request({ model: openai.responses("gpt-5"), prompt: "Hello" })
|
||||
expect(ai.llm.canCompact(responses)).toBe(true)
|
||||
expect(ai.llm.canCompact(responses, { mechanism: "trigger" })).toBe(true)
|
||||
expect(ai.llm.canCompact(ai.llm.request(request))).toBe(false)
|
||||
await ai.dispose()
|
||||
})
|
||||
|
||||
test("exposes a generation's snapshot and terminal state", async () => {
|
||||
const ai = AI.make({ layer: executor([]) })
|
||||
const model = Runway.configure({ apiKey: "test", baseURL: "https://runway.test/v1" }).video("gen4.5")
|
||||
const generation = await ai.video.start({ model, prompt: "A kite" })
|
||||
expect(generation.snapshot).toEqual({ id: "task_1", status: "queued", progress: undefined, position: undefined })
|
||||
expect(generation.terminal).toBe(false)
|
||||
const refreshed = await generation.refresh()
|
||||
expect(refreshed.terminal).toBe(false)
|
||||
expect((await refreshed.refresh()).terminal).toBe(true)
|
||||
await ai.dispose()
|
||||
})
|
||||
|
||||
test("observes a started generation's events and fetches its result", async () => {
|
||||
const ai = AI.make({ layer: executor([]) })
|
||||
const model = Runway.configure({ apiKey: "test", baseURL: "https://runway.test/v1" }).video("gen4.5")
|
||||
|
||||
Reference in New Issue
Block a user