agents 0.22.0 → 0.23.0

package/dist/text-stream-CpdiKrJB.js

@@ -0,0 +1,272 @@
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
+import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-qMjJ6sHQ.js";
+import { t as TextSegmentJoiner } from "./text-segment-joiner-BtAFQSA_.js";
+//#region src/voice/sentence-chunker.ts
+/**
+* Sentence chunker — accumulates streaming text and yields complete sentences.
+*
+* Isolated and testable: no dependencies on the voice pipeline, Agent, or AI APIs.
+* Feed it tokens via `add()`, get back sentences via the return value.
+* Call `flush()` at end-of-stream to get any remaining text.
+*
+* Current implementation: splits on sentence-ending punctuation (. ! ?) followed
+* by a space or end-of-input. This is intentionally simple — optimize later with
+* better heuristics (abbreviations, decimal numbers, quoted speech, etc.).
+*/
+/**
+* Punctuation characters that can end a sentence.
+*/
+const SENTENCE_TERMINATORS = /* @__PURE__ */ new Set([
+	".",
+	"!",
+	"?"
+]);
+/**
+* Minimum character count before we'll emit a sentence.
+* Prevents emitting fragments like "Dr." or "U.S." as standalone sentences,
+* while still allowing short responses like "Sure thing!" to stream quickly.
+*/
+const MIN_SENTENCE_LENGTH = 10;
+var _buffer = /* @__PURE__ */ new WeakMap();
+var _SentenceChunker_brand = /* @__PURE__ */ new WeakSet();
+var SentenceChunker = class {
+	constructor() {
+		_classPrivateMethodInitSpec(this, _SentenceChunker_brand);
+		_classPrivateFieldInitSpec(this, _buffer, "");
+	}
+	/**
+	* Add a chunk of text (e.g. a streamed LLM token).
+	* Returns an array of complete sentences extracted from the buffer.
+	* May return 0, 1, or multiple sentences depending on the input.
+	*/
+	add(text) {
+		_classPrivateFieldSet2(_buffer, this, _classPrivateFieldGet2(_buffer, this) + text);
+		return _assertClassBrand(_SentenceChunker_brand, this, _extractSentences).call(this);
+	}
+	/**
+	* Flush any remaining text in the buffer as a final sentence.
+	* Call this when the LLM stream ends.
+	* Returns the remaining text (trimmed), or an empty array if nothing is left.
+	*/
+	flush() {
+		const remaining = _classPrivateFieldGet2(_buffer, this).trim();
+		_classPrivateFieldSet2(_buffer, this, "");
+		if (remaining.length > 0) return [remaining];
+		return [];
+	}
+	/**
+	* Reset the chunker, discarding any buffered text.
+	*/
+	reset() {
+		_classPrivateFieldSet2(_buffer, this, "");
+	}
+};
+/**
+* Extract complete sentences from the buffer.
+* A sentence boundary is a terminator (. ! ?) followed by:
+* - a space and an uppercase letter (start of next sentence)
+* - a space and end of current buffer (likely a boundary)
+* - end of buffer after the terminator
+*
+* We leave ambiguous cases in the buffer until more text arrives.
+*/
+function _extractSentences() {
+	const sentences = [];
+	while (true) {
+		const boundary = _assertClassBrand(_SentenceChunker_brand, this, _findSentenceBoundary).call(this);
+		if (boundary === -1) break;
+		const sentence = _classPrivateFieldGet2(_buffer, this).slice(0, boundary + 1).trim();
+		_classPrivateFieldSet2(_buffer, this, _classPrivateFieldGet2(_buffer, this).slice(boundary + 1).trimStart());
+		if (sentence.length > 0) sentences.push(sentence);
+	}
+	return sentences;
+}
+/**
+* Find the index of the end of the first complete sentence in the buffer.
+* Returns -1 if no complete sentence boundary is found.
+*/
+function _findSentenceBoundary() {
+	for (let i = 0; i < _classPrivateFieldGet2(_buffer, this).length; i++) {
+		const char = _classPrivateFieldGet2(_buffer, this)[i];
+		if (!SENTENCE_TERMINATORS.has(char)) continue;
+		const nextChar = _classPrivateFieldGet2(_buffer, this)[i + 1];
+		if (nextChar === void 0) continue;
+		if (nextChar === " " || nextChar === "\n") {
+			if (_classPrivateFieldGet2(_buffer, this).slice(0, i + 1).trim().length >= MIN_SENTENCE_LENGTH) return i;
+		}
+	}
+	return -1;
+}
+//#endregion
+//#region src/voice/text-stream.ts
+const warnedTextStreamSources = /* @__PURE__ */ new WeakSet();
+/**
+* Turn any {@link TextSource} into a lazy async generator of string chunks.
+*
+* - `string` → yields the string once (if non-empty).
+* - `ReadableStream<string>` → yields each chunk directly.
+* - `ReadableStream<Uint8Array>` → decodes and parses as newline-delimited
+*   JSON (NDJSON) / SSE (`data: …` lines), extracting text from common AI
+*   response formats.
+* - `AsyncIterable<string>` → re-yields each chunk.
+*/
+async function* iterateText(source) {
+	for await (const event of iterateTextEvents(source)) if (event.type === "text") yield event.text;
+	else if (event.type === "error") throw toError(event.error);
+}
+async function* iterateTextEvents(source) {
+	if (typeof source === "string") {
+		if (source) yield textEvent(source);
+		return;
+	}
+	if (hasCustomAsyncIterator(source)) {
+		for await (const event of iterateAsyncTextEvents(source)) yield event;
+		return;
+	}
+	if (source instanceof ReadableStream) {
+		const reader = source.getReader();
+		const first = await reader.read();
+		if (first.done || first.value === void 0) return;
+		if (first.value instanceof Uint8Array) {
+			const peeked = first.value;
+			const combined = new ReadableStream({ async start(controller) {
+				controller.enqueue(peeked);
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					controller.enqueue(value);
+				}
+				controller.close();
+			} });
+			for await (const chunk of parseNDJSON(combined.getReader())) {
+				const ai = chunk;
+				if (ai.response) yield textEvent(ai.response);
+				else if (ai.choices && ai.choices.length > 0) {
+					const choice = ai.choices[0];
+					if (choice.delta?.content && choice.delta?.role === "assistant") yield textEvent(choice.delta.content);
+				}
+			}
+		} else for await (const event of iterateAsyncTextEvents(readWithFirst(first.value, reader))) yield event;
+		return;
+	}
+	if (Symbol.asyncIterator in source) for await (const event of iterateAsyncTextEvents(source)) yield event;
+}
+async function* readWithFirst(first, reader) {
+	yield first;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		yield value;
+	}
+}
+function hasCustomAsyncIterator(source) {
+	const iterator = source[Symbol.asyncIterator];
+	if (typeof iterator !== "function") return false;
+	if (!(source instanceof ReadableStream)) return true;
+	return Object.prototype.hasOwnProperty.call(source, Symbol.asyncIterator) || iterator !== ReadableStream.prototype[Symbol.asyncIterator];
+}
+async function* iterateAsyncTextEvents(source) {
+	const textSegmentJoiner = new TextSegmentJoiner();
+	for await (const value of source) {
+		if (typeof value === "string") {
+			warnDeprecatedTextStream(source);
+			if (value) yield textEvent(value);
+			continue;
+		}
+		if (!isRecord(value)) continue;
+		const chunk = value;
+		for (const event of textSegmentJoiner.pushChunk(chunk)) yield event;
+		switch (chunk.type) {
+			case "reasoning-start":
+			case "reasoning-end":
+				yield chunk;
+				break;
+			case "reasoning-delta": break;
+			case "finish":
+				yield chunk;
+				break;
+			case "error":
+				yield {
+					type: "error",
+					error: toError(chunk.error)
+				};
+				return;
+		}
+	}
+}
+function textEvent(text) {
+	return {
+		type: "text",
+		text
+	};
+}
+function warnDeprecatedTextStream(source) {
+	if (!source || !(source instanceof ReadableStream)) return;
+	if (warnedTextStreamSources.has(source)) return;
+	warnedTextStreamSources.add(source);
+	console.warn("[voice] AI SDK textStream is not recommended because non-adjacent text parts may be joined incorrectly. Return result.stream from onTurn() instead.");
+}
+function toError(error) {
+	if (error instanceof Error) return error;
+	if (typeof error === "string") return new Error(error);
+	return new Error("AI SDK stream error", { cause: error });
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Parse a `ReadableStream<Uint8Array>` that contains newline-delimited JSON
+* or Server-Sent Events (`data: {…}` lines).  Yields each parsed JSON object.
+*
+* Handles the `data: [DONE]` sentinel used by OpenAI-compatible APIs.
+*/
+async function* parseNDJSON(reader, leftOverBuffer = "") {
+	const decoder = new TextDecoder();
+	let buffer = leftOverBuffer;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		const lines = buffer.split("\n");
+		buffer = lines.pop() ?? "";
+		for (const line of lines) {
+			const parsed = parseLine(line);
+			if (parsed === "DONE") return;
+			if (parsed) yield parsed;
+		}
+	}
+	if (buffer.trim()) {
+		const remaining = buffer.split("\n").filter((l) => l.trim());
+		for (const line of remaining) {
+			const parsed = parseLine(line);
+			if (parsed === "DONE") return;
+			if (parsed) yield parsed;
+		}
+	}
+}
+function parseLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed) return null;
+	if (trimmed.startsWith("data:")) {
+		const json = trimmed.slice(5).trim();
+		if (json === "[DONE]") return "DONE";
+		try {
+			return JSON.parse(json);
+		} catch {
+			console.warn("[voice] Skipping malformed SSE data:", json);
+			return null;
+		}
+	}
+	if (trimmed === "[DONE]") return "DONE";
+	if (trimmed.startsWith(":") || trimmed.startsWith("event:") || trimmed.startsWith("id:") || trimmed.startsWith("retry:")) return null;
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		console.warn("[voice] Skipping malformed NDJSON line:", trimmed);
+		return null;
+	}
+}
+//#endregion
+export { iterateTextEvents as n, SentenceChunker as r, iterateText as t };
+
+//# sourceMappingURL=text-stream-CpdiKrJB.js.map

package/dist/text-stream-CpdiKrJB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-stream-CpdiKrJB.js","names":[],"sources":["../src/voice/sentence-chunker.ts","../src/voice/text-stream.ts"],"sourcesContent":["/**\n * Sentence chunker — accumulates streaming text and yields complete sentences.\n *\n * Isolated and testable: no dependencies on the voice pipeline, Agent, or AI APIs.\n * Feed it tokens via `add()`, get back sentences via the return value.\n * Call `flush()` at end-of-stream to get any remaining text.\n *\n * Current implementation: splits on sentence-ending punctuation (. ! ?) followed\n * by a space or end-of-input. This is intentionally simple — optimize later with\n * better heuristics (abbreviations, decimal numbers, quoted speech, etc.).\n */\n\n/**\n * Punctuation characters that can end a sentence.\n */\nconst SENTENCE_TERMINATORS = new Set([\".\", \"!\", \"?\"]);\n\n/**\n * Minimum character count before we'll emit a sentence.\n * Prevents emitting fragments like \"Dr.\" or \"U.S.\" as standalone sentences,\n * while still allowing short responses like \"Sure thing!\" to stream quickly.\n */\nconst MIN_SENTENCE_LENGTH = 10;\n\nexport class SentenceChunker {\n  #buffer = \"\";\n\n  /**\n   * Add a chunk of text (e.g. a streamed LLM token).\n   * Returns an array of complete sentences extracted from the buffer.\n   * May return 0, 1, or multiple sentences depending on the input.\n   */\n  add(text: string): string[] {\n    this.#buffer += text;\n    return this.#extractSentences();\n  }\n\n  /**\n   * Flush any remaining text in the buffer as a final sentence.\n   * Call this when the LLM stream ends.\n   * Returns the remaining text (trimmed), or an empty array if nothing is left.\n   */\n  flush(): string[] {\n    const remaining = this.#buffer.trim();\n    this.#buffer = \"\";\n    if (remaining.length > 0) {\n      return [remaining];\n    }\n    return [];\n  }\n\n  /**\n   * Reset the chunker, discarding any buffered text.\n   */\n  reset() {\n    this.#buffer = \"\";\n  }\n\n  /**\n   * Extract complete sentences from the buffer.\n   * A sentence boundary is a terminator (. ! ?) followed by:\n   * - a space and an uppercase letter (start of next sentence)\n   * - a space and end of current buffer (likely a boundary)\n   * - end of buffer after the terminator\n   *\n   * We leave ambiguous cases in the buffer until more text arrives.\n   */\n  #extractSentences(): string[] {\n    const sentences: string[] = [];\n\n    while (true) {\n      const boundary = this.#findSentenceBoundary();\n      if (boundary === -1) break;\n\n      const sentence = this.#buffer.slice(0, boundary + 1).trim();\n      this.#buffer = this.#buffer.slice(boundary + 1).trimStart();\n\n      if (sentence.length > 0) {\n        sentences.push(sentence);\n      }\n    }\n\n    return sentences;\n  }\n\n  /**\n   * Find the index of the end of the first complete sentence in the buffer.\n   * Returns -1 if no complete sentence boundary is found.\n   */\n  #findSentenceBoundary(): number {\n    for (let i = 0; i < this.#buffer.length; i++) {\n      const char = this.#buffer[i];\n\n      if (!SENTENCE_TERMINATORS.has(char)) continue;\n\n      // Check what follows the terminator\n      const nextChar = this.#buffer[i + 1];\n\n      // If this is the last character in the buffer, don't split yet —\n      // more text might follow (e.g. \"3.14\" or \"Dr. Smith\")\n      if (nextChar === undefined) continue;\n\n      // Terminator followed by space — likely a real sentence boundary\n      if (nextChar === \" \" || nextChar === \"\\n\") {\n        // But only if the sentence is long enough to be real\n        const candidate = this.#buffer.slice(0, i + 1).trim();\n        if (candidate.length >= MIN_SENTENCE_LENGTH) {\n          return i;\n        }\n      }\n    }\n\n    return -1;\n  }\n}\n","import { TextSegmentJoiner } from \"../chat/text-segment-joiner\";\nimport type { TextSegmentChunk } from \"../chat/text-segment-joiner\";\nimport type { VoiceModelFinishReason } from \"./types\";\n\n/**\n * Utilities for normalising various text-producing sources into a uniform\n * `AsyncGenerator<string>`.  This lets `onTurn()` return any of:\n *\n *   - A plain `string`\n *   - An `AsyncIterable<string>` (deprecated for AI SDK `textStream`)\n *   - An `AsyncIterable` of AI SDK `stream` parts\n *   - A `ReadableStream<Uint8Array>` (e.g. a raw `fetch` response body\n *     containing newline-delimited JSON / SSE)\n *   - A `ReadableStream<string>`\n *\n * The generator yields individual text chunks as they become available.\n */\n\n/** Union of every source type that {@link iterateText} accepts. */\nexport type TextSource = string | TextReadableStream | AsyncIterable<unknown>;\n\n/** @internal Semantic events retained while normalizing model streams. */\nexport type TextStreamEvent =\n  | { type: \"text\"; text: string }\n  | { type: \"boundary\" }\n  | { type: \"reasoning-start\" }\n  | { type: \"reasoning-end\" }\n  | { type: \"finish\"; finishReason: VoiceModelFinishReason }\n  | { type: \"error\"; error: Error };\n\ntype TextReadableStreamReader = {\n  read(): Promise<ReadableStreamReadResult<unknown>>;\n};\n\ninterface TextReadableStream {\n  getReader(): TextReadableStreamReader;\n}\n\n/** Shape of a parsed NDJSON/SSE chunk from common AI APIs. */\ninterface AIStreamChunk {\n  response?: string;\n  choices?: {\n    delta?: { content?: string; role?: string };\n  }[];\n}\n\ninterface StructuredStreamChunk extends TextSegmentChunk {\n  type?: string;\n  error?: unknown;\n  finishReason?: VoiceModelFinishReason;\n}\n\nconst warnedTextStreamSources = new WeakSet<object>();\n\n/**\n * Turn any {@link TextSource} into a lazy async generator of string chunks.\n *\n * - `string` → yields the string once (if non-empty).\n * - `ReadableStream<string>` → yields each chunk directly.\n * - `ReadableStream<Uint8Array>` → decodes and parses as newline-delimited\n *   JSON (NDJSON) / SSE (`data: …` lines), extracting text from common AI\n *   response formats.\n * - `AsyncIterable<string>` → re-yields each chunk.\n */\nexport async function* iterateText(source: TextSource): AsyncGenerator<string> {\n  for await (const event of iterateTextEvents(source)) {\n    if (event.type === \"text\") {\n      yield event.text;\n    } else if (event.type === \"error\") {\n      throw toError(event.error);\n    }\n  }\n}\n\nexport async function* iterateTextEvents(\n  source: TextSource\n): AsyncGenerator<TextStreamEvent> {\n  // --- plain string ---\n  if (typeof source === \"string\") {\n    if (source) yield textEvent(source);\n    return;\n  }\n\n  // --- Custom AsyncIterable ---\n  // AI SDK textStream/stream are ReadableStreams with custom async\n  // iterators. Prefer those custom iterators before the generic ReadableStream\n  // parser, while still letting native ReadableStream async iteration fall\n  // through to the stream-specific branches below.\n  if (hasCustomAsyncIterator(source)) {\n    for await (const event of iterateAsyncTextEvents(\n      source as AsyncIterable<unknown>\n    )) {\n      yield event;\n    }\n    return;\n  }\n\n  // --- ReadableStream ---\n  if (source instanceof ReadableStream) {\n    const reader = source.getReader();\n\n    const first = await reader.read();\n    if (first.done || first.value === undefined) return;\n\n    if (first.value instanceof Uint8Array) {\n      // ReadableStream<Uint8Array> — re-assemble into an NDJSON stream\n      // by pushing the already-read first chunk back into a new stream.\n      const peeked = first.value as Uint8Array;\n      const combined = new ReadableStream<Uint8Array>({\n        async start(controller) {\n          controller.enqueue(peeked);\n          while (true) {\n            const { done, value } = await reader.read();\n            if (done) break;\n            controller.enqueue(value as Uint8Array);\n          }\n          controller.close();\n        }\n      });\n\n      for await (const chunk of parseNDJSON(combined.getReader())) {\n        const ai = chunk as AIStreamChunk;\n        if (ai.response) {\n          yield textEvent(ai.response);\n        } else if (ai.choices && ai.choices.length > 0) {\n          const choice = ai.choices[0];\n          if (choice.delta?.content && choice.delta?.role === \"assistant\") {\n            yield textEvent(choice.delta.content);\n          }\n        }\n      }\n    } else {\n      for await (const event of iterateAsyncTextEvents(\n        readWithFirst(first.value, reader)\n      )) {\n        yield event;\n      }\n    }\n    return;\n  }\n\n  // --- AsyncIterable ---\n  if (Symbol.asyncIterator in source) {\n    for await (const event of iterateAsyncTextEvents(source)) {\n      yield event;\n    }\n  }\n}\n\nasync function* readWithFirst(\n  first: unknown,\n  reader: TextReadableStreamReader\n): AsyncGenerator<unknown> {\n  yield first;\n\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    yield value;\n  }\n}\n\nfunction hasCustomAsyncIterator(source: Exclude<TextSource, string>): boolean {\n  const iterator = (source as Partial<AsyncIterable<unknown>>)[\n    Symbol.asyncIterator\n  ];\n\n  if (typeof iterator !== \"function\") return false;\n\n  if (!(source instanceof ReadableStream)) return true;\n\n  return (\n    Object.prototype.hasOwnProperty.call(source, Symbol.asyncIterator) ||\n    iterator !==\n      (ReadableStream.prototype as Partial<AsyncIterable<unknown>>)[\n        Symbol.asyncIterator\n      ]\n  );\n}\n\nasync function* iterateAsyncTextEvents(\n  source: AsyncIterable<unknown>\n): AsyncGenerator<TextStreamEvent> {\n  const textSegmentJoiner = new TextSegmentJoiner();\n\n  for await (const value of source) {\n    if (typeof value === \"string\") {\n      warnDeprecatedTextStream(source);\n      if (value) yield textEvent(value);\n      continue;\n    }\n\n    if (!isRecord(value)) continue;\n    const chunk = value as StructuredStreamChunk;\n\n    for (const event of textSegmentJoiner.pushChunk(chunk)) {\n      yield event;\n    }\n\n    switch (chunk.type) {\n      case \"reasoning-start\":\n      case \"reasoning-end\":\n        yield chunk as TextStreamEvent;\n        break;\n      case \"reasoning-delta\":\n        break;\n      case \"finish\":\n        yield chunk as TextStreamEvent;\n        break;\n      case \"error\":\n        yield { type: \"error\", error: toError(chunk.error) };\n        return;\n    }\n  }\n}\n\nfunction textEvent(text: string): TextStreamEvent {\n  return { type: \"text\", text };\n}\n\nfunction warnDeprecatedTextStream(source?: object): void {\n  if (!source || !(source instanceof ReadableStream)) return;\n  if (warnedTextStreamSources.has(source)) return;\n  warnedTextStreamSources.add(source);\n\n  console.warn(\n    \"[voice] AI SDK textStream is not recommended because non-adjacent text parts may be joined incorrectly. Return result.stream from onTurn() instead.\"\n  );\n}\n\nfunction toError(error: unknown): Error {\n  if (error instanceof Error) return error;\n  if (typeof error === \"string\") return new Error(error);\n  return new Error(\"AI SDK stream error\", { cause: error });\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null;\n}\n\n// ---------------------------------------------------------------------------\n// Internal: NDJSON / SSE stream parser\n// ---------------------------------------------------------------------------\n\n/**\n * Parse a `ReadableStream<Uint8Array>` that contains newline-delimited JSON\n * or Server-Sent Events (`data: {…}` lines).  Yields each parsed JSON object.\n *\n * Handles the `data: [DONE]` sentinel used by OpenAI-compatible APIs.\n */\nasync function* parseNDJSON(\n  reader: ReadableStreamDefaultReader<Uint8Array>,\n  leftOverBuffer = \"\"\n): AsyncGenerator<Record<string, unknown>> {\n  const decoder = new TextDecoder();\n  let buffer = leftOverBuffer;\n\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n\n    buffer += decoder.decode(value, { stream: true });\n\n    const lines = buffer.split(\"\\n\");\n    buffer = lines.pop() ?? \"\";\n\n    for (const line of lines) {\n      const parsed = parseLine(line);\n      if (parsed === \"DONE\") return;\n      if (parsed) yield parsed;\n    }\n  }\n\n  // Flush remaining buffer\n  if (buffer.trim()) {\n    const remaining = buffer.split(\"\\n\").filter((l) => l.trim());\n    for (const line of remaining) {\n      const parsed = parseLine(line);\n      if (parsed === \"DONE\") return;\n      if (parsed) yield parsed;\n    }\n  }\n}\n\nfunction parseLine(line: string): Record<string, unknown> | \"DONE\" | null {\n  const trimmed = line.trim();\n  if (!trimmed) return null;\n\n  if (trimmed.startsWith(\"data:\")) {\n    const json = trimmed.slice(5).trim();\n    if (json === \"[DONE]\") return \"DONE\";\n    try {\n      return JSON.parse(json) as Record<string, unknown>;\n    } catch {\n      console.warn(\"[voice] Skipping malformed SSE data:\", json);\n      return null;\n    }\n  }\n\n  if (trimmed === \"[DONE]\") return \"DONE\";\n\n  // Ignore SSE metadata/comment lines. Only `data:` carries payload.\n  if (\n    trimmed.startsWith(\":\") ||\n    trimmed.startsWith(\"event:\") ||\n    trimmed.startsWith(\"id:\") ||\n    trimmed.startsWith(\"retry:\")\n  ) {\n    return null;\n  }\n\n  try {\n    return JSON.parse(trimmed) as Record<string, unknown>;\n  } catch {\n    console.warn(\"[voice] Skipping malformed NDJSON line:\", trimmed);\n    return null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAeA,MAAM,uCAAuB,IAAI,IAAI;CAAC;CAAK;CAAK;AAAG,CAAC;;;;;;AAOpD,MAAM,sBAAsB;;;AAE5B,IAAa,kBAAb,MAA6B;;;4CACjB,EAAA;;;;;;;CAOV,IAAI,MAAwB;EAC1B,uBAAA,SAAA,MAAA,uBAAA,SAAA,IAAA,IAAgB,IAAA;EAChB,OAAA,kBAAA,wBAAO,MAAA,iBAAA,CAAA,CAAA,KAAA,IAAuB;CAChC;;;;;;CAOA,QAAkB;EAChB,MAAM,YAAA,uBAAA,SAAY,IAAA,CAAA,CAAa,KAAK;EACpC,uBAAA,SAAA,MAAe,EAAA;EACf,IAAI,UAAU,SAAS,GACrB,OAAO,CAAC,SAAS;EAEnB,OAAO,CAAC;CACV;;;;CAKA,QAAQ;EACN,uBAAA,SAAA,MAAe,EAAA;CACjB;AA0DF;;;;;;;;;;AA/CE,SAAA,oBAA8B;CAC5B,MAAM,YAAsB,CAAC;CAE7B,OAAO,MAAM;EACX,MAAM,WAAA,kBAAA,wBAAW,MAAA,qBAAA,CAAA,CAAA,KAAA,IAA2B;EAC5C,IAAI,aAAa,IAAI;EAErB,MAAM,WAAA,uBAAA,SAAW,IAAA,CAAA,CAAa,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK;EAC1D,uBAAA,SAAA,MAAA,uBAAA,SAAe,IAAA,CAAA,CAAa,MAAM,WAAW,CAAC,CAAC,CAAC,UAAU,CAAA;EAE1D,IAAI,SAAS,SAAS,GACpB,UAAU,KAAK,QAAQ;CAE3B;CAEA,OAAO;AACT;;;;;AAMA,SAAA,wBAAgC;CAC9B,KAAK,IAAI,IAAI,GAAG,IAAA,uBAAA,SAAI,IAAA,CAAA,CAAa,QAAQ,KAAK;EAC5C,MAAM,OAAA,uBAAA,SAAO,IAAA,CAAA,CAAa;EAE1B,IAAI,CAAC,qBAAqB,IAAI,IAAI,GAAG;EAGrC,MAAM,WAAA,uBAAA,SAAW,IAAA,CAAA,CAAa,IAAI;EAIlC,IAAI,aAAa,KAAA,GAAW;EAG5B,IAAI,aAAa,OAAO,aAAa;uCAEjB,IAAA,CAAA,CAAa,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,KACnC,CAAC,CAAC,UAAU,qBACtB,OAAO;EAAA;CAGb;CAEA,OAAO;AACT;;;AC7DF,MAAM,0CAA0B,IAAI,QAAgB;;;;;;;;;;;AAYpD,gBAAuB,YAAY,QAA4C;CAC7E,WAAW,MAAM,SAAS,kBAAkB,MAAM,GAChD,IAAI,MAAM,SAAS,QACjB,MAAM,MAAM;MACP,IAAI,MAAM,SAAS,SACxB,MAAM,QAAQ,MAAM,KAAK;AAG/B;AAEA,gBAAuB,kBACrB,QACiC;CAEjC,IAAI,OAAO,WAAW,UAAU;EAC9B,IAAI,QAAQ,MAAM,UAAU,MAAM;EAClC;CACF;CAOA,IAAI,uBAAuB,MAAM,GAAG;EAClC,WAAW,MAAM,SAAS,uBACxB,MACF,GACE,MAAM;EAER;CACF;CAGA,IAAI,kBAAkB,gBAAgB;EACpC,MAAM,SAAS,OAAO,UAAU;EAEhC,MAAM,QAAQ,MAAM,OAAO,KAAK;EAChC,IAAI,MAAM,QAAQ,MAAM,UAAU,KAAA,GAAW;EAE7C,IAAI,MAAM,iBAAiB,YAAY;GAGrC,MAAM,SAAS,MAAM;GACrB,MAAM,WAAW,IAAI,eAA2B,EAC9C,MAAM,MAAM,YAAY;IACtB,WAAW,QAAQ,MAAM;IACzB,OAAO,MAAM;KACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,KAAK;KAC1C,IAAI,MAAM;KACV,WAAW,QAAQ,KAAmB;IACxC;IACA,WAAW,MAAM;GACnB,EACF,CAAC;GAED,WAAW,MAAM,SAAS,YAAY,SAAS,UAAU,CAAC,GAAG;IAC3D,MAAM,KAAK;IACX,IAAI,GAAG,UACL,MAAM,UAAU,GAAG,QAAQ;SACtB,IAAI,GAAG,WAAW,GAAG,QAAQ,SAAS,GAAG;KAC9C,MAAM,SAAS,GAAG,QAAQ;KAC1B,IAAI,OAAO,OAAO,WAAW,OAAO,OAAO,SAAS,aAClD,MAAM,UAAU,OAAO,MAAM,OAAO;IAExC;GACF;EACF,OACE,WAAW,MAAM,SAAS,uBACxB,cAAc,MAAM,OAAO,MAAM,CACnC,GACE,MAAM;EAGV;CACF;CAGA,IAAI,OAAO,iBAAiB,QAC1B,WAAW,MAAM,SAAS,uBAAuB,MAAM,GACrD,MAAM;AAGZ;AAEA,gBAAgB,cACd,OACA,QACyB;CACzB,MAAM;CAEN,OAAO,MAAM;EACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,KAAK;EAC1C,IAAI,MAAM;EACV,MAAM;CACR;AACF;AAEA,SAAS,uBAAuB,QAA8C;CAC5E,MAAM,WAAY,OAChB,OAAO;CAGT,IAAI,OAAO,aAAa,YAAY,OAAO;CAE3C,IAAI,EAAE,kBAAkB,iBAAiB,OAAO;CAEhD,OACE,OAAO,UAAU,eAAe,KAAK,QAAQ,OAAO,aAAa,KACjE,aACG,eAAe,UACd,OAAO;AAGf;AAEA,gBAAgB,uBACd,QACiC;CACjC,MAAM,oBAAoB,IAAI,kBAAkB;CAEhD,WAAW,MAAM,SAAS,QAAQ;EAChC,IAAI,OAAO,UAAU,UAAU;GAC7B,yBAAyB,MAAM;GAC/B,IAAI,OAAO,MAAM,UAAU,KAAK;GAChC;EACF;EAEA,IAAI,CAAC,SAAS,KAAK,GAAG;EACtB,MAAM,QAAQ;EAEd,KAAK,MAAM,SAAS,kBAAkB,UAAU,KAAK,GACnD,MAAM;EAGR,QAAQ,MAAM,MAAd;GACE,KAAK;GACL,KAAK;IACH,MAAM;IACN;GACF,KAAK,mBACH;GACF,KAAK;IACH,MAAM;IACN;GACF,KAAK;IACH,MAAM;KAAE,MAAM;KAAS,OAAO,QAAQ,MAAM,KAAK;IAAE;IACnD;EACJ;CACF;AACF;AAEA,SAAS,UAAU,MAA+B;CAChD,OAAO;EAAE,MAAM;EAAQ;CAAK;AAC9B;AAEA,SAAS,yBAAyB,QAAuB;CACvD,IAAI,CAAC,UAAU,EAAE,kBAAkB,iBAAiB;CACpD,IAAI,wBAAwB,IAAI,MAAM,GAAG;CACzC,wBAAwB,IAAI,MAAM;CAElC,QAAQ,KACN,qJACF;AACF;AAEA,SAAS,QAAQ,OAAuB;CACtC,IAAI,iBAAiB,OAAO,OAAO;CACnC,IAAI,OAAO,UAAU,UAAU,OAAO,IAAI,MAAM,KAAK;CACrD,OAAO,IAAI,MAAM,uBAAuB,EAAE,OAAO,MAAM,CAAC;AAC1D;AAEA,SAAS,SAAS,OAAkD;CAClE,OAAO,OAAO,UAAU,YAAY,UAAU;AAChD;;;;;;;AAYA,gBAAgB,YACd,QACA,iBAAiB,IACwB;CACzC,MAAM,UAAU,IAAI,YAAY;CAChC,IAAI,SAAS;CAEb,OAAO,MAAM;EACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,KAAK;EAC1C,IAAI,MAAM;EAEV,UAAU,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC;EAEhD,MAAM,QAAQ,OAAO,MAAM,IAAI;EAC/B,SAAS,MAAM,IAAI,KAAK;EAExB,KAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,SAAS,UAAU,IAAI;GAC7B,IAAI,WAAW,QAAQ;GACvB,IAAI,QAAQ,MAAM;EACpB;CACF;CAGA,IAAI,OAAO,KAAK,GAAG;EACjB,MAAM,YAAY,OAAO,MAAM,IAAI,CAAC,CAAC,QAAQ,MAAM,EAAE,KAAK,CAAC;EAC3D,KAAK,MAAM,QAAQ,WAAW;GAC5B,MAAM,SAAS,UAAU,IAAI;GAC7B,IAAI,WAAW,QAAQ;GACvB,IAAI,QAAQ,MAAM;EACpB;CACF;AACF;AAEA,SAAS,UAAU,MAAuD;CACxE,MAAM,UAAU,KAAK,KAAK;CAC1B,IAAI,CAAC,SAAS,OAAO;CAErB,IAAI,QAAQ,WAAW,OAAO,GAAG;EAC/B,MAAM,OAAO,QAAQ,MAAM,CAAC,CAAC,CAAC,KAAK;EACnC,IAAI,SAAS,UAAU,OAAO;EAC9B,IAAI;GACF,OAAO,KAAK,MAAM,IAAI;EACxB,QAAQ;GACN,QAAQ,KAAK,wCAAwC,IAAI;GACzD,OAAO;EACT;CACF;CAEA,IAAI,YAAY,UAAU,OAAO;CAGjC,IACE,QAAQ,WAAW,GAAG,KACtB,QAAQ,WAAW,QAAQ,KAC3B,QAAQ,WAAW,KAAK,KACxB,QAAQ,WAAW,QAAQ,GAE3B,OAAO;CAGT,IAAI;EACF,OAAO,KAAK,MAAM,OAAO;CAC3B,QAAQ;EACN,QAAQ,KAAK,2CAA2C,OAAO;EAC/D,OAAO;CACT;AACF"}

package/dist/tokens-nHAKcN6M.js

@@ -0,0 +1,52 @@
+/** Approximate token multiplier per whitespace-separated word */
+const WORDS_TOKEN_MULTIPLIER = 1.3;
+/** Flat token charge for an image attachment (vision-model ballpark). */
+const IMAGE_ATTACHMENT_TOKENS = 1600;
+/** Ceiling for a non-image attachment's bytes/4 token charge. */
+const MAX_ATTACHMENT_TOKENS = 2e4;
+function estimateStringTokens(text) {
+	if (!text) return 0;
+	const charEstimate = text.length / 4;
+	const wordEstimate = text.split(/\s+/).filter(Boolean).length * WORDS_TOKEN_MULTIPLIER;
+	return Math.ceil(Math.max(charEstimate, wordEstimate));
+}
+function estimateUnknownTokens(value) {
+	if (value === null || value === void 0) return 0;
+	if (typeof value === "string") return estimateStringTokens(value);
+	try {
+		return estimateStringTokens(JSON.stringify(value));
+	} catch {
+		return estimateStringTokens(String(value));
+	}
+}
+/** Estimate tokens for messages from their text, reasoning, and tool parts. */
+function estimateMessageTokens(messages) {
+	let tokens = 0;
+	for (const msg of messages) {
+		tokens += 4;
+		for (const part of msg.parts) if (part.type === "text" || part.type === "reasoning") tokens += estimateUnknownTokens(part.text ?? part.reasoning);
+		else if (part.type.startsWith("tool-") || part.type === "dynamic-tool") {
+			tokens += estimateUnknownTokens(part.input);
+			tokens += estimateUnknownTokens(part.output ?? part.result);
+		} else if (part.text !== void 0) tokens += estimateUnknownTokens(part.text);
+		else if (part.result !== void 0) tokens += estimateUnknownTokens(part.result);
+	}
+	return tokens;
+}
+/** Heuristic token weight of one attachment so media never counts as zero. */
+function estimateAttachmentTokens(mediaType, bytes) {
+	if (mediaType.startsWith("image/")) return IMAGE_ATTACHMENT_TOKENS;
+	return Math.min(Math.ceil(bytes / 4), MAX_ATTACHMENT_TOKENS);
+}
+/** Approximate decoded size of a `data:` URL without decoding it. */
+function estimatedDataUrlBytes(url) {
+	const comma = url.indexOf(",");
+	if (!url.startsWith("data:") || comma < 0) return 0;
+	const header = url.slice(5, comma);
+	const payload = url.slice(comma + 1);
+	return header.endsWith(";base64") ? Math.floor(payload.length * 3 / 4) : payload.length;
+}
+//#endregion
+export { estimatedDataUrlBytes as i, estimateMessageTokens as n, estimateStringTokens as r, estimateAttachmentTokens as t };
+
+//# sourceMappingURL=tokens-nHAKcN6M.js.map

package/dist/tokens-nHAKcN6M.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens-nHAKcN6M.js","names":[],"sources":["../src/sessions/tokens.ts"],"sourcesContent":["/**\n * Token estimation heuristics.\n *\n * Real tokenizers cost ~100 MB of heap, so Sessions estimates: the larger of\n * ~4 characters per token and ~1.3 tokens per word, plus a small per-message\n * framing charge. Attachments get a flat image charge or a bytes/4 charge\n * capped so a large document cannot dominate a compaction trigger. These\n * numbers gate cheap triggers only; model-reported usage stays authoritative.\n */\n\nimport type { SessionMessage } from \"./types\";\n\n/** Approximate characters per token for English text */\nexport const CHARS_PER_TOKEN = 4;\n\n/** Approximate token multiplier per whitespace-separated word */\nexport const WORDS_TOKEN_MULTIPLIER = 1.3;\n\n/** Approximate overhead tokens per message (role, framing) */\nexport const TOKENS_PER_MESSAGE = 4;\n\n/** Flat token charge for an image attachment (vision-model ballpark). */\nexport const IMAGE_ATTACHMENT_TOKENS = 1_600;\n\n/** Ceiling for a non-image attachment's bytes/4 token charge. */\nexport const MAX_ATTACHMENT_TOKENS = 20_000;\n\nexport function estimateStringTokens(text: string): number {\n  if (!text) return 0;\n  const charEstimate = text.length / CHARS_PER_TOKEN;\n  const wordEstimate =\n    text.split(/\\s+/).filter(Boolean).length * WORDS_TOKEN_MULTIPLIER;\n  return Math.ceil(Math.max(charEstimate, wordEstimate));\n}\n\nfunction estimateUnknownTokens(value: unknown): number {\n  if (value === null || value === undefined) return 0;\n  if (typeof value === \"string\") return estimateStringTokens(value);\n  try {\n    return estimateStringTokens(JSON.stringify(value));\n  } catch {\n    return estimateStringTokens(String(value));\n  }\n}\n\n/** Estimate tokens for messages from their text, reasoning, and tool parts. */\nexport function estimateMessageTokens(messages: SessionMessage[]): number {\n  let tokens = 0;\n  for (const msg of messages) {\n    tokens += TOKENS_PER_MESSAGE;\n    for (const part of msg.parts) {\n      if (part.type === \"text\" || part.type === \"reasoning\") {\n        tokens += estimateUnknownTokens(part.text ?? part.reasoning);\n      } else if (\n        part.type.startsWith(\"tool-\") ||\n        part.type === \"dynamic-tool\"\n      ) {\n        tokens += estimateUnknownTokens(part.input);\n        tokens += estimateUnknownTokens(part.output ?? part.result);\n      } else if (part.text !== undefined) {\n        tokens += estimateUnknownTokens(part.text);\n      } else if (part.result !== undefined) {\n        tokens += estimateUnknownTokens(part.result);\n      }\n    }\n  }\n  return tokens;\n}\n\n/** Heuristic token weight of one attachment so media never counts as zero. */\nexport function estimateAttachmentTokens(\n  mediaType: string,\n  bytes: number\n): number {\n  if (mediaType.startsWith(\"image/\")) return IMAGE_ATTACHMENT_TOKENS;\n  return Math.min(Math.ceil(bytes / 4), MAX_ATTACHMENT_TOKENS);\n}\n\n/** Approximate decoded size of a `data:` URL without decoding it. */\nexport function estimatedDataUrlBytes(url: string): number {\n  const comma = url.indexOf(\",\");\n  if (!url.startsWith(\"data:\") || comma < 0) return 0;\n  const header = url.slice(\"data:\".length, comma);\n  const payload = url.slice(comma + 1);\n  return header.endsWith(\";base64\")\n    ? Math.floor((payload.length * 3) / 4)\n    : payload.length;\n}\n"],"mappings":";AAgBA,MAAa,yBAAyB;;AAMtC,MAAa,0BAA0B;;AAGvC,MAAa,wBAAwB;AAErC,SAAgB,qBAAqB,MAAsB;CACzD,IAAI,CAAC,MAAM,OAAO;CAClB,MAAM,eAAe,KAAK,SAAA;CAC1B,MAAM,eACJ,KAAK,MAAM,KAAK,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,SAAS;CAC7C,OAAO,KAAK,KAAK,KAAK,IAAI,cAAc,YAAY,CAAC;AACvD;AAEA,SAAS,sBAAsB,OAAwB;CACrD,IAAI,UAAU,QAAQ,UAAU,KAAA,GAAW,OAAO;CAClD,IAAI,OAAO,UAAU,UAAU,OAAO,qBAAqB,KAAK;CAChE,IAAI;EACF,OAAO,qBAAqB,KAAK,UAAU,KAAK,CAAC;CACnD,QAAQ;EACN,OAAO,qBAAqB,OAAO,KAAK,CAAC;CAC3C;AACF;;AAGA,SAAgB,sBAAsB,UAAoC;CACxE,IAAI,SAAS;CACb,KAAK,MAAM,OAAO,UAAU;EAC1B,UAAA;EACA,KAAK,MAAM,QAAQ,IAAI,OACrB,IAAI,KAAK,SAAS,UAAU,KAAK,SAAS,aACxC,UAAU,sBAAsB,KAAK,QAAQ,KAAK,SAAS;OACtD,IACL,KAAK,KAAK,WAAW,OAAO,KAC5B,KAAK,SAAS,gBACd;GACA,UAAU,sBAAsB,KAAK,KAAK;GAC1C,UAAU,sBAAsB,KAAK,UAAU,KAAK,MAAM;EAC5D,OAAO,IAAI,KAAK,SAAS,KAAA,GACvB,UAAU,sBAAsB,KAAK,IAAI;OACpC,IAAI,KAAK,WAAW,KAAA,GACzB,UAAU,sBAAsB,KAAK,MAAM;CAGjD;CACA,OAAO;AACT;;AAGA,SAAgB,yBACd,WACA,OACQ;CACR,IAAI,UAAU,WAAW,QAAQ,GAAG,OAAO;CAC3C,OAAO,KAAK,IAAI,KAAK,KAAK,QAAQ,CAAC,GAAG,qBAAqB;AAC7D;;AAGA,SAAgB,sBAAsB,KAAqB;CACzD,MAAM,QAAQ,IAAI,QAAQ,GAAG;CAC7B,IAAI,CAAC,IAAI,WAAW,OAAO,KAAK,QAAQ,GAAG,OAAO;CAClD,MAAM,SAAS,IAAI,MAAM,GAAgB,KAAK;CAC9C,MAAM,UAAU,IAAI,MAAM,QAAQ,CAAC;CACnC,OAAO,OAAO,SAAS,SAAS,IAC5B,KAAK,MAAO,QAAQ,SAAS,IAAK,CAAC,IACnC,QAAQ;AACd"}

package/dist/tool-schema-CBjGPrsQ.js

@@ -0,0 +1,31 @@
+//#region src/channels/tool-schema.ts
+const channelMessageJsonSchema = {
+	type: "object",
+	properties: {
+		title: {
+			type: "string",
+			description: "Optional title or topic for the message"
+		},
+		markdown: {
+			type: "string",
+			minLength: 1,
+			description: "Message content formatted as Markdown"
+		}
+	},
+	required: ["markdown"],
+	additionalProperties: false
+};
+function parseChannelMessage(value) {
+	if (typeof value === "object" && value !== null) {
+		const candidate = value;
+		if (typeof candidate.markdown === "string" && candidate.markdown.length > 0 && (candidate.title === void 0 || typeof candidate.title === "string")) return {
+			...typeof candidate.title === "string" ? { title: candidate.title } : {},
+			markdown: candidate.markdown
+		};
+	}
+	throw new Error("Expected an optional string title and a non-empty Markdown string");
+}
+//#endregion
+export { parseChannelMessage as n, channelMessageJsonSchema as t };
+
+//# sourceMappingURL=tool-schema-CBjGPrsQ.js.map

package/dist/tool-schema-CBjGPrsQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-schema-CBjGPrsQ.js","names":[],"sources":["../src/channels/tool-schema.ts"],"sourcesContent":["import type { ChannelMessage } from \"./channel\";\n\nexport const channelMessageJsonSchema: {\n  type: \"object\";\n  properties: {\n    title: { type: \"string\"; description: string };\n    markdown: { type: \"string\"; minLength: number; description: string };\n  };\n  required: string[];\n  additionalProperties: false;\n} = {\n  type: \"object\",\n  properties: {\n    title: {\n      type: \"string\",\n      description: \"Optional title or topic for the message\"\n    },\n    markdown: {\n      type: \"string\",\n      minLength: 1,\n      description: \"Message content formatted as Markdown\"\n    }\n  },\n  required: [\"markdown\"],\n  additionalProperties: false\n};\n\nexport function parseChannelMessage(value: unknown): ChannelMessage {\n  if (typeof value === \"object\" && value !== null) {\n    const candidate = value as Record<string, unknown>;\n    if (\n      typeof candidate.markdown === \"string\" &&\n      candidate.markdown.length > 0 &&\n      (candidate.title === undefined || typeof candidate.title === \"string\")\n    ) {\n      return {\n        ...(typeof candidate.title === \"string\"\n          ? { title: candidate.title }\n          : {}),\n        markdown: candidate.markdown\n      };\n    }\n  }\n\n  throw new Error(\n    \"Expected an optional string title and a non-empty Markdown string\"\n  );\n}\n"],"mappings":";AAEA,MAAa,2BAQT;CACF,MAAM;CACN,YAAY;EACV,OAAO;GACL,MAAM;GACN,aAAa;EACf;EACA,UAAU;GACR,MAAM;GACN,WAAW;GACX,aAAa;EACf;CACF;CACA,UAAU,CAAC,UAAU;CACrB,sBAAsB;AACxB;AAEA,SAAgB,oBAAoB,OAAgC;CAClE,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM;EAC/C,MAAM,YAAY;EAClB,IACE,OAAO,UAAU,aAAa,YAC9B,UAAU,SAAS,SAAS,MAC3B,UAAU,UAAU,KAAA,KAAa,OAAO,UAAU,UAAU,WAE7D,OAAO;GACL,GAAI,OAAO,UAAU,UAAU,WAC3B,EAAE,OAAO,UAAU,MAAM,IACzB,CAAC;GACL,UAAU,UAAU;EACtB;CAEJ;CAEA,MAAM,IAAI,MACR,mEACF;AACF"}

package/dist/types-B7LojTe4.d.ts

@@ -0,0 +1,202 @@
+//#region src/sessions/types.d.ts
+/**
+ * Types for the Sessions capability.
+ *
+ * @experimental The whole `agents/sessions` surface may change before
+ * stabilizing.
+ */
+/**
+ * Minimal message part shape used by Sessions internals.
+ * Vercel AI SDK's `UIMessagePart` is structurally compatible.
+ */
+interface SessionMessagePart {
+  type: string;
+  text?: string;
+  reasoning?: string;
+  toolCallId?: string;
+  toolName?: string;
+  input?: unknown;
+  output?: unknown;
+  state?: string;
+  result?: unknown;
+  /** File parts (AI SDK `FileUIPart`): IANA media type of the payload. */
+  mediaType?: string;
+  /** File parts: a `data:` URL or a remote URL. */
+  url?: string;
+  /** File parts: original filename, when one was supplied. */
+  filename?: string;
+}
+/**
+ * Minimal message shape used by Sessions internals.
+ * Vercel AI SDK's `UIMessage` is structurally compatible — you can pass
+ * `UIMessage` objects directly without conversion.
+ */
+interface SessionMessage {
+  id: string;
+  role: string;
+  parts: SessionMessagePart[];
+  metadata?: unknown;
+  createdAt?: Date;
+}
+interface SearchResult {
+  id: string;
+  role: string;
+  content: string;
+  createdAt?: string;
+  sessionId?: string;
+}
+interface StoredCompaction {
+  id: string;
+  summary: string;
+  fromMessageId: string;
+  toMessageId: string;
+  createdAt: string;
+}
+/** Per-row info for the active branch path, root → leaf order. */
+interface SessionRowStat {
+  id: string;
+  /** Stored message role (e.g. "user" / "assistant"). */
+  role: string;
+  /**
+   * Serialized size in bytes: the message row, every continuation row it
+   * was split across, and the payloads it points at as they read back.
+   */
+  bytes: number;
+  /** Token estimate stamped when the row was written. */
+  tokenEstimate: number;
+}
+/** Result of a byte-budgeted history read. */
+interface RecentHistoryResult {
+  /**
+   * The most recent messages on the active branch path whose stored bytes
+   * fit `maxContentBytes`, root → leaf order, with compaction overlays
+   * applied within the window. The window always covers at least the leaf
+   * row; rows whose stored content fails to parse are skipped.
+   */
+  messages: SessionMessage[];
+  /** True when older messages were left out to satisfy the byte budget. */
+  truncated: boolean;
+  /** Summed stored size of the FULL path, in bytes. */
+  totalContentBytes: number;
+}
+/** Result of an append/upsert write. */
+interface AppendResult {
+  /** False when the id already existed and the write was an idempotent no-op. */
+  inserted: boolean;
+  /** The STORED form of the message (sanitized). */
+  message: SessionMessage;
+}
+/** Change-feed events dispatched after each durable write. */
+type SessionChangeEvent =
+  | {
+      type: "append";
+      sessionId: string;
+      message: SessionMessage;
+      parentId?: string | null;
+      inserted: boolean;
+    }
+  | {
+      type: "update";
+      sessionId: string;
+      message: SessionMessage;
+    }
+  | {
+      type: "delete";
+      sessionId: string;
+      messageIds: string[];
+    }
+  | {
+      type: "clear";
+      sessionId: string;
+    }
+  | {
+      type: "compact";
+      sessionId: string;
+    }
+  /**
+   * A row written verbatim by `importMessage()`. A host cache should treat
+   * the path as changed underneath it rather than patch itself: imports come
+   * in bulk with explicit parents, so re-deriving once later is the cheap
+   * response.
+   */
+  | {
+      type: "import";
+      sessionId: string;
+      message: SessionMessage;
+      parentId: string | null;
+    } /** An overlay stored directly through `addCompaction()`. */
+  | {
+      type: "compaction";
+      sessionId: string;
+      compaction: StoredCompaction;
+    };
+type SessionChangeListener = (
+  event: SessionChangeEvent
+) => void | Promise<void>;
+/** Options accepted by history reads. */
+interface HistoryReadOptions {
+  /** Read the path ending at this leaf instead of the active leaf. */
+  leafId?: string | null;
+  /** Abort a streamed read between chunks. */
+  signal?: AbortSignal;
+  /**
+   * Yield the path leaf → root instead of root → leaf. Content is still
+   * fetched in bounded windows, newest window first, so a consumer that
+   * stops after the message it was looking for reads only the newest rows.
+   */
+  newestFirst?: boolean;
+}
+/** Options accepted by batched history reads. */
+interface HistoryBatchReadOptions extends HistoryReadOptions {
+  /** Maximum messages per yielded batch. Default 50. */
+  batchSize?: number;
+  /**
+   * Maximum serialized bytes per yielded batch. Default 4 MiB. A single
+   * message larger than the limit is yielded alone.
+   */
+  maxBatchBytes?: number;
+}
+/** Policy for a Sessions capability. */
+interface SessionsOptions {
+  /**
+   * Message-metadata keys reserved for server-side writers. Stripped from
+   * writes marked `source: "client"`. Default: none.
+   */
+  readonly reservedMetadataKeys?: readonly string[];
+}
+/** Trust policy shared by append and update writes. */
+interface WriteOptions {
+  /**
+   * `"client"` marks untrusted intake: reserved metadata keys are stripped.
+   * Default `"server"`.
+   */
+  source?: "client" | "server";
+}
+/** Options accepted by append writes. */
+interface AppendOptions extends WriteOptions {
+  /**
+   * - `undefined` / omitted → auto-detect: attach to the current latest leaf.
+   * - `null` → create a root message with no parent.
+   * - string → attach to the given parent id (falls back to root when the
+   *   parent does not belong to this session).
+   */
+  parentId?: string | null;
+}
+//#endregion
+export {
+  RecentHistoryResult as a,
+  SessionChangeListener as c,
+  SessionRowStat as d,
+  SessionsOptions as f,
+  HistoryReadOptions as i,
+  SessionMessage as l,
+  WriteOptions as m,
+  AppendResult as n,
+  SearchResult as o,
+  StoredCompaction as p,
+  HistoryBatchReadOptions as r,
+  SessionChangeEvent as s,
+  AppendOptions as t,
+  SessionMessagePart as u
+};
+//# sourceMappingURL=types-B7LojTe4.d.ts.map