@tangle-network/agent-runtime 0.126.0 → 0.131.0

package/dist/backends-CiOCyRHb.js

@@ -1,743 +0,0 @@
-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