@opencode-ai/ai 0.0.0-beta-18387 → 0.0.0-beta-18593

package/dist/schema/events.js

@@ -91,6 +91,8 @@ export const TextDelta = Schema.Struct({
 export const TextEnd = Schema.Struct({
     type: Schema.tag("text-end"),
     id: ContentBlockID,
+    /** Authoritative complete value; replaces accumulated deltas when present. */
+    text: Schema.optional(Schema.String),
     providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.TextEnd" });
 export const ReasoningStart = Schema.Struct({
@@ -107,6 +109,8 @@ export const ReasoningDelta = Schema.Struct({
 export const ReasoningEnd = Schema.Struct({
     type: Schema.tag("reasoning-end"),
     id: ContentBlockID,
+    /** Authoritative complete value; replaces accumulated deltas when present. */
+    text: Schema.optional(Schema.String),
     providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ReasoningEnd" });
 export const ToolInputStart = Schema.Struct({
@@ -259,14 +263,26 @@ export const LLMEvent = Object.assign(llmEventTagged, {
         providerError: llmEventTagged.guards["provider-error"],
     },
 });
-const responseText = (events) => events
-    .filter(LLMEvent.is.textDelta)
-    .map((event) => event.text)
-    .join("");
-const responseReasoning = (events) => events
-    .filter(LLMEvent.is.reasoningDelta)
-    .map((event) => event.text)
-    .join("");
+/** Joins deltas per fragment, letting an authoritative end value replace that fragment's accumulated deltas. */
+const joinFragments = (events, isDelta, isEnd) => {
+    const order = [];
+    const parts = new Map();
+    for (const event of events) {
+        if (isDelta(event)) {
+            if (!parts.has(event.id))
+                order.push(event.id);
+            parts.set(event.id, (parts.get(event.id) ?? "") + event.text);
+        }
+        if (isEnd(event) && event.text !== undefined) {
+            if (!parts.has(event.id))
+                order.push(event.id);
+            parts.set(event.id, event.text);
+        }
+    }
+    return order.map((id) => parts.get(id)).join("");
+};
+const responseText = (events) => joinFragments(events, LLMEvent.is.textDelta, LLMEvent.is.textEnd);
+const responseReasoning = (events) => joinFragments(events, LLMEvent.is.reasoningDelta, LLMEvent.is.reasoningEnd);
 const responseUsage = (events) => events.reduce((usage, event) => ("usage" in event && event.usage !== undefined ? event.usage : usage), undefined);
 const emptyResponseState = () => ({
     events: [],
@@ -333,10 +349,11 @@ const reduceTextEnd = (state, event) => {
     const current = state.textParts[event.id];
     if (!current)
         return state;
+    const text = event.text ?? current.text;
     const providerMetadata = event.providerMetadata ?? current.providerMetadata;
     return {
-        ...replaceContent(state, current.contentIndex, textContent(current.text, providerMetadata)),
-        textParts: { ...state.textParts, [event.id]: { ...current, providerMetadata } },
+        ...replaceContent(state, current.contentIndex, textContent(text, providerMetadata)),
+        textParts: { ...state.textParts, [event.id]: { ...current, text, providerMetadata } },
     };
 };
 const ensureReasoning = (state, id, providerMetadata) => {
@@ -366,10 +383,11 @@ const reduceReasoningEnd = (state, event) => {
     const current = state.reasoningParts[event.id];
     if (!current)
         return state;
+    const text = event.text ?? current.text;
     const providerMetadata = event.providerMetadata ?? current.providerMetadata;
     return {
-        ...replaceContent(state, current.contentIndex, reasoningContent(current.text, providerMetadata)),
-        reasoningParts: { ...state.reasoningParts, [event.id]: { ...current, providerMetadata } },
+        ...replaceContent(state, current.contentIndex, reasoningContent(text, providerMetadata)),
+        reasoningParts: { ...state.reasoningParts, [event.id]: { ...current, text, providerMetadata } },
     };
 };
 const reduceToolInputStart = (state, event) => ({
@@ -457,11 +475,11 @@ export class LLMResponse extends Schema.Class("LLM.Response")({
     usage: Schema.optional(Usage),
     finishReason: FinishReasonDetails,
 }) {
-    /** Concatenated assistant text assembled from streamed `text-delta` events. */
+    /** Concatenated assistant text; each fragment's `text-end` value replaces its accumulated deltas when present. */
     get text() {
         return responseText(this.events);
     }
-    /** Concatenated reasoning text assembled from streamed `reasoning-delta` events. */
+    /** Concatenated reasoning text; each fragment's `reasoning-end` value replaces its accumulated deltas when present. */
     get reasoning() {
         return responseReasoning(this.events);
     }

package/dist/testing.d.ts

@@ -1,5 +1,5 @@
 export * as TestLLM from "./testing.js";
-import { type Interface as LLMClientShape } from "./route/client.js";
+import { LLMClient } from "./route/client.js";
 import { LLMEvent, type FinishReasonDetails, type AIError, type LLMRequest, type ProviderMetadata, type UsageInput } from "./schema/index.js";
 import { Context, Effect, Layer, Scope, Stream } from "effect";
 export type Response = readonly LLMEvent[] | Stream.Stream<LLMEvent, AIError>;
@@ -7,13 +7,31 @@ export type Gate = Readonly<{
     started: Effect.Effect<void>;
     release: Effect.Effect<void>;
 }>;
+type ClientInterface = Context.Service.Shape<typeof LLMClient.Service>;
+export type Responder = (request: LLMRequest) => Response;
+export interface TestInterface extends ClientInterface {
+    /** Returns a snapshot of requests observed at execution time. */
+    readonly requests: () => Effect.Effect<readonly LLMRequest[]>;
+    readonly push: (...responses: readonly Response[]) => Effect.Effect<void>;
+    /** Replaces the fallback without changing queued responses. */
+    readonly always: (response: Response) => Effect.Effect<void>;
+    /** Answers requests after the one-shot queue is exhausted; receives the original request. */
+    readonly serve: (responder: Responder) => Effect.Effect<void>;
+    /** Waits for request arrivals, not output or completion. */
+    readonly wait: (count: number) => Effect.Effect<void>;
+    readonly gate: () => Effect.Effect<Gate, never, Scope.Scope>;
+}
+declare const Test_base: Context.ServiceClass<Test, "@opencode/ai/TestLLM/Test", TestInterface>;
+export declare class Test extends Test_base {
+}
+/** @deprecated Use TestInterface through Test and testLayer. */
 export interface Interface {
     readonly requests: LLMRequest[];
     readonly push: (...responses: readonly Response[]) => Effect.Effect<void>;
     readonly always: (response: Response) => Effect.Effect<void>;
     readonly wait: (count: number) => Effect.Effect<void>;
     readonly gate: Effect.Effect<Gate, never, Scope.Scope>;
-    readonly client: LLMClientShape;
+    readonly client: ClientInterface;
 }
 export interface LayerOptions {
     readonly transformRequest?: (request: LLMRequest) => LLMRequest;
@@ -21,6 +39,7 @@ export interface LayerOptions {
     readonly fallback?: Response;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/ai/TestLLM", Interface>;
+/** @deprecated Use Test and testLayer for normal client methods and test controls. */
 export declare class Service extends Service_base {
 }
 export declare const complete: (options: {
@@ -50,6 +69,7 @@ export declare const complete: (options: {
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -75,6 +95,7 @@ export declare const complete: (options: {
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -233,6 +254,7 @@ export declare const stop: (...events: readonly LLMEvent[]) => ({
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -258,6 +280,7 @@ export declare const stop: (...events: readonly LLMEvent[]) => ({
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -416,6 +439,7 @@ export declare const toolCalls: (...events: readonly LLMEvent[]) => ({
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -441,6 +465,7 @@ export declare const toolCalls: (...events: readonly LLMEvent[]) => ({
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -599,6 +624,7 @@ export declare const text: (value: string, id: string) => ({
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -624,6 +650,7 @@ export declare const text: (value: string, id: string) => ({
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -782,6 +809,7 @@ export declare const textWithUsage: (value: string, id: string, inputTokens: num
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -807,6 +835,7 @@ export declare const textWithUsage: (value: string, id: string, inputTokens: num
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -965,6 +994,7 @@ export declare const tool: (id: string, name: string, input: unknown) => ({
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -990,6 +1020,7 @@ export declare const tool: (id: string, name: string, input: unknown) => ({
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -1148,6 +1179,7 @@ export declare const failAfter: (error: AIError, ...events: readonly LLMEvent[])
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -1173,6 +1205,7 @@ export declare const failAfter: (error: AIError, ...events: readonly LLMEvent[])
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -1331,6 +1364,7 @@ export declare const hangAfter: (...events: readonly LLMEvent[]) => Stream.Strea
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -1356,6 +1390,7 @@ export declare const hangAfter: (...events: readonly LLMEvent[]) => Stream.Strea
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -1491,7 +1526,11 @@ export declare const hangAfter: (...events: readonly LLMEvent[]) => Stream.Strea
     } | undefined;
     readonly classification?: "context-overflow" | "payload-too-large" | undefined;
 }, never, never>;
+/** Provides one shared implementation under the normal client and test-control tags. */
+export declare const testLayer: (options?: LayerOptions) => Layer.Layer<import("./route/client.js").Service | Test, never, never>;
+/** @deprecated Use testLayer; retained for published callers of the legacy control interface. */
 export declare const layer: (options?: LayerOptions) => Layer.Layer<Service, never, never>;
+/** @deprecated testLayer provides LLMClient.Service directly. */
 export declare const clientLayer: Layer.Layer<import("./route/client.js").Service, never, Service>;
 export declare const push: (...responses: readonly Response[]) => Effect.Effect<void, never, Service>;
 export declare const always: (response: Response) => Effect.Effect<void, never, Service>;

package/dist/testing.js

@@ -2,6 +2,9 @@ export * as TestLLM from "./testing.js";
 import { LLMClient } from "./route/client.js";
 import { LLMEvent, LLMResponse, } from "./schema/index.js";
 import { Context, Deferred, Effect, Latch, Layer, Queue, Scope, Stream } from "effect";
+export class Test extends Context.Service()("@opencode/ai/TestLLM/Test") {
+}
+/** @deprecated Use Test and testLayer for normal client methods and test controls. */
 export class Service extends Context.Service()("@opencode/ai/TestLLM") {
 }
 export const complete = (options, ...events) => [
@@ -28,28 +31,33 @@ export const tool = (id, name, input) => toolCalls(LLMEvent.toolCall({ id, name,
 export const failAfter = (error, ...events) => Stream.fromIterable(events).pipe(Stream.concat(Stream.fail(error)));
 export const hangAfter = (...events) => Stream.concat(Stream.fromIterable(events), Stream.never);
 const toStream = (response) => (Stream.isStream(response) ? response : Stream.fromIterable(response));
-export const layer = (options = {}) => Layer.effect(Service, Effect.gen(function* () {
+const make = (options) => Effect.sync(() => {
     const requests = [];
     const responses = [];
     let started = Deferred.makeUnsafe();
     let fallback = options.fallback;
     let activeGate;
     const wait = (count) => Effect.suspend(() => requests.length >= count ? Effect.void : Deferred.await(started).pipe(Effect.andThen(wait(count))));
-    const stream = ((request) => {
-        requests.push(options.transformRequest?.(request) ?? request);
+    const stream = (request) => Stream.suspend(() => {
+        const count = requests.push(options.transformRequest?.(request) ?? request);
         const waiting = started;
         started = Deferred.makeUnsafe();
-        Deferred.doneUnsafe(waiting, Effect.void);
-        const response = responses.shift() ?? fallback;
-        if (!response)
-            return Stream.die(new Error(`TestLLM has no response for request ${requests.length}`));
-        const streamed = toStream(response);
         const gate = activeGate;
-        if (!gate)
-            return streamed;
-        return Stream.unwrap(Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(streamed)));
+        try {
+            const response = responses.shift() ?? (typeof fallback === "function" ? fallback(request) : fallback);
+            if (!response)
+                return Stream.die(new Error(`TestLLM has no response for request ${count}`));
+            const streamed = toStream(response);
+            if (!gate)
+                return streamed;
+            return Stream.unwrap(Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(streamed)));
+        }
+        finally {
+            // Waiters can resume synchronously; assign the reply and gate before notifying them.
+            Deferred.doneUnsafe(waiting, Effect.void);
+        }
     });
-    const client = LLMClient.Service.of({
+    const test = Test.of({
         stream,
         generate: (request) => stream(request).pipe(Stream.runFold(LLMResponse.empty, LLMResponse.reduce), Effect.flatMap((state) => {
             const response = LLMResponse.complete(state);
@@ -57,17 +65,18 @@ export const layer = (options = {}) => Layer.effect(Service, Effect.gen(function
                 return Effect.succeed(response);
             return Effect.die("TestLLM response ended without a terminal finish event");
         })),
-    });
-    return Service.of({
-        requests,
+        requests: () => Effect.sync(() => [...requests]),
         push: (...input) => Effect.sync(() => {
             responses.push(...input);
         }),
         always: (response) => Effect.sync(() => {
             fallback = response;
         }),
+        serve: (responder) => Effect.sync(() => {
+            fallback = responder;
+        }),
         wait,
-        gate: Effect.gen(function* () {
+        gate: () => Effect.gen(function* () {
             const gate = {
                 started: yield* Effect.acquireRelease(Queue.unbounded(), Queue.shutdown),
                 release: yield* Latch.make(),
@@ -83,9 +92,21 @@ export const layer = (options = {}) => Layer.effect(Service, Effect.gen(function
                 release,
             };
         }),
-        client,
     });
-}));
+    return { test, requests };
+});
+/** Provides one shared implementation under the normal client and test-control tags. */
+export const testLayer = (options = {}) => Layer.effectContext(Effect.map(make(options), (implementation) => Context.make(LLMClient.Service, implementation.test).pipe(Context.add(Test, implementation.test))));
+/** @deprecated Use testLayer; retained for published callers of the legacy control interface. */
+export const layer = (options = {}) => Layer.effect(Service, Effect.map(make(options), (implementation) => Service.of({
+    requests: implementation.requests,
+    push: implementation.test.push,
+    always: implementation.test.always,
+    wait: implementation.test.wait,
+    gate: implementation.test.gate(),
+    client: implementation.test,
+})));
+/** @deprecated testLayer provides LLMClient.Service directly. */
 export const clientLayer = Layer.effect(LLMClient.Service, Effect.map(Service, (service) => service.client));
 export const push = (...responses) => Service.use((service) => service.push(...responses));
 export const always = (response) => Service.use((service) => service.always(response));

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-beta-18387",
+  "version": "0.0.0-beta-18593",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -29,8 +29,8 @@
   },
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
-    "@effect/platform-node": "4.0.0-rc.111",
-    "@opencode-ai/http-recorder": "0.0.0-beta-18387",
+    "@effect/platform-node": "4.0.0-rc.112",
+    "@opencode-ai/http-recorder": "0.0.0-beta-18593",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -39,9 +39,9 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-beta-18387",
+    "@opencode-ai/schema": "0.0.0-beta-18593",
     "aws4fetch": "1.0.20",
-    "effect": "4.0.0-rc.111",
+    "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"
   }
 }