assistant-stream 0.3.25 → 0.3.27

package/dist/core/{object/ObjectStreamAccumulator.js → gorp/GorpStreamAccumulator.js}

@@ -1,5 +1,6 @@
-//#region src/core/object/ObjectStreamAccumulator.ts
-var ObjectStreamAccumulator = class ObjectStreamAccumulator {
+import { assertSafePathSegment } from "./changeTree.js";
+//#region src/core/gorp/GorpStreamAccumulator.ts
+var GorpStreamAccumulator = class GorpStreamAccumulator {
 	_state;
 	constructor(initialValue = null) {
 		this._state = initialValue;
@@ -8,13 +9,13 @@ var ObjectStreamAccumulator = class ObjectStreamAccumulator {
 		return this._state;
 	}
 	append(ops) {
-		this._state = ops.reduce((state, op) => ObjectStreamAccumulator.apply(state, op), this._state);
+		this._state = ops.reduce((state, op) => GorpStreamAccumulator.apply(state, op), this._state);
 	}
 	static apply(state, op) {
 		const type = op.type;
 		switch (type) {
-			case "set": return ObjectStreamAccumulator.updatePath(state, op.path, () => op.value);
-			case "append-text": return ObjectStreamAccumulator.updatePath(state, op.path, (current) => {
+			case "set": return GorpStreamAccumulator.updatePath(state, op.path, () => op.value);
+			case "append-text": return GorpStreamAccumulator.updatePath(state, op.path, (current) => {
 				if (typeof current !== "string") throw new Error(`Expected string at path [${op.path.join(", ")}]`);
 				return current + op.value;
 			});
@@ -26,20 +27,21 @@ var ObjectStreamAccumulator = class ObjectStreamAccumulator {
 		state ??= {};
 		if (typeof state !== "object") throw new Error(`Invalid path: [${path.join(", ")}]`);
 		const [key, ...rest] = path;
+		assertSafePathSegment(key);
 		if (Array.isArray(state)) {
 			const idx = Number(key);
 			if (Number.isNaN(idx)) throw new Error(`Expected array index at [${path.join(", ")}]`);
 			if (idx > state.length || idx < 0) throw new Error(`Insert array index out of bounds`);
 			const nextState = [...state];
-			nextState[idx] = ObjectStreamAccumulator.updatePath(nextState[idx], rest, updater);
+			nextState[idx] = GorpStreamAccumulator.updatePath(Object.hasOwn(nextState, idx) ? nextState[idx] : void 0, rest, updater);
 			return nextState;
 		}
 		const nextState = { ...state };
-		nextState[key] = ObjectStreamAccumulator.updatePath(nextState[key], rest, updater);
+		nextState[key] = GorpStreamAccumulator.updatePath(Object.hasOwn(nextState, key) ? nextState[key] : void 0, rest, updater);
 		return nextState;
 	}
 };
 //#endregion
-export { ObjectStreamAccumulator };
+export { GorpStreamAccumulator };
 
-//# sourceMappingURL=ObjectStreamAccumulator.js.map
+//# sourceMappingURL=GorpStreamAccumulator.js.map

package/dist/core/gorp/GorpStreamAccumulator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GorpStreamAccumulator.js","names":["_exhaustiveCheck"],"sources":["../../../src/core/gorp/GorpStreamAccumulator.ts"],"sourcesContent":["import type { ReadonlyJSONValue, ReadonlyJSONObject } from \"../../utils\";\nimport { assertSafePathSegment } from \"./changeTree\";\nimport type { GorpStreamOperation } from \"./types\";\n\nexport class GorpStreamAccumulator {\n  private _state: ReadonlyJSONValue;\n\n  constructor(initialValue: ReadonlyJSONValue = null) {\n    this._state = initialValue;\n  }\n\n  get state() {\n    return this._state;\n  }\n\n  append(ops: readonly GorpStreamOperation[]) {\n    this._state = ops.reduce(\n      (state, op) => GorpStreamAccumulator.apply(state, op),\n      this._state,\n    );\n  }\n\n  private static apply(state: ReadonlyJSONValue, op: GorpStreamOperation) {\n    const type = op.type;\n    switch (type) {\n      case \"set\":\n        return GorpStreamAccumulator.updatePath(state, op.path, () => op.value);\n      case \"append-text\":\n        return GorpStreamAccumulator.updatePath(state, op.path, (current) => {\n          if (typeof current !== \"string\")\n            throw new Error(`Expected string at path [${op.path.join(\", \")}]`);\n          return current + op.value;\n        });\n\n      default: {\n        const _exhaustiveCheck: never = type;\n        throw new Error(`Invalid operation type: ${_exhaustiveCheck}`);\n      }\n    }\n  }\n\n  private static updatePath(\n    state: ReadonlyJSONValue | undefined,\n    path: readonly string[],\n    updater: (current: ReadonlyJSONValue | undefined) => ReadonlyJSONValue,\n  ): ReadonlyJSONValue {\n    if (path.length === 0) return updater(state);\n\n    // Initialize state as empty object if it's null and we're trying to set a property\n    state ??= {};\n\n    if (typeof state !== \"object\") {\n      throw new Error(`Invalid path: [${path.join(\", \")}]`);\n    }\n\n    const [key, ...rest] = path as [string, ...(readonly string[])];\n    assertSafePathSegment(key);\n    if (Array.isArray(state)) {\n      const idx = Number(key);\n      if (Number.isNaN(idx))\n        throw new Error(`Expected array index at [${path.join(\", \")}]`);\n      if (idx > state.length || idx < 0)\n        throw new Error(`Insert array index out of bounds`);\n\n      const nextState = [...state];\n      nextState[idx] = GorpStreamAccumulator.updatePath(\n        Object.hasOwn(nextState, idx) ? nextState[idx] : undefined,\n        rest,\n        updater,\n      );\n\n      return nextState;\n    }\n\n    const nextState = { ...(state as ReadonlyJSONObject) };\n    nextState[key] = GorpStreamAccumulator.updatePath(\n      Object.hasOwn(nextState, key) ? nextState[key] : undefined,\n      rest,\n      updater,\n    );\n\n    return nextState;\n  }\n}\n"],"mappings":";;AAIA,IAAa,wBAAb,MAAa,sBAAsB;CACjC;CAEA,YAAY,eAAkC,MAAM;EAClD,KAAK,SAAS;CAChB;CAEA,IAAI,QAAQ;EACV,OAAO,KAAK;CACd;CAEA,OAAO,KAAqC;EAC1C,KAAK,SAAS,IAAI,QACf,OAAO,OAAO,sBAAsB,MAAM,OAAO,EAAE,GACpD,KAAK,MACP;CACF;CAEA,OAAe,MAAM,OAA0B,IAAyB;EACtE,MAAM,OAAO,GAAG;EAChB,QAAQ,MAAR;GACE,KAAK,OACH,OAAO,sBAAsB,WAAW,OAAO,GAAG,YAAY,GAAG,KAAK;GACxE,KAAK,eACH,OAAO,sBAAsB,WAAW,OAAO,GAAG,OAAO,YAAY;IACnE,IAAI,OAAO,YAAY,UACrB,MAAM,IAAI,MAAM,4BAA4B,GAAG,KAAK,KAAK,IAAI,EAAE,EAAE;IACnE,OAAO,UAAU,GAAG;GACtB,CAAC;GAEH,SAEE,MAAM,IAAI,MAAM,2BAA2BA,MAAkB;EAEjE;CACF;CAEA,OAAe,WACb,OACA,MACA,SACmB;EACnB,IAAI,KAAK,WAAW,GAAG,OAAO,QAAQ,KAAK;EAG3C,UAAU,CAAC;EAEX,IAAI,OAAO,UAAU,UACnB,MAAM,IAAI,MAAM,kBAAkB,KAAK,KAAK,IAAI,EAAE,EAAE;EAGtD,MAAM,CAAC,KAAK,GAAG,QAAQ;EACvB,sBAAsB,GAAG;EACzB,IAAI,MAAM,QAAQ,KAAK,GAAG;GACxB,MAAM,MAAM,OAAO,GAAG;GACtB,IAAI,OAAO,MAAM,GAAG,GAClB,MAAM,IAAI,MAAM,4BAA4B,KAAK,KAAK,IAAI,EAAE,EAAE;GAChE,IAAI,MAAM,MAAM,UAAU,MAAM,GAC9B,MAAM,IAAI,MAAM,kCAAkC;GAEpD,MAAM,YAAY,CAAC,GAAG,KAAK;GAC3B,UAAU,OAAO,sBAAsB,WACrC,OAAO,OAAO,WAAW,GAAG,IAAI,UAAU,OAAO,KAAA,GACjD,MACA,OACF;GAEA,OAAO;EACT;EAEA,MAAM,YAAY,EAAE,GAAI,MAA6B;EACrD,UAAU,OAAO,sBAAsB,WACrC,OAAO,OAAO,WAAW,GAAG,IAAI,UAAU,OAAO,KAAA,GACjD,MACA,OACF;EAEA,OAAO;CACT;AACF"}

package/dist/core/gorp/GorpStreamDeltaTracker.d.ts

@@ -0,0 +1,17 @@
+import { ReadonlyJSONValue } from "../../utils/json/json-value.js";
+import "../../utils.js";
+import { GorpStreamOperation } from "./types.js";
+//#region src/core/gorp/GorpStreamDeltaTracker.d.ts
+declare class GorpStreamDeltaTracker {
+  private readonly accumulator;
+  private previousState;
+  private changes;
+  constructor(initialValue?: ReadonlyJSONValue);
+  get state(): ReadonlyJSONValue;
+  append(operations: readonly GorpStreamOperation[]): void;
+  isChangedAt(path: readonly string[]): boolean;
+  getChangedKeys(path: readonly string[]): string[];
+}
+//#endregion
+export { GorpStreamDeltaTracker };
+//# sourceMappingURL=GorpStreamDeltaTracker.d.ts.map

package/dist/core/gorp/GorpStreamDeltaTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GorpStreamDeltaTracker.d.ts","names":[],"sources":["../../../src/core/gorp/GorpStreamDeltaTracker.ts"],"mappings":";;;;cAYa;mBACM;UACT;UACA;EAEI,YAAA,eAAc;MAKtB,SAAS;EAIb,OAAO,qBAAqB;EAW5B,YAAY;EAMZ,eAAe"}

package/dist/core/gorp/GorpStreamDeltaTracker.js

@@ -0,0 +1,38 @@
+import { createChangeNode, diffKeys, lookupChange, lookupValue, markChanged } from "./changeTree.js";
+import { GorpStreamAccumulator } from "./GorpStreamAccumulator.js";
+//#region src/core/gorp/GorpStreamDeltaTracker.ts
+var GorpStreamDeltaTracker = class {
+	accumulator;
+	previousState;
+	changes = createChangeNode();
+	constructor(initialValue = null) {
+		this.accumulator = new GorpStreamAccumulator(initialValue);
+		this.previousState = this.accumulator.state;
+	}
+	get state() {
+		return this.accumulator.state;
+	}
+	append(operations) {
+		const previousState = this.accumulator.state;
+		let changes = createChangeNode();
+		for (const op of operations) changes = markChanged(changes, op.path);
+		this.accumulator.append(operations);
+		this.previousState = previousState;
+		this.changes = changes;
+	}
+	isChangedAt(path) {
+		const node = lookupChange(this.changes, path);
+		if (node === true) return true;
+		return node !== false && Object.keys(node).length > 0;
+	}
+	getChangedKeys(path) {
+		const node = lookupChange(this.changes, path);
+		if (node === false) return [];
+		if (node === true) return diffKeys(lookupValue(this.accumulator.state, path), lookupValue(this.previousState, path));
+		return Object.keys(node);
+	}
+};
+//#endregion
+export { GorpStreamDeltaTracker };
+
+//# sourceMappingURL=GorpStreamDeltaTracker.js.map

package/dist/core/gorp/GorpStreamDeltaTracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GorpStreamDeltaTracker.js","names":[],"sources":["../../../src/core/gorp/GorpStreamDeltaTracker.ts"],"sourcesContent":["import type { ReadonlyJSONValue } from \"../../utils\";\nimport { GorpStreamAccumulator } from \"./GorpStreamAccumulator\";\nimport type { GorpStreamOperation } from \"./types\";\nimport {\n  type ChangeNode,\n  createChangeNode,\n  diffKeys,\n  lookupChange,\n  lookupValue,\n  markChanged,\n} from \"./changeTree\";\n\nexport class GorpStreamDeltaTracker {\n  private readonly accumulator: GorpStreamAccumulator;\n  private previousState: ReadonlyJSONValue;\n  private changes: ChangeNode = createChangeNode();\n\n  constructor(initialValue: ReadonlyJSONValue = null) {\n    this.accumulator = new GorpStreamAccumulator(initialValue);\n    this.previousState = this.accumulator.state;\n  }\n\n  get state(): ReadonlyJSONValue {\n    return this.accumulator.state;\n  }\n\n  append(operations: readonly GorpStreamOperation[]): void {\n    const previousState = this.accumulator.state;\n    let changes: ChangeNode = createChangeNode();\n    for (const op of operations) {\n      changes = markChanged(changes, op.path);\n    }\n    this.accumulator.append(operations);\n    this.previousState = previousState;\n    this.changes = changes;\n  }\n\n  isChangedAt(path: readonly string[]): boolean {\n    const node = lookupChange(this.changes, path);\n    if (node === true) return true;\n    return node !== false && Object.keys(node).length > 0;\n  }\n\n  getChangedKeys(path: readonly string[]): string[] {\n    const node = lookupChange(this.changes, path);\n    if (node === false) return [];\n    if (node === true) {\n      return diffKeys(\n        lookupValue(this.accumulator.state, path),\n        lookupValue(this.previousState, path),\n      );\n    }\n    return Object.keys(node);\n  }\n}\n"],"mappings":";;;AAYA,IAAa,yBAAb,MAAoC;CAClC;CACA;CACA,UAA8B,iBAAiB;CAE/C,YAAY,eAAkC,MAAM;EAClD,KAAK,cAAc,IAAI,sBAAsB,YAAY;EACzD,KAAK,gBAAgB,KAAK,YAAY;CACxC;CAEA,IAAI,QAA2B;EAC7B,OAAO,KAAK,YAAY;CAC1B;CAEA,OAAO,YAAkD;EACvD,MAAM,gBAAgB,KAAK,YAAY;EACvC,IAAI,UAAsB,iBAAiB;EAC3C,KAAK,MAAM,MAAM,YACf,UAAU,YAAY,SAAS,GAAG,IAAI;EAExC,KAAK,YAAY,OAAO,UAAU;EAClC,KAAK,gBAAgB;EACrB,KAAK,UAAU;CACjB;CAEA,YAAY,MAAkC;EAC5C,MAAM,OAAO,aAAa,KAAK,SAAS,IAAI;EAC5C,IAAI,SAAS,MAAM,OAAO;EAC1B,OAAO,SAAS,SAAS,OAAO,KAAK,IAAI,CAAC,CAAC,SAAS;CACtD;CAEA,eAAe,MAAmC;EAChD,MAAM,OAAO,aAAa,KAAK,SAAS,IAAI;EAC5C,IAAI,SAAS,OAAO,OAAO,CAAC;EAC5B,IAAI,SAAS,MACX,OAAO,SACL,YAAY,KAAK,YAAY,OAAO,IAAI,GACxC,YAAY,KAAK,eAAe,IAAI,CACtC;EAEF,OAAO,OAAO,KAAK,IAAI;CACzB;AACF"}

package/dist/core/gorp/GorpStreamResponse.d.ts

@@ -0,0 +1,16 @@
+import { GorpStreamChunk } from "./types.js";
+import { PipeableTransformStream } from "../utils/stream/PipeableTransformStream.js";
+//#region src/core/gorp/GorpStreamResponse.d.ts
+declare class GorpStreamEncoder extends PipeableTransformStream<GorpStreamChunk, Uint8Array> {
+  constructor();
+}
+declare class GorpStreamDecoder extends PipeableTransformStream<Uint8Array<ArrayBuffer>, GorpStreamChunk> {
+  constructor();
+}
+declare class GorpStreamResponse extends Response {
+  constructor(body: ReadableStream<GorpStreamChunk>);
+}
+declare const fromGorpStreamResponse: (response: Response) => ReadableStream<GorpStreamChunk>;
+//#endregion
+export { GorpStreamDecoder, GorpStreamEncoder, GorpStreamResponse, fromGorpStreamResponse };
+//# sourceMappingURL=GorpStreamResponse.d.ts.map

package/dist/core/gorp/GorpStreamResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GorpStreamResponse.d.ts","names":[],"sources":["../../../src/core/gorp/GorpStreamResponse.ts"],"mappings":";;;cAKa,0BAA0B,wBACrC,iBACA;;;cAyBW,0BAA0B,wBACrC,WAAW,cACX;;;cAsBW,2BAA2B;EAC1B,YAAA,MAAM,eAAe;;cAYtB,yBACX,UAAU,aACT,eAAe"}

package/dist/core/gorp/GorpStreamResponse.js

@@ -0,0 +1,51 @@
+import { PipeableTransformStream } from "../utils/stream/PipeableTransformStream.js";
+import { GorpStreamAccumulator } from "./GorpStreamAccumulator.js";
+import { SSEDecoder, SSEEncoder } from "../utils/stream/SSE.js";
+//#region src/core/gorp/GorpStreamResponse.ts
+var GorpStreamEncoder = class extends PipeableTransformStream {
+	constructor() {
+		let isFirstChunk = true;
+		super((readable) => readable.pipeThrough(new TransformStream({ transform(chunk, controller) {
+			if (isFirstChunk) controller.enqueue([{
+				type: "set",
+				path: [],
+				value: chunk.snapshot
+			}]);
+			else controller.enqueue(chunk.operations);
+			isFirstChunk = false;
+		} })).pipeThrough(new SSEEncoder()));
+	}
+};
+var GorpStreamDecoder = class extends PipeableTransformStream {
+	constructor() {
+		const accumulator = new GorpStreamAccumulator();
+		super((readable) => readable.pipeThrough(new SSEDecoder()).pipeThrough(new TransformStream({ transform(operations, controller) {
+			accumulator.append(operations);
+			controller.enqueue({
+				snapshot: accumulator.state,
+				operations
+			});
+		} })));
+	}
+};
+var GorpStreamResponse = class extends Response {
+	constructor(body) {
+		super(body.pipeThrough(new GorpStreamEncoder()), { headers: new Headers({
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+			"Assistant-Stream-Format": "object-stream/v0"
+		}) });
+	}
+};
+const fromGorpStreamResponse = (response) => {
+	if (!response.ok) throw new Error(`Response failed, status ${response.status}`);
+	if (!response.body) throw new Error("Response body is null");
+	if (response.headers.get("Content-Type")?.split(";", 1)[0]?.trim().toLowerCase() !== "text/event-stream") throw new Error("Response is not an event stream");
+	if (response.headers.get("Assistant-Stream-Format") !== "object-stream/v0") throw new Error("Unsupported Assistant-Stream-Format header");
+	return response.body.pipeThrough(new GorpStreamDecoder());
+};
+//#endregion
+export { GorpStreamDecoder, GorpStreamEncoder, GorpStreamResponse, fromGorpStreamResponse };
+
+//# sourceMappingURL=GorpStreamResponse.js.map

package/dist/core/gorp/GorpStreamResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GorpStreamResponse.js","names":[],"sources":["../../../src/core/gorp/GorpStreamResponse.ts"],"sourcesContent":["import { PipeableTransformStream } from \"../utils/stream/PipeableTransformStream\";\nimport { GorpStreamAccumulator } from \"./GorpStreamAccumulator\";\nimport { SSEDecoder, SSEEncoder } from \"../utils/stream/SSE\";\nimport type { GorpStreamChunk, GorpStreamOperation } from \"./types\";\n\nexport class GorpStreamEncoder extends PipeableTransformStream<\n  GorpStreamChunk,\n  Uint8Array\n> {\n  constructor() {\n    let isFirstChunk = true;\n    super((readable) =>\n      readable\n        .pipeThrough(\n          new TransformStream<GorpStreamChunk, readonly GorpStreamOperation[]>({\n            transform(chunk, controller) {\n              if (isFirstChunk) {\n                controller.enqueue([\n                  { type: \"set\", path: [], value: chunk.snapshot },\n                ]);\n              } else {\n                controller.enqueue(chunk.operations);\n              }\n              isFirstChunk = false;\n            },\n          }),\n        )\n        .pipeThrough(new SSEEncoder()),\n    );\n  }\n}\n\nexport class GorpStreamDecoder extends PipeableTransformStream<\n  Uint8Array<ArrayBuffer>,\n  GorpStreamChunk\n> {\n  constructor() {\n    const accumulator = new GorpStreamAccumulator();\n    super((readable) =>\n      readable\n        .pipeThrough(new SSEDecoder<readonly GorpStreamOperation[]>())\n        .pipeThrough(\n          new TransformStream<readonly GorpStreamOperation[], GorpStreamChunk>({\n            transform(operations, controller) {\n              accumulator.append(operations);\n              controller.enqueue({\n                snapshot: accumulator.state,\n                operations,\n              });\n            },\n          }),\n        ),\n    );\n  }\n}\n\nexport class GorpStreamResponse extends Response {\n  constructor(body: ReadableStream<GorpStreamChunk>) {\n    super(body.pipeThrough(new GorpStreamEncoder()), {\n      headers: new Headers({\n        \"Content-Type\": \"text/event-stream\",\n        \"Cache-Control\": \"no-cache\",\n        Connection: \"keep-alive\",\n        \"Assistant-Stream-Format\": \"object-stream/v0\",\n      }),\n    });\n  }\n}\n\nexport const fromGorpStreamResponse = (\n  response: Response,\n): ReadableStream<GorpStreamChunk> => {\n  if (!response.ok)\n    throw new Error(`Response failed, status ${response.status}`);\n  if (!response.body) throw new Error(\"Response body is null\");\n  const mediaType = response.headers\n    .get(\"Content-Type\")\n    ?.split(\";\", 1)[0]\n    ?.trim()\n    .toLowerCase();\n  if (mediaType !== \"text/event-stream\") {\n    throw new Error(\"Response is not an event stream\");\n  }\n  if (response.headers.get(\"Assistant-Stream-Format\") !== \"object-stream/v0\") {\n    throw new Error(\"Unsupported Assistant-Stream-Format header\");\n  }\n  return response.body.pipeThrough(new GorpStreamDecoder());\n};\n"],"mappings":";;;;AAKA,IAAa,oBAAb,cAAuC,wBAGrC;CACA,cAAc;EACZ,IAAI,eAAe;EACnB,OAAO,aACL,SACG,YACC,IAAI,gBAAiE,EACnE,UAAU,OAAO,YAAY;GAC3B,IAAI,cACF,WAAW,QAAQ,CACjB;IAAE,MAAM;IAAO,MAAM,CAAC;IAAG,OAAO,MAAM;GAAS,CACjD,CAAC;QAED,WAAW,QAAQ,MAAM,UAAU;GAErC,eAAe;EACjB,EACF,CAAC,CACH,CAAC,CACA,YAAY,IAAI,WAAW,CAAC,CACjC;CACF;AACF;AAEA,IAAa,oBAAb,cAAuC,wBAGrC;CACA,cAAc;EACZ,MAAM,cAAc,IAAI,sBAAsB;EAC9C,OAAO,aACL,SACG,YAAY,IAAI,WAA2C,CAAC,CAAC,CAC7D,YACC,IAAI,gBAAiE,EACnE,UAAU,YAAY,YAAY;GAChC,YAAY,OAAO,UAAU;GAC7B,WAAW,QAAQ;IACjB,UAAU,YAAY;IACtB;GACF,CAAC;EACH,EACF,CAAC,CACH,CACJ;CACF;AACF;AAEA,IAAa,qBAAb,cAAwC,SAAS;CAC/C,YAAY,MAAuC;EACjD,MAAM,KAAK,YAAY,IAAI,kBAAkB,CAAC,GAAG,EAC/C,SAAS,IAAI,QAAQ;GACnB,gBAAgB;GAChB,iBAAiB;GACjB,YAAY;GACZ,2BAA2B;EAC7B,CAAC,EACH,CAAC;CACH;AACF;AAEA,MAAa,0BACX,aACoC;CACpC,IAAI,CAAC,SAAS,IACZ,MAAM,IAAI,MAAM,2BAA2B,SAAS,QAAQ;CAC9D,IAAI,CAAC,SAAS,MAAM,MAAM,IAAI,MAAM,uBAAuB;CAM3D,IALkB,SAAS,QACxB,IAAI,cAAc,CAAC,EAClB,MAAM,KAAK,CAAC,CAAC,CAAC,EAAE,EAChB,KAAK,CAAC,CACP,YAAY,MACG,qBAChB,MAAM,IAAI,MAAM,iCAAiC;CAEnD,IAAI,SAAS,QAAQ,IAAI,yBAAyB,MAAM,oBACtD,MAAM,IAAI,MAAM,4CAA4C;CAE9D,OAAO,SAAS,KAAK,YAAY,IAAI,kBAAkB,CAAC;AAC1D"}

package/dist/core/gorp/changeTree.d.ts

@@ -0,0 +1,16 @@
+//#region src/core/gorp/changeTree.d.ts
+type ChangeNode = true | {
+  [key: string]: ChangeNode;
+};
+declare function createChangeNode(): {
+  [key: string]: ChangeNode;
+};
+declare function assertSafePathSegment(segment: string): void;
+declare function markChanged(node: ChangeNode, path: readonly string[]): ChangeNode;
+declare function mergeChanged(target: ChangeNode, source: ChangeNode): ChangeNode;
+declare function lookupChange(node: ChangeNode, path: readonly string[]): ChangeNode | false;
+declare function lookupValue(state: unknown, path: readonly string[]): unknown;
+declare function diffKeys(newNode: unknown, oldNode: unknown): string[];
+//#endregion
+export { ChangeNode, assertSafePathSegment, createChangeNode, diffKeys, lookupChange, lookupValue, markChanged, mergeChanged };
+//# sourceMappingURL=changeTree.d.ts.map

package/dist/core/gorp/changeTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changeTree.d.ts","names":[],"sources":["../../../src/core/gorp/changeTree.ts"],"mappings":";KAAY;GAAuB,cAAc;;iBAEjC;GAAuB,cAAc;;iBAMrC,sBAAsB;iBAMtB,YACd,MAAM,YACN,0BACC;iBAiBa,aACd,QAAQ,YACR,QAAQ,aACP;iBAwBa,aACd,MAAM,YACN,0BACC;iBAUa,YAAY,gBAAgB;iBAY5B,SAAS,kBAAkB"}

package/dist/core/gorp/changeTree.js

@@ -0,0 +1,77 @@
+//#region src/core/gorp/changeTree.ts
+function createChangeNode() {
+	return Object.create(null);
+}
+const UNSAFE_PATH_SEGMENTS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function assertSafePathSegment(segment) {
+	if (UNSAFE_PATH_SEGMENTS.has(segment)) throw new Error(`Unsafe gorp path segment: ${segment}`);
+}
+function markChanged(node, path) {
+	if (node === true || path.length === 0) return true;
+	let cursor = node;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = path[i];
+		assertSafePathSegment(key);
+		const next = Object.hasOwn(cursor, key) ? cursor[key] : void 0;
+		if (next === true) return node;
+		if (next === void 0) cursor[key] = createChangeNode();
+		cursor = cursor[key];
+	}
+	const leaf = path[path.length - 1];
+	assertSafePathSegment(leaf);
+	cursor[leaf] = true;
+	return node;
+}
+function mergeChanged(target, source) {
+	if (target === true || source === true) return true;
+	for (const key of Object.keys(source)) {
+		assertSafePathSegment(key);
+		const sChild = source[key];
+		const tChild = Object.hasOwn(target, key) ? target[key] : void 0;
+		target[key] = tChild === void 0 ? cloneChangeNode(sChild) : mergeChanged(tChild, sChild);
+	}
+	return target;
+}
+function cloneChangeNode(source) {
+	if (source === true) return true;
+	const clone = createChangeNode();
+	for (const key of Object.keys(source)) {
+		assertSafePathSegment(key);
+		clone[key] = cloneChangeNode(source[key]);
+	}
+	return clone;
+}
+function lookupChange(node, path) {
+	for (const key of path) {
+		if (node === true) return true;
+		const next = Object.hasOwn(node, key) ? node[key] : void 0;
+		if (next === void 0) return false;
+		node = next;
+	}
+	return node;
+}
+function lookupValue(state, path) {
+	let node = state;
+	for (const key of path) {
+		assertSafePathSegment(key);
+		if (typeof node !== "object" || node === null) return void 0;
+		node = Object.hasOwn(node, key) ? node[key] : void 0;
+	}
+	return node;
+}
+function diffKeys(newNode, oldNode) {
+	const newKeys = typeof newNode === "object" && newNode !== null ? Object.keys(newNode) : [];
+	const oldKeys = typeof oldNode === "object" && oldNode !== null ? Object.keys(oldNode) : [];
+	if (oldKeys.length === 0) return newKeys;
+	const newSet = new Set(newKeys);
+	const deletedKeys = oldKeys.filter((k) => !newSet.has(k)).reverse();
+	return [...newKeys, ...deletedKeys];
+}
+//#endregion
+export { assertSafePathSegment, createChangeNode, diffKeys, lookupChange, lookupValue, markChanged, mergeChanged };
+
+//# sourceMappingURL=changeTree.js.map

package/dist/core/gorp/changeTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"changeTree.js","names":[],"sources":["../../../src/core/gorp/changeTree.ts"],"sourcesContent":["export type ChangeNode = true | { [key: string]: ChangeNode };\n\nexport function createChangeNode(): { [key: string]: ChangeNode } {\n  return Object.create(null);\n}\n\nconst UNSAFE_PATH_SEGMENTS = new Set([\"__proto__\", \"constructor\", \"prototype\"]);\n\nexport function assertSafePathSegment(segment: string): void {\n  if (UNSAFE_PATH_SEGMENTS.has(segment)) {\n    throw new Error(`Unsafe gorp path segment: ${segment}`);\n  }\n}\n\nexport function markChanged(\n  node: ChangeNode,\n  path: readonly string[],\n): ChangeNode {\n  if (node === true || path.length === 0) return true;\n  let cursor = node;\n  for (let i = 0; i < path.length - 1; i++) {\n    const key = path[i]!;\n    assertSafePathSegment(key);\n    const next = Object.hasOwn(cursor, key) ? cursor[key] : undefined;\n    if (next === true) return node;\n    if (next === undefined) cursor[key] = createChangeNode();\n    cursor = cursor[key] as { [k: string]: ChangeNode };\n  }\n  const leaf = path[path.length - 1]!;\n  assertSafePathSegment(leaf);\n  cursor[leaf] = true;\n  return node;\n}\n\nexport function mergeChanged(\n  target: ChangeNode,\n  source: ChangeNode,\n): ChangeNode {\n  if (target === true || source === true) return true;\n  for (const key of Object.keys(source)) {\n    assertSafePathSegment(key);\n    const sChild = source[key]!;\n    const tChild = Object.hasOwn(target, key) ? target[key] : undefined;\n    target[key] =\n      tChild === undefined\n        ? cloneChangeNode(sChild)\n        : mergeChanged(tChild, sChild);\n  }\n  return target;\n}\n\nfunction cloneChangeNode(source: ChangeNode): ChangeNode {\n  if (source === true) return true;\n  const clone = createChangeNode();\n  for (const key of Object.keys(source)) {\n    assertSafePathSegment(key);\n    clone[key] = cloneChangeNode(source[key]!);\n  }\n  return clone;\n}\n\nexport function lookupChange(\n  node: ChangeNode,\n  path: readonly string[],\n): ChangeNode | false {\n  for (const key of path) {\n    if (node === true) return true;\n    const next = Object.hasOwn(node, key) ? node[key] : undefined;\n    if (next === undefined) return false;\n    node = next;\n  }\n  return node;\n}\n\nexport function lookupValue(state: unknown, path: readonly string[]): unknown {\n  let node = state;\n  for (const key of path) {\n    assertSafePathSegment(key);\n    if (typeof node !== \"object\" || node === null) return undefined;\n    node = Object.hasOwn(node, key)\n      ? (node as Record<string, unknown>)[key]\n      : undefined;\n  }\n  return node;\n}\n\nexport function diffKeys(newNode: unknown, oldNode: unknown): string[] {\n  const newKeys =\n    typeof newNode === \"object\" && newNode !== null ? Object.keys(newNode) : [];\n  const oldKeys =\n    typeof oldNode === \"object\" && oldNode !== null ? Object.keys(oldNode) : [];\n  if (oldKeys.length === 0) return newKeys;\n  const newSet = new Set(newKeys);\n  const deletedKeys = oldKeys.filter((k) => !newSet.has(k)).reverse();\n  return [...newKeys, ...deletedKeys];\n}\n"],"mappings":";AAEA,SAAgB,mBAAkD;CAChE,OAAO,OAAO,OAAO,IAAI;AAC3B;AAEA,MAAM,uCAAuB,IAAI,IAAI;CAAC;CAAa;CAAe;AAAW,CAAC;AAE9E,SAAgB,sBAAsB,SAAuB;CAC3D,IAAI,qBAAqB,IAAI,OAAO,GAClC,MAAM,IAAI,MAAM,6BAA6B,SAAS;AAE1D;AAEA,SAAgB,YACd,MACA,MACY;CACZ,IAAI,SAAS,QAAQ,KAAK,WAAW,GAAG,OAAO;CAC/C,IAAI,SAAS;CACb,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,SAAS,GAAG,KAAK;EACxC,MAAM,MAAM,KAAK;EACjB,sBAAsB,GAAG;EACzB,MAAM,OAAO,OAAO,OAAO,QAAQ,GAAG,IAAI,OAAO,OAAO,KAAA;EACxD,IAAI,SAAS,MAAM,OAAO;EAC1B,IAAI,SAAS,KAAA,GAAW,OAAO,OAAO,iBAAiB;EACvD,SAAS,OAAO;CAClB;CACA,MAAM,OAAO,KAAK,KAAK,SAAS;CAChC,sBAAsB,IAAI;CAC1B,OAAO,QAAQ;CACf,OAAO;AACT;AAEA,SAAgB,aACd,QACA,QACY;CACZ,IAAI,WAAW,QAAQ,WAAW,MAAM,OAAO;CAC/C,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,GAAG;EACrC,sBAAsB,GAAG;EACzB,MAAM,SAAS,OAAO;EACtB,MAAM,SAAS,OAAO,OAAO,QAAQ,GAAG,IAAI,OAAO,OAAO,KAAA;EAC1D,OAAO,OACL,WAAW,KAAA,IACP,gBAAgB,MAAM,IACtB,aAAa,QAAQ,MAAM;CACnC;CACA,OAAO;AACT;AAEA,SAAS,gBAAgB,QAAgC;CACvD,IAAI,WAAW,MAAM,OAAO;CAC5B,MAAM,QAAQ,iBAAiB;CAC/B,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,GAAG;EACrC,sBAAsB,GAAG;EACzB,MAAM,OAAO,gBAAgB,OAAO,IAAK;CAC3C;CACA,OAAO;AACT;AAEA,SAAgB,aACd,MACA,MACoB;CACpB,KAAK,MAAM,OAAO,MAAM;EACtB,IAAI,SAAS,MAAM,OAAO;EAC1B,MAAM,OAAO,OAAO,OAAO,MAAM,GAAG,IAAI,KAAK,OAAO,KAAA;EACpD,IAAI,SAAS,KAAA,GAAW,OAAO;EAC/B,OAAO;CACT;CACA,OAAO;AACT;AAEA,SAAgB,YAAY,OAAgB,MAAkC;CAC5E,IAAI,OAAO;CACX,KAAK,MAAM,OAAO,MAAM;EACtB,sBAAsB,GAAG;EACzB,IAAI,OAAO,SAAS,YAAY,SAAS,MAAM,OAAO,KAAA;EACtD,OAAO,OAAO,OAAO,MAAM,GAAG,IACzB,KAAiC,OAClC,KAAA;CACN;CACA,OAAO;AACT;AAEA,SAAgB,SAAS,SAAkB,SAA4B;CACrE,MAAM,UACJ,OAAO,YAAY,YAAY,YAAY,OAAO,OAAO,KAAK,OAAO,IAAI,CAAC;CAC5E,MAAM,UACJ,OAAO,YAAY,YAAY,YAAY,OAAO,OAAO,KAAK,OAAO,IAAI,CAAC;CAC5E,IAAI,QAAQ,WAAW,GAAG,OAAO;CACjC,MAAM,SAAS,IAAI,IAAI,OAAO;CAC9B,MAAM,cAAc,QAAQ,QAAQ,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ;CAClE,OAAO,CAAC,GAAG,SAAS,GAAG,WAAW;AACpC"}

package/dist/core/gorp/createGorpStream.d.ts

@@ -0,0 +1,16 @@
+import { ReadonlyJSONValue } from "../../utils/json/json-value.js";
+import "../../utils.js";
+import { GorpStreamChunk, GorpStreamOperation } from "./types.js";
+//#region src/core/gorp/createGorpStream.d.ts
+type GorpStreamController = {
+  readonly abortSignal: AbortSignal;
+  enqueue(operations: readonly GorpStreamOperation[]): void;
+};
+type CreateGorpStreamOptions = {
+  execute: (controller: GorpStreamController) => void | PromiseLike<void>;
+  defaultValue?: ReadonlyJSONValue;
+};
+declare const createGorpStream: ({ execute, defaultValue }: CreateGorpStreamOptions) => ReadableStream<GorpStreamChunk>;
+//#endregion
+export { createGorpStream };
+//# sourceMappingURL=createGorpStream.d.ts.map

package/dist/core/gorp/createGorpStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createGorpStream.d.ts","names":[],"sources":["../../../src/core/gorp/createGorpStream.ts"],"mappings":";;;;KAKK;WACM,aAAa;EAEtB,QAAQ,qBAAqB;;KA8D1B;EACH,UAAU,YAAY,gCAAgC;EACtD,eAAe;;cAGJ,qBAAoB,SAAA,gBAG9B,4BAAuB,eAAA"}

package/dist/core/{object/createObjectStream.js → gorp/createGorpStream.js}

@@ -1,18 +1,20 @@
-import { ObjectStreamAccumulator } from "./ObjectStreamAccumulator.js";
+import { GorpStreamAccumulator } from "./GorpStreamAccumulator.js";
 import { withPromiseOrValue } from "../utils/withPromiseOrValue.js";
-//#region src/core/object/createObjectStream.ts
-var ObjectStreamControllerImpl = class {
+//#region src/core/gorp/createGorpStream.ts
+var GorpStreamControllerImpl = class {
 	_controller;
 	_abortController = new AbortController();
 	_accumulator;
+	_cancelled = false;
 	get abortSignal() {
 		return this._abortController.signal;
 	}
 	constructor(controller, defaultValue) {
 		this._controller = controller;
-		this._accumulator = new ObjectStreamAccumulator(defaultValue);
+		this._accumulator = new GorpStreamAccumulator(defaultValue);
 	}
 	enqueue(operations) {
+		if (this._cancelled) return;
 		this._accumulator.append(operations);
 		this._controller.enqueue({
 			snapshot: this._accumulator.state,
@@ -20,12 +22,15 @@ var ObjectStreamControllerImpl = class {
 		});
 	}
 	__internalError(error) {
+		if (this._cancelled) return;
 		this._controller.error(error);
 	}
 	__internalClose() {
+		if (this._cancelled) return;
 		this._controller.close();
 	}
 	__internalCancel(reason) {
+		this._cancelled = true;
 		this._abortController.abort(reason);
 	}
 };
@@ -33,14 +38,14 @@ const getStreamControllerPair = (defaultValue) => {
 	let controller;
 	return [new ReadableStream({
 		start(c) {
-			controller = new ObjectStreamControllerImpl(c, defaultValue);
+			controller = new GorpStreamControllerImpl(c, defaultValue);
 		},
 		cancel(reason) {
 			controller.__internalCancel(reason);
 		}
 	}), controller];
 };
-const createObjectStream = ({ execute, defaultValue = {} }) => {
+const createGorpStream = ({ execute, defaultValue = {} }) => {
 	const [stream, controller] = getStreamControllerPair(defaultValue);
 	withPromiseOrValue(() => execute(controller), () => {
 		controller.__internalClose();
@@ -50,6 +55,6 @@ const createObjectStream = ({ execute, defaultValue = {} }) => {
 	return stream;
 };
 //#endregion
-export { createObjectStream };
+export { createGorpStream };
 
-//# sourceMappingURL=createObjectStream.js.map
+//# sourceMappingURL=createGorpStream.js.map

package/dist/core/gorp/createGorpStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createGorpStream.js","names":[],"sources":["../../../src/core/gorp/createGorpStream.ts"],"sourcesContent":["import type { ReadonlyJSONValue } from \"../../utils\";\nimport { withPromiseOrValue } from \"../utils/withPromiseOrValue\";\nimport { GorpStreamAccumulator } from \"./GorpStreamAccumulator\";\nimport type { GorpStreamOperation, GorpStreamChunk } from \"./types\";\n\ntype GorpStreamController = {\n  readonly abortSignal: AbortSignal;\n\n  enqueue(operations: readonly GorpStreamOperation[]): void;\n};\n\nclass GorpStreamControllerImpl implements GorpStreamController {\n  private _controller: ReadableStreamDefaultController<GorpStreamChunk>;\n  private _abortController = new AbortController();\n  private _accumulator: GorpStreamAccumulator;\n  private _cancelled = false;\n\n  get abortSignal() {\n    return this._abortController.signal;\n  }\n\n  constructor(\n    controller: ReadableStreamDefaultController<GorpStreamChunk>,\n    defaultValue: ReadonlyJSONValue,\n  ) {\n    this._controller = controller;\n    this._accumulator = new GorpStreamAccumulator(defaultValue);\n  }\n\n  enqueue(operations: readonly GorpStreamOperation[]) {\n    if (this._cancelled) return;\n\n    this._accumulator.append(operations);\n\n    this._controller.enqueue({\n      snapshot: this._accumulator.state,\n      operations,\n    });\n  }\n\n  __internalError(error: unknown) {\n    if (this._cancelled) return;\n    this._controller.error(error);\n  }\n\n  __internalClose() {\n    if (this._cancelled) return;\n    this._controller.close();\n  }\n\n  __internalCancel(reason?: unknown) {\n    this._cancelled = true;\n    this._abortController.abort(reason);\n  }\n}\n\nconst getStreamControllerPair = (defaultValue: ReadonlyJSONValue) => {\n  let controller!: GorpStreamControllerImpl;\n  const stream = new ReadableStream<GorpStreamChunk>({\n    start(c) {\n      controller = new GorpStreamControllerImpl(c, defaultValue);\n    },\n    cancel(reason: unknown) {\n      controller.__internalCancel(reason);\n    },\n  });\n\n  return [stream, controller] as const;\n};\n\ntype CreateGorpStreamOptions = {\n  execute: (controller: GorpStreamController) => void | PromiseLike<void>;\n  defaultValue?: ReadonlyJSONValue;\n};\n\nexport const createGorpStream = ({\n  execute,\n  defaultValue = {},\n}: CreateGorpStreamOptions) => {\n  const [stream, controller] = getStreamControllerPair(defaultValue);\n\n  withPromiseOrValue(\n    () => execute(controller),\n    () => {\n      controller.__internalClose();\n    },\n    (e: unknown) => {\n      controller.__internalError(e);\n    },\n  );\n\n  return stream;\n};\n"],"mappings":";;;AAWA,IAAM,2BAAN,MAA+D;CAC7D;CACA,mBAA2B,IAAI,gBAAgB;CAC/C;CACA,aAAqB;CAErB,IAAI,cAAc;EAChB,OAAO,KAAK,iBAAiB;CAC/B;CAEA,YACE,YACA,cACA;EACA,KAAK,cAAc;EACnB,KAAK,eAAe,IAAI,sBAAsB,YAAY;CAC5D;CAEA,QAAQ,YAA4C;EAClD,IAAI,KAAK,YAAY;EAErB,KAAK,aAAa,OAAO,UAAU;EAEnC,KAAK,YAAY,QAAQ;GACvB,UAAU,KAAK,aAAa;GAC5B;EACF,CAAC;CACH;CAEA,gBAAgB,OAAgB;EAC9B,IAAI,KAAK,YAAY;EACrB,KAAK,YAAY,MAAM,KAAK;CAC9B;CAEA,kBAAkB;EAChB,IAAI,KAAK,YAAY;EACrB,KAAK,YAAY,MAAM;CACzB;CAEA,iBAAiB,QAAkB;EACjC,KAAK,aAAa;EAClB,KAAK,iBAAiB,MAAM,MAAM;CACpC;AACF;AAEA,MAAM,2BAA2B,iBAAoC;CACnE,IAAI;CAUJ,OAAO,CAAC,IATW,eAAgC;EACjD,MAAM,GAAG;GACP,aAAa,IAAI,yBAAyB,GAAG,YAAY;EAC3D;EACA,OAAO,QAAiB;GACtB,WAAW,iBAAiB,MAAM;EACpC;CACF,CAEa,GAAG,UAAU;AAC5B;AAOA,MAAa,oBAAoB,EAC/B,SACA,eAAe,CAAC,QACa;CAC7B,MAAM,CAAC,QAAQ,cAAc,wBAAwB,YAAY;CAEjE,yBACQ,QAAQ,UAAU,SAClB;EACJ,WAAW,gBAAgB;CAC7B,IACC,MAAe;EACd,WAAW,gBAAgB,CAAC;CAC9B,CACF;CAEA,OAAO;AACT"}

package/dist/core/gorp/types.d.ts

@@ -0,0 +1,20 @@
+import { ReadonlyJSONValue } from "../../utils/json/json-value.js";
+import "../../utils.js";
+//#region src/core/gorp/types.d.ts
+type AssistantTransportStateOperation = {
+  readonly type: "set";
+  readonly path: readonly string[];
+  readonly value: ReadonlyJSONValue;
+} | {
+  readonly type: "append-text";
+  readonly path: readonly string[];
+  readonly value: string;
+};
+type GorpStreamOperation = AssistantTransportStateOperation;
+type GorpStreamChunk = {
+  readonly snapshot: ReadonlyJSONValue;
+  readonly operations: readonly GorpStreamOperation[];
+};
+//#endregion
+export { AssistantTransportStateOperation, GorpStreamChunk, GorpStreamOperation };
+//# sourceMappingURL=types.d.ts.map

package/dist/core/gorp/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/core/gorp/types.ts"],"mappings":";;;KAEY;WAEG;WACA;WACA,OAAO;;WAGP;WACA;WACA;;KAGH,sBAAsB;KAEtB;WACD,UAAU;WACV,qBAAqB"}

package/dist/core/modules/assistant-stream.d.ts

@@ -5,7 +5,6 @@ import { ToolCallStreamController } from "./tool-call.js";
 import { DataPart, FilePart, SourcePart } from "../utils/types.js";
 import { AssistantStreamChunk } from "../AssistantStreamChunk.js";
 import { AssistantStream } from "../AssistantStream.js";
-
 //#region src/core/modules/assistant-stream.d.ts
 type ToolCallPartInit = {
   toolCallId?: string;
@@ -22,10 +21,15 @@ type ToolCallPartInit = {
  * parts with `addTextPart` and `addToolCallPart` when you need direct control.
  */
 type AssistantStreamController = {
-  /** Appends text to the current text part, opening one if needed. */appendText(textDelta: string): void; /** Appends reasoning text to the current reasoning part, opening one if needed. */
-  appendReasoning(reasoningDelta: string): void; /** Appends a source citation part to the stream. */
-  appendSource(options: SourcePart): void; /** Appends a file part to the stream. */
-  appendFile(options: FilePart): void; /** Appends a named data part to the stream. */
+  /** Appends text to the current text part, opening one if needed. */
+  appendText(textDelta: string): void;
+  /** Appends reasoning text to the current reasoning part, opening one if needed. */
+  appendReasoning(reasoningDelta: string): void;
+  /** Appends a source citation part to the stream. */
+  appendSource(options: SourcePart): void;
+  /** Appends a file part to the stream. */
+  appendFile(options: FilePart): void;
+  /** Appends a named data part to the stream. */
   appendData(options: DataPart): void;
   /**
    * Opens a text part and returns its writer.
@@ -48,7 +52,8 @@ type AssistantStreamController = {
    * Use this overload to provide a stable `toolCallId`, initial arguments,
    * streamed argument text, or an immediate {@link ToolResponseLike}.
    */
-  addToolCallPart(options: ToolCallPartInit): ToolCallStreamController; /** Enqueues a raw protocol chunk. Prefer higher-level helpers when possible. */
+  addToolCallPart(options: ToolCallPartInit): ToolCallStreamController;
+  /** Enqueues a raw protocol chunk. Prefer higher-level helpers when possible. */
   enqueue(chunk: AssistantStreamChunk): void;
   /**
    * Merges another assistant stream into this stream.
@@ -56,7 +61,8 @@ type AssistantStreamController = {
    * Paths from the merged stream are remapped so its parts appear at the next
    * available position in this controller's output.
    */
-  merge(stream: AssistantStream): void; /** Closes any active part and finishes the stream. */
+  merge(stream: AssistantStream): void;
+  /** Closes any active part and finishes the stream. */
   close(): void;
   /**
    * Returns a controller that writes child parts with `parentId` attached.
@@ -70,10 +76,11 @@ type AssistantStreamController = {
  * Creates an {@link AssistantStream} and writes to it with an
  * {@link AssistantStreamController}.
  *
- * The callback may write synchronously or asynchronously. If it throws, an
- * `error` chunk is emitted before the error is rethrown; when the callback
- * settles, the stream is closed automatically unless the controller was
- * already closed.
+ * The callback may write synchronously or asynchronously. If it throws while
+ * the stream is open, an `error` chunk is emitted. Failures after an explicit
+ * close are logged, while failures after consumer cancellation are discarded.
+ * When the callback settles, the stream is closed automatically unless the
+ * controller was already closed.
  */
 declare function createAssistantStream(callback: (controller: AssistantStreamController) => PromiseLike<void> | void): AssistantStream;
 /**

package/dist/core/modules/assistant-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assistant-stream.d.ts","names":[],"sources":["../../../src/core/modules/assistant-stream.ts"],"mappings":";;;;;;;;;KAuBK,gBAAA;EACH,UAAA;EACA,QAAA;EACA,QAAA;EACA,IAAA,GAAO,kBAAA;EACP,QAAA,GAAW,gBAAA,CAAiB,iBAAA;AAAA;;;;;;;;KAUlB,yBAAA;EAVV,oEAYA,UAAA,CAAW,SAAA,iBAZiB;EAc5B,eAAA,CAAgB,cAAA,iBAd6B;EAgB7C,YAAA,CAAa,OAAA,EAAS,UAAA,SANa;EAQnC,UAAA,CAAW,OAAA,EAAS,QAAA,SAFE;EAItB,UAAA,CAAW,OAAA,EAAS,QAAA;EAAA;;;;;;;EAQpB,WAAA,IAAe,oBAAA;EAgC0C;;;;;;EAzBzD,eAAA,CAAgB,OAAA,WAAkB,wBAAA;EAnBZ;;;;;;EA0BtB,eAAA,CAAgB,OAAA,EAAS,gBAAA,GAAmB,wBAAA,EAtBjC;EAwBX,OAAA,CAAQ,KAAA,EAAO,oBAAA;EAhBA;;;;;;EAuBf,KAAA,CAAM,MAAA,EAAQ,eAAA,SAT8B;EAW5C,KAAA;EATe;;;;;;EAgBf,YAAA,CAAa,QAAA,WAAmB,yBAAA;AAAA;;;AAAyB;AA2M3D;;;;;;iBAAgB,qBAAA,CACd,QAAA,GAAW,UAAA,EAAY,yBAAA,KAA8B,WAAA,gBACpD,eAAA;;;;;;;;iBAiCa,+BAAA,cAA+B,eAAA,EAAA,yBAAA;AAA/C;;;;AAA+C;AAsB/C;;AAtBA,iBAsBgB,6BAAA,CACd,QAAA,GAAW,UAAA,EAAY,yBAAA,KAA8B,WAAA,gBAAwB,QAAA"}
+{"version":3,"file":"assistant-stream.d.ts","names":[],"sources":["../../../src/core/modules/assistant-stream.ts"],"mappings":";;;;;;;;KAuBK;EACH;EACA;EACA;EACA,OAAO;EACP,WAAW,iBAAiB;;;;;;;;;KAUlB;;EAEV,WAAW;;EAEX,gBAAgB;;EAEhB,aAAa,SAAS;;EAEtB,WAAW,SAAS;;EAEpB,WAAW,SAAS;;;;;;;;EAQpB,eAAe;;;;;;;EAOf,gBAAgB,kBAAkB;;;;;;;EAOlC,gBAAgB,SAAS,mBAAmB;;EAE5C,QAAQ,OAAO;;;;;;;EAOf,MAAM,QAAQ;;EAEd;;;;;;;EAOA,aAAa,mBAAmB;;;;;;;;;;;;iBAoNlB,sBACd,WAAW,YAAY,8BAA8B,2BACpD;;;;;;;;iBAkCa,6CAA+B,iBAAA;;;;;;;;iBAsB/B,8BACd,WAAW,YAAY,8BAA8B,2BAAwB"}

package/dist/core/modules/assistant-stream.js

@@ -18,7 +18,10 @@ var AssistantStreamControllerImpl = class AssistantStreamControllerImpl {
 		};
 	}
 	get __internal_isClosed() {
-		return this._state.merger.isSealed();
+		return this._state.merger.isSealed() || this._state.merger.isCancelled() || this._state.merger.isErrored();
+	}
+	get __internal_isCancelled() {
+		return this._state.merger.isCancelled();
 	}
 	__internal_getReadable() {
 		return this._state.merger.readable;
@@ -133,10 +136,11 @@ var AssistantStreamControllerImpl = class AssistantStreamControllerImpl {
 * Creates an {@link AssistantStream} and writes to it with an
 * {@link AssistantStreamController}.
 *
-* The callback may write synchronously or asynchronously. If it throws, an
-* `error` chunk is emitted before the error is rethrown; when the callback
-* settles, the stream is closed automatically unless the controller was
-* already closed.
+* The callback may write synchronously or asynchronously. If it throws while
+* the stream is open, an `error` chunk is emitted. Failures after an explicit
+* close are logged, while failures after consumer cancellation are discarded.
+* When the callback settles, the stream is closed automatically unless the
+* controller was already closed.
 */
 function createAssistantStream(callback) {
 	const controller = new AssistantStreamControllerImpl();
@@ -149,7 +153,7 @@ function createAssistantStream(callback) {
 				path: [],
 				error: String(e)
 			});
-			throw e;
+			else if (!controller.__internal_isCancelled) console.error(e);
 		} finally {
 			if (!controller.__internal_isClosed) controller.close();
 		}