@tangle-network/agent-runtime 0.105.0 → 0.106.1

package/dist/backends-CiOCyRHb.js

@@ -0,0 +1,743 @@
+import { l as SessionMismatchError, r as BackendTransportError } from "./errors-DEAvWQPy.js";
+//#region src/sessions.ts
+/**
+*
+* Session helpers + an in-memory `RuntimeSessionStore` implementation suitable
+* for tests, scratch processes, and per-request scratch storage in serverless
+* runtimes. Durable stores (D1, postgres, Durable Objects) implement the same
+* interface from `./types`.
+*
+* @stable
+*/
+/** @internal */
+function newRuntimeSession(backend, requestedId, metadata) {
+	const now = nowIso();
+	return {
+		id: requestedId || crypto.randomUUID(),
+		backend,
+		status: "active",
+		createdAt: now,
+		updatedAt: now,
+		metadata
+	};
+}
+/** @internal */
+function touchSession(session) {
+	return {
+		...session,
+		updatedAt: nowIso()
+	};
+}
+/** @internal */
+function nowIso() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+/** Start or resume one backend session and persist its current identity. @internal */
+async function startOrResumeRuntimeSession(options) {
+	const existing = options.resume && options.sessionId ? await options.store?.get(options.sessionId) : void 0;
+	if (!existing) {
+		const input = resolveSessionInput(options.input);
+		const session = options.backend.start ? await options.backend.start(input, {
+			...options.context,
+			requestedSessionId: options.sessionId
+		}) : newRuntimeSession(options.backend.kind, options.sessionId);
+		assertSessionBackend(session, options.backend.kind);
+		options.validateSession?.(session);
+		await options.store?.put(session);
+		return {
+			session,
+			input,
+			resumed: false
+		};
+	}
+	assertSessionBackend(existing, options.backend.kind);
+	const input = resolveSessionInput(options.backend.resume !== void 0 ? options.continuationInput ?? options.input : options.input);
+	const session = options.backend.resume ? await options.backend.resume(existing, input, options.context) : touchSession({
+		...existing,
+		status: "active"
+	});
+	assertSessionBackend(session, options.backend.kind);
+	options.validateSession?.(session);
+	await options.store?.put(session);
+	return {
+		session,
+		input,
+		resumed: true
+	};
+}
+function resolveSessionInput(input) {
+	return typeof input === "function" ? input() : input;
+}
+function assertSessionBackend(session, backend) {
+	if (session.backend !== backend) throw new SessionMismatchError(session.backend, backend);
+}
+/** In-memory `RuntimeSessionStore` for single-process use and tests. @stable */
+var InMemoryRuntimeSessionStore = class {
+	sessions = /* @__PURE__ */ new Map();
+	events = /* @__PURE__ */ new Map();
+	get(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	put(session) {
+		this.sessions.set(session.id, session);
+	}
+	appendEvent(sessionId, event) {
+		const existing = this.events.get(sessionId) ?? [];
+		existing.push(event);
+		this.events.set(sessionId, existing);
+	}
+	listEvents(sessionId) {
+		return [...this.events.get(sessionId) ?? []];
+	}
+};
+//#endregion
+//#region src/backends.ts
+/**
+*
+* Backend factories for `runAgentTaskStream`. Three shapes ship in core:
+*
+*  - `createIterableBackend` — wrap any custom async iterable into a backend
+*  - `createSandboxPromptBackend` — sandbox / sidecar `streamPrompt` clients
+*  - `createOpenAICompatibleBackend` — OpenAI-style chat completions endpoints
+*
+* Adapters stay thin: domain repos own auth, model selection, and the concrete
+* tool surface. The factories handle session creation, stream normalization,
+* and graceful end-of-stream signalling.
+*
+* @stable
+*/
+/** Wrap any custom async-iterable stream into a typed `AgentExecutionBackend`. @stable */
+function createIterableBackend(options) {
+	return options;
+}
+/** Build an `AgentExecutionBackend` backed by a sandbox/sidecar `streamPrompt` call. @stable */
+function createSandboxPromptBackend(options) {
+	const kind = options.kind ?? "sandbox";
+	return {
+		kind,
+		async start(input, context) {
+			const box = await options.getBox(input, context);
+			return newRuntimeSession(kind, options.getSessionId?.(box, input) ?? context.requestedSessionId, { resumable: true });
+		},
+		resume(session) {
+			return touchSession({
+				...session,
+				status: "active"
+			});
+		},
+		async *stream(input, context) {
+			const box = await options.getBox(input, context);
+			const message = input.message ?? input.messages?.at(-1)?.content ?? context.task.intent;
+			for await (const event of options.streamPrompt(box, message, context)) {
+				const mapped = options.mapEvent?.(event, context) ?? mapCommonBackendEvent(event, context);
+				if (mapped) yield mapped;
+			}
+		}
+	};
+}
+const DEFAULT_RETRY_STATUSES = [
+	408,
+	425,
+	429,
+	500,
+	502,
+	503,
+	504
+];
+function pickRetryDelayMs(attempt, policy) {
+	const exp = policy.initialBackoffMs * 2 ** (attempt - 1);
+	const capped = Math.min(exp, policy.maxBackoffMs);
+	const jitter = capped * policy.jitter * (Math.random() * 2 - 1);
+	return Math.max(0, Math.round(capped + jitter));
+}
+/**
+* Derive a per-attempt AbortSignal that fires when EITHER the caller's
+* signal aborts OR `timeoutMs` elapses. `dispose()` clears the timer so a
+* completed attempt doesn't leak a pending timeout. `timeoutMs <= 0`
+* disables the deadline (caller signal still propagates).
+*/
+function withTimeout(callerSignal, timeoutMs) {
+	if (timeoutMs <= 0) return {
+		signal: callerSignal ?? new AbortController().signal,
+		dispose: () => void 0
+	};
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(/* @__PURE__ */ new Error(`request timed out after ${timeoutMs}ms`)), timeoutMs);
+	if (typeof timer.unref === "function") timer.unref();
+	const onCallerAbort = () => controller.abort(callerSignal?.reason ?? /* @__PURE__ */ new Error("aborted"));
+	if (callerSignal) if (callerSignal.aborted) onCallerAbort();
+	else callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+	return {
+		signal: controller.signal,
+		dispose: () => {
+			clearTimeout(timer);
+			callerSignal?.removeEventListener("abort", onCallerAbort);
+		}
+	};
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(signal.reason ?? /* @__PURE__ */ new Error("aborted"));
+			return;
+		}
+		const t = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(t);
+			reject(signal?.reason ?? /* @__PURE__ */ new Error("aborted"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+*
+* OpenAI-compat streaming backend. Routes `runAgentTaskStream` through any
+* `POST /chat/completions` endpoint that speaks OpenAI's SSE protocol —
+* Tangle Router, OpenAI direct, OpenRouter, Groq, DeepSeek, Together. The
+* router also fronts Anthropic models in Anthropic-native SSE shape; this
+* backend handles both.
+*
+* ### Tool calls
+*
+* Pass `tools` (and optionally `toolChoice`) to forward an OpenAI Chat
+* Completions `tools[]` array on every request. Streamed `tool_call` chunks
+* are buffered until the model finalizes them (either `finish_reason:
+* 'tool_calls'` for OpenAI shape or a `content_block_stop` for Anthropic
+* `tool_use` blocks proxied through the router), then emitted as a single
+* `tool_call` RuntimeStreamEvent with the assembled `args`.
+*
+* The backend does NOT execute tools — it surfaces calls for the caller's
+* own dispatcher (typically the product's MCP / sandbox runtime) to fulfill
+* and feed back as a subsequent `messages` turn. This keeps the transport
+* thin and lets the agent host own tool dispatch policy.
+*
+* ### Fail-loud errors
+*
+* Non-success HTTP responses (4xx/5xx) and exhausted retry budgets throw
+* `BackendTransportError` from inside the `stream()` generator. The runtime
+* catches the throw, yields a `backend_error` with a typed `error` field
+* (`kind`, `status`, truncated `body`) and a terminal `final` event with
+* `status: 'failed'` carrying the same detail. Consumers MUST map
+* `final.error` onto their `RunRecord.error` — silently treating an empty
+* `finalText` as "agent produced nothing" hides credit exhaustion, auth
+* failure, and upstream outages.
+*
+* @stable
+*/
+function createOpenAICompatibleBackend(options) {
+	const fetcher = options.fetchImpl ?? fetch;
+	const kind = options.kind ?? "tcloud";
+	const retryPolicy = {
+		maxAttempts: options.retry?.maxAttempts ?? 5,
+		initialBackoffMs: options.retry?.initialBackoffMs ?? 1e3,
+		maxBackoffMs: options.retry?.maxBackoffMs ?? 3e4,
+		jitter: options.retry?.jitter ?? .25,
+		retryStatuses: options.retry?.retryStatuses ?? DEFAULT_RETRY_STATUSES,
+		requestTimeoutMs: options.retry?.requestTimeoutMs ?? 12e4
+	};
+	return {
+		kind,
+		start(_input, context) {
+			return newRuntimeSession(kind, context.requestedSessionId);
+		},
+		async *stream(input, context) {
+			const url = `${options.baseUrl.replace(/\/$/, "")}/chat/completions`;
+			const bodyPayload = {
+				model: options.model,
+				stream: true,
+				stream_options: { include_usage: true },
+				messages: input.messages ?? [{
+					role: "user",
+					content: input.message ?? context.task.intent
+				}]
+			};
+			if (options.tools && options.tools.length > 0) {
+				bodyPayload.tools = options.tools;
+				if (options.toolChoice !== void 0) bodyPayload.tool_choice = options.toolChoice;
+			}
+			if (options.responseFormat !== void 0) bodyPayload.response_format = options.responseFormat;
+			if (options.temperature !== void 0) bodyPayload.temperature = options.temperature;
+			if (options.maxTokens !== void 0) bodyPayload.max_tokens = options.maxTokens;
+			const requestBody = JSON.stringify(bodyPayload);
+			let response;
+			let lastStatus = 0;
+			let lastThrown;
+			for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt++) {
+				lastThrown = void 0;
+				const attemptSignal = withTimeout(context.signal, retryPolicy.requestTimeoutMs);
+				try {
+					response = await fetcher(url, {
+						method: "POST",
+						headers: {
+							Authorization: `Bearer ${options.apiKey}`,
+							"Content-Type": "application/json",
+							...context.propagatedHeaders ?? {}
+						},
+						body: requestBody,
+						signal: attemptSignal.signal
+					});
+				} catch (err) {
+					attemptSignal.dispose();
+					if (context.signal?.aborted) throw err;
+					lastThrown = err;
+					response = void 0;
+					if (attempt === retryPolicy.maxAttempts) break;
+					await sleep(pickRetryDelayMs(attempt, retryPolicy), context.signal);
+					continue;
+				}
+				attemptSignal.dispose();
+				if (response.ok) break;
+				lastStatus = response.status;
+				if (!retryPolicy.retryStatuses.includes(response.status)) break;
+				if (attempt === retryPolicy.maxAttempts) break;
+				try {
+					await response.body?.cancel();
+				} catch {}
+				await sleep(pickRetryDelayMs(attempt, retryPolicy), context.signal);
+			}
+			if (!response) {
+				const reason = lastThrown instanceof Error ? lastThrown.message : String(lastThrown);
+				throw new BackendTransportError(kind, `chat backend unreachable after ${retryPolicy.maxAttempts} attempts: ${reason}`, { status: 0 });
+			}
+			if (!response.ok) {
+				let body;
+				try {
+					const raw = await response.text();
+					body = raw.length > MAX_ERROR_BODY_BYTES ? `${raw.slice(0, MAX_ERROR_BODY_BYTES)}…` : raw;
+				} catch {
+					body = void 0;
+				}
+				throw new BackendTransportError(kind, `chat backend returned ${lastStatus || "unknown"}`, {
+					status: lastStatus || 0,
+					body
+				});
+			}
+			yield* streamResponseEvents(response, context, options.model);
+		}
+	};
+}
+/**
+* Cap the captured error body. 2 KiB is enough to carry a JSON error envelope
+* with a structured `code`/`message` payload (the router returns ~150 bytes
+* for a free-tier denial; OpenAI returns ~300 bytes for invalid auth) without
+* letting an HTML error page balloon persisted events.
+*/
+const MAX_ERROR_BODY_BYTES = 2048;
+/** @internal */
+function normalizeBackendStreamEvent(event, task, session) {
+	if ("task" in event && event.task && "session" in event && event.session && "timestamp" in event && event.timestamp) return event;
+	return {
+		...event,
+		task: "task" in event && event.task ? event.task : task,
+		session: "session" in event && event.session ? event.session : session,
+		timestamp: "timestamp" in event && event.timestamp ? event.timestamp : nowIso()
+	};
+}
+function mapCommonBackendEvent(event, context) {
+	if (!event || typeof event !== "object") return void 0;
+	const record = event;
+	const type = String(record.type ?? "");
+	const data = record.data && typeof record.data === "object" ? record.data : record;
+	if (type === "message.part.updated" || type === "text_delta" || type === "delta") {
+		const part = data.part;
+		const partText = part !== void 0 && typeof part === "object" && (part.type === "text" || part.type === void 0) ? stringValue(part.text) : void 0;
+		const text = stringValue(data.text) ?? stringValue(data.delta) ?? stringValue(record.text) ?? partText;
+		return text ? {
+			type: "text_delta",
+			task: context.task,
+			session: context.session,
+			text,
+			timestamp: nowIso()
+		} : void 0;
+	}
+	if (type === "reasoning_delta") {
+		const text = stringValue(data.text) ?? stringValue(record.text);
+		return text ? {
+			type: "reasoning_delta",
+			task: context.task,
+			session: context.session,
+			text,
+			timestamp: nowIso()
+		} : void 0;
+	}
+	if (type === "tool_call") return {
+		type: "tool_call",
+		task: context.task,
+		session: context.session,
+		toolName: stringValue(data.name) ?? stringValue(record.toolName) ?? "tool",
+		toolCallId: stringValue(data.id) ?? stringValue(record.toolCallId),
+		args: data.args ?? data.input ?? record.args,
+		timestamp: nowIso()
+	};
+	if (type === "tool_result") return {
+		type: "tool_result",
+		task: context.task,
+		session: context.session,
+		toolName: stringValue(data.name) ?? stringValue(record.toolName) ?? "tool",
+		toolCallId: stringValue(data.id) ?? stringValue(record.toolCallId),
+		result: data.result ?? data.output ?? record.result,
+		timestamp: nowIso()
+	};
+	if (type === "artifact") {
+		const artifactId = stringValue(data.artifactId) ?? stringValue(data.id) ?? stringValue(record.artifactId);
+		if (!artifactId) return void 0;
+		return {
+			type: "artifact",
+			task: context.task,
+			session: context.session,
+			artifactId,
+			name: stringValue(data.name) ?? stringValue(record.name),
+			mimeType: stringValue(data.mimeType) ?? stringValue(record.mimeType),
+			uri: stringValue(data.uri) ?? stringValue(record.uri),
+			content: stringValue(data.content) ?? stringValue(data.body) ?? stringValue(record.content),
+			metadata: data.metadata && typeof data.metadata === "object" ? data.metadata : void 0,
+			timestamp: nowIso()
+		};
+	}
+	if (type === "proposal_created" || type === "proposal" || type === "filing") {
+		const proposalId = stringValue(data.proposalId) ?? stringValue(data.id) ?? stringValue(record.proposalId);
+		if (!proposalId) return void 0;
+		const status = stringValue(data.status) ?? stringValue(record.status);
+		return {
+			type: "proposal_created",
+			task: context.task,
+			session: context.session,
+			proposalId,
+			title: stringValue(data.title) ?? stringValue(record.title) ?? proposalId,
+			status: status === "pending" || status === "approved" || status === "rejected" ? status : void 0,
+			content: stringValue(data.content) ?? stringValue(data.body) ?? stringValue(record.content),
+			timestamp: nowIso()
+		};
+	}
+	if (type === "result" || type === "final") {
+		const text = stringValue(data.finalText) ?? stringValue(data.text) ?? stringValue(record.text);
+		return text ? {
+			type: "text_delta",
+			task: context.task,
+			session: context.session,
+			text,
+			timestamp: nowIso()
+		} : void 0;
+	}
+}
+async function* streamResponseEvents(response, context, requestedModel) {
+	const body = response.body;
+	if (!body) return;
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	const usage = { saw: false };
+	const toolCalls = /* @__PURE__ */ new Map();
+	const startedAt = Date.now();
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
+		for (const event of drainStreamBuffer(false)) yield event;
+	}
+	buffer += decoder.decode().replace(/\r\n/g, "\n");
+	for (const event of drainStreamBuffer(true)) yield event;
+	if (buffer.trim()) for (const event of parseStreamChunk(buffer, context, usage, toolCalls)) yield event;
+	for (const event of flushPendingToolCalls(toolCalls, context)) yield event;
+	if (usage.saw) yield {
+		type: "llm_call",
+		task: context.task,
+		session: context.session,
+		model: usage.model ?? requestedModel,
+		tokensIn: usage.tokensIn,
+		tokensOut: usage.tokensOut,
+		latencyMs: Date.now() - startedAt,
+		finishReason: usage.finishReason,
+		timestamp: nowIso()
+	};
+	function* drainStreamBuffer(flush) {
+		for (;;) {
+			const sseBoundary = buffer.indexOf("\n\n");
+			if (sseBoundary >= 0) {
+				const chunk = buffer.slice(0, sseBoundary);
+				buffer = buffer.slice(sseBoundary + 2);
+				for (const event of parseStreamChunk(chunk, context, usage, toolCalls)) yield event;
+				continue;
+			}
+			const newline = buffer.indexOf("\n");
+			if (newline >= 0 && !buffer.slice(0, newline).startsWith("data:")) {
+				const line = buffer.slice(0, newline);
+				buffer = buffer.slice(newline + 1);
+				for (const event of parseStreamChunk(line, context, usage, toolCalls)) yield event;
+				continue;
+			}
+			if (flush && buffer.trim() && !buffer.trimStart().startsWith("data:")) {
+				const line = buffer;
+				buffer = "";
+				for (const event of parseStreamChunk(line, context, usage, toolCalls)) yield event;
+				continue;
+			}
+			break;
+		}
+	}
+}
+function* parseStreamChunk(chunk, context, usage, toolCalls) {
+	const lines = chunk.split(/\r?\n/);
+	const dataLines = lines.filter((line) => line.startsWith("data:"));
+	if (dataLines.length === 0 && lines.every((line) => {
+		const trimmed = line.trim();
+		return trimmed.length === 0 || trimmed.startsWith(":");
+	})) return;
+	const data = dataLines.length > 0 ? dataLines.map((line) => line.slice(5).trimStart()).join("\n") : chunk.trim();
+	if (!data || data === "[DONE]") return;
+	let parsed;
+	try {
+		parsed = JSON.parse(data);
+	} catch {
+		yield {
+			type: "text_delta",
+			task: context.task,
+			session: context.session,
+			text: data,
+			timestamp: nowIso()
+		};
+		return;
+	}
+	captureStreamUsage(parsed, usage);
+	const choices = parsed.choices;
+	const choice = Array.isArray(choices) ? choices[0] : void 0;
+	const delta = choice?.delta;
+	const message = choice?.message;
+	const deltaToolCalls = delta?.tool_calls;
+	if (Array.isArray(deltaToolCalls)) for (const tc of deltaToolCalls) {
+		if (!tc || typeof tc !== "object") continue;
+		const rec = tc;
+		const id = stringValue(rec.id);
+		const key = deltaToolCallKey(rec, id, toolCalls);
+		const acc = toolCalls.get(key) ?? {
+			argsRaw: "",
+			source: "openai",
+			finalized: false
+		};
+		if (id) acc.id = id;
+		const fn = rec.function;
+		const name = stringValue(fn?.name);
+		if (name) acc.name = name;
+		const args = stringValue(fn?.arguments);
+		if (args) acc.argsRaw += args;
+		toolCalls.set(key, acc);
+	}
+	const messageToolCalls = message?.tool_calls;
+	if (Array.isArray(messageToolCalls)) for (const tc of messageToolCalls) {
+		if (!tc || typeof tc !== "object") continue;
+		const rec = tc;
+		const fn = rec.function;
+		const key = `openai:${numberValue(rec.index) ?? messageToolCalls.indexOf(tc)}`;
+		const acc = toolCalls.get(key) ?? {
+			argsRaw: "",
+			source: "openai",
+			finalized: false
+		};
+		const id = stringValue(rec.id);
+		if (id) acc.id = id;
+		const name = stringValue(fn?.name);
+		if (name) acc.name = name;
+		const args = stringValue(fn?.arguments);
+		if (args) acc.argsRaw += args;
+		acc.finalized = true;
+		toolCalls.set(key, acc);
+	}
+	if (stringValue(choice?.finish_reason) === "tool_calls") for (const [key, acc] of toolCalls) {
+		if (acc.source === "openai" && !acc.finalized) acc.finalized = true;
+		toolCalls.set(key, acc);
+	}
+	const eventType = stringValue(parsed.type);
+	if (eventType === "content_block_start") {
+		const block = parsed.content_block;
+		if (block && stringValue(block.type) === "tool_use") {
+			const key = `anthropic:${numberValue(parsed.index) ?? 0}`;
+			toolCalls.set(key, {
+				id: stringValue(block.id),
+				name: stringValue(block.name),
+				argsRaw: "",
+				source: "anthropic",
+				finalized: false
+			});
+		}
+	}
+	if (eventType === "content_block_delta") {
+		const d = parsed.delta;
+		if (stringValue(d?.type) === "input_json_delta") {
+			const key = `anthropic:${numberValue(parsed.index) ?? 0}`;
+			const acc = toolCalls.get(key);
+			if (acc) {
+				const partial = stringValue(d?.partial_json) ?? "";
+				acc.argsRaw += partial;
+				toolCalls.set(key, acc);
+			}
+		} else {
+			const text = stringValue(d?.text);
+			if (text) yield {
+				type: "text_delta",
+				task: context.task,
+				session: context.session,
+				text,
+				timestamp: nowIso()
+			};
+		}
+	}
+	if (eventType === "content_block_stop") {
+		const key = `anthropic:${numberValue(parsed.index) ?? 0}`;
+		const acc = toolCalls.get(key);
+		if (acc) {
+			acc.finalized = true;
+			toolCalls.set(key, acc);
+		}
+	}
+	for (const event of drainFinalizedToolCalls(toolCalls, context)) yield event;
+	const text = stringValue(delta?.content) ?? stringValue(message?.content) ?? stringValue(parsed.text);
+	if (text) {
+		yield {
+			type: "text_delta",
+			task: context.task,
+			session: context.session,
+			text,
+			timestamp: nowIso()
+		};
+		return;
+	}
+	const mapped = mapCommonBackendEvent(parsed, context);
+	if (mapped) yield mapped;
+}
+function* drainFinalizedToolCalls(toolCalls, context) {
+	for (const [key, acc] of toolCalls) {
+		if (!acc.finalized) continue;
+		toolCalls.delete(key);
+		yield buildToolCallEvent(acc, context);
+	}
+}
+function* flushPendingToolCalls(toolCalls, context) {
+	for (const [key, acc] of toolCalls) {
+		toolCalls.delete(key);
+		yield buildToolCallEvent(acc, context);
+	}
+}
+/**
+* The accumulator key one streamed `delta.tool_calls[]` entry belongs to.
+*
+* OpenAI's streaming contract puts `index` on every fragment, so fragments of
+* the same call concatenate under `openai:<index>`. Some OpenAI-COMPATIBLE
+* gateways do not: the Tangle router's Gemini lane emits N COMPLETE tool calls
+* inside a single delta, each with a distinct `id` and no `index` at all.
+* Defaulting those to index 0 concatenated every call's `arguments` into one
+* string, which then failed `JSON.parse` and was surfaced as a raw string — so
+* a turn that asked for six deliverables silently produced none.
+*
+* Resolution order:
+*   1. `index` present  → spec path, key by index (cross-delta fragments join).
+*   2. `id` present     → key by id; distinct ids are distinct calls, and a
+*                         repeated id still concatenates correctly.
+*   3. neither          → an argument-only continuation fragment; append to the
+*                         last-OPENED unfinalized OpenAI entry. `Map` iteration
+*                         is insertion-ordered and `set` on an existing key does
+*                         not reorder, so this is the most recently STARTED call
+*                         still taking arguments — which is the one a gateway
+*                         streaming calls sequentially is continuing.
+*/
+function deltaToolCallKey(rec, id, toolCalls) {
+	const idx = numberValue(rec.index);
+	if (idx !== void 0) return `openai:${idx}`;
+	if (id) return `openai:id:${id}`;
+	let last;
+	for (const [key, acc] of toolCalls) if (acc.source === "openai" && !acc.finalized) last = key;
+	return last ?? "openai:0";
+}
+function buildToolCallEvent(acc, context) {
+	let args = acc.argsRaw;
+	if (acc.argsRaw.length > 0) try {
+		args = JSON.parse(acc.argsRaw);
+	} catch {
+		args = acc.argsRaw;
+	}
+	else args = {};
+	return {
+		type: "tool_call",
+		task: context.task,
+		session: context.session,
+		toolName: acc.name ?? "tool",
+		toolCallId: acc.id,
+		args,
+		timestamp: nowIso()
+	};
+}
+/**
+* Accumulate token usage from any SSE chunk shape the router may emit.
+*
+*  - OpenAI: a final chunk before `[DONE]` with `{ usage: { prompt_tokens,
+*    completion_tokens, total_tokens } }` and (often) empty `choices`. The
+*    `model` field is on every chunk and the last `choices[0].finish_reason`
+*    carries the stop reason.
+*  - Anthropic: `message_start` carries `message.model` and
+*    `message.usage.input_tokens`. The terminal `message_delta` carries
+*    `usage.output_tokens` and `delta.stop_reason`.
+*/
+function captureStreamUsage(parsed, usage) {
+	const model = stringValue(parsed.model);
+	if (model && !usage.model) usage.model = model;
+	const openAiUsage = parsed.usage;
+	if (openAiUsage && typeof openAiUsage === "object") {
+		const promptTokens = numberValue(openAiUsage.prompt_tokens);
+		const completionTokens = numberValue(openAiUsage.completion_tokens);
+		const inputTokens = numberValue(openAiUsage.input_tokens);
+		const outputTokens = numberValue(openAiUsage.output_tokens);
+		if (promptTokens !== void 0) {
+			usage.tokensIn = promptTokens;
+			usage.saw = true;
+		} else if (inputTokens !== void 0) {
+			usage.tokensIn = (usage.tokensIn ?? 0) + inputTokens;
+			usage.saw = true;
+		}
+		if (completionTokens !== void 0) {
+			usage.tokensOut = completionTokens;
+			usage.saw = true;
+		} else if (outputTokens !== void 0) {
+			usage.tokensOut = (usage.tokensOut ?? 0) + outputTokens;
+			usage.saw = true;
+		}
+	}
+	const type = stringValue(parsed.type);
+	if (type === "message_start") {
+		const message = parsed.message;
+		const messageModel = stringValue(message?.model);
+		if (messageModel && !usage.model) usage.model = messageModel;
+		const messageUsage = message?.usage;
+		const inputTokens = numberValue(messageUsage?.input_tokens);
+		if (inputTokens !== void 0) {
+			usage.tokensIn = inputTokens;
+			usage.saw = true;
+		}
+		const outputTokens = numberValue(messageUsage?.output_tokens);
+		if (outputTokens !== void 0) {
+			usage.tokensOut = (usage.tokensOut ?? 0) + outputTokens;
+			usage.saw = true;
+		}
+	}
+	if (type === "message_delta") {
+		const delta = parsed.delta;
+		const stopReason = stringValue(delta?.stop_reason);
+		if (stopReason) usage.finishReason = stopReason;
+	}
+	const choices = parsed.choices;
+	if (Array.isArray(choices)) {
+		const finishReason = stringValue(choices[0]?.finish_reason);
+		if (finishReason) usage.finishReason = finishReason;
+	}
+}
+function numberValue(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function stringValue(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+//#endregion
+export { InMemoryRuntimeSessionStore as a, startOrResumeRuntimeSession as c, normalizeBackendStreamEvent as i, touchSession as l, createOpenAICompatibleBackend as n, newRuntimeSession as o, createSandboxPromptBackend as r, nowIso as s, createIterableBackend as t };
+
+//# sourceMappingURL=backends-CiOCyRHb.js.map