@anvia/client 1.6.0 → 1.8.0

package/dist/durable-chat.js

@@ -0,0 +1,965 @@
+import { DurableHttpError } from "./durable.js";
+import { n as createClientId, t as CLIENT_STREAM_PROTOCOL } from "./types-CqJxMo_1.js";
+import { isJsonValue } from "@anvia/core/completion";
+// src/durable-chat-map.ts
+function createDurableChatMapState(sequence = 0) {
+	return {
+		sequence,
+		openedOperations: /* @__PURE__ */ new Set(),
+		openedParts: /* @__PURE__ */ new Set(),
+		tools: /* @__PURE__ */ new Map(),
+		runOpened: false
+	};
+}
+/**
+* Map one durable event. Events at or before the applied cursor produce nothing, so a reconnect
+* that overlaps the stored sequence does not double-apply.
+*/
+function mapDurableChatEvent(event, state, settledOutcome) {
+	if (!Number.isSafeInteger(event.sequence) || event.sequence <= state.sequence) return {
+		events: [],
+		state
+	};
+	const draft = fork(state, event.sequence);
+	return {
+		events: project(event, draft, settledOutcome),
+		state: draft
+	};
+}
+/**
+* True when a status event needs the run's outcome, which the event itself no longer carries
+* (DUR-07). The caller reads it from the run snapshot and passes it to `mapDurableChatEvent`.
+* Journals written before the change still carry `data.outcome`, so nothing is fetched for them.
+*/
+function needsSettledOutcome(event) {
+	if (event.type !== "status") return false;
+	const data = asRecord(event.data);
+	if (data === void 0 || data.outcome !== void 0) return false;
+	const status = text(data, "status");
+	return status === "completed" || status === "waiting" || status === "failed";
+}
+/** The status a status event reports, so a caller can check a snapshot is still at that point. */
+function statusEventStatus(event) {
+	return event.type === "status" ? text(asRecord(event.data), "status") : void 0;
+}
+/**
+* One assistant message per model operation. Retries keep the identity and reset its parts, so a
+* streamed journal never leaves the empty placeholders that per-attempt ids would create.
+*/
+function durableChatMessageId(runId, operationId) {
+	return `${runId}:${operationId}`;
+}
+function project(event, state, settledOutcome) {
+	const data = asRecord(event.data);
+	switch (event.type) {
+		case "submitted": return openRun(event.runId, state);
+		case "status": return mapStatus(event, data, state, settledOutcome);
+		case "model_started": return mapModelStarted(event, data, state);
+		case "model_attempt_started": return mapAttemptStarted(event, data, state);
+		case "model_delta": return mapModelDelta(event, data, state);
+		case "model_attempt_failed": return mapAttemptFailed(event, data, state);
+		case "model_completed": return mapModelCompleted(event, data, state);
+		case "tool_started": return mapToolStarted(event, data, state);
+		case "tool_completed": return mapToolCompleted(event, data, state);
+		case "compaction_completed": return mapCompaction(event, data);
+		case "steering_queued":
+		case "steering_applied": return [located(event, {
+			type: "data",
+			name: event.type,
+			data: data ?? {},
+			transient: true
+		})];
+		default: return [];
+	}
+}
+function mapStatus(event, data, state, settledOutcome) {
+	const status = text(data, "status");
+	const outcome = asRecord(data?.outcome) ?? settledOutcome;
+	if (status === "needs_attention") return needsAttention(event, data);
+	if (status === "failed") return failed(event, data, outcome);
+	if (status === "cancelled") return [located(event, {
+		type: "run_end",
+		status: "cancelled"
+	})];
+	if (status === "waiting" || status === "completed") return settled(event, outcome, status);
+	if (!state.runOpened && (status === "queued" || status === "pending" || status === "running")) return openRun(event.runId, state);
+	return [];
+}
+function openRun(runId, state) {
+	state.runOpened = true;
+	return [{
+		type: "run_start",
+		source: "agent",
+		runId
+	}];
+}
+function mapModelStarted(event, data, state) {
+	const operationId = text(data, "operationId") ?? "model";
+	const messageId = durableChatMessageId(event.runId, operationId);
+	state.openedOperations.add(operationId);
+	state.messageId = messageId;
+	const generation = {
+		type: "generation_start",
+		runId: event.runId
+	};
+	const model = modelOf(data);
+	if (model !== void 0) generation.model = model;
+	const events = [];
+	if (!state.runOpened) events.push({
+		type: "run_start",
+		source: "agent",
+		runId: event.runId
+	});
+	state.runOpened = true;
+	events.push({
+		type: "turn_start",
+		runId: event.runId
+	}, generation, {
+		type: "message_start",
+		messageId,
+		role: "assistant",
+		runId: event.runId
+	});
+	return events;
+}
+function mapAttemptStarted(event, data, state) {
+	const operationId = text(data, "operationId");
+	if (operationId === void 0) return [];
+	const attempt = number(data, "attempt");
+	const messageId = state.messageId ?? durableChatMessageId(event.runId, operationId);
+	const opened = state.openedOperations.has(operationId);
+	const retried = opened && (attempt === void 0 || attempt > 1);
+	const events = [];
+	if (retried && state.messageId !== void 0) events.push({
+		type: "message_reset",
+		messageId: state.messageId,
+		runId: event.runId
+	});
+	else if (!opened) events.push({
+		type: "message_start",
+		messageId,
+		role: "assistant",
+		runId: event.runId
+	});
+	state.openedOperations.add(operationId);
+	state.messageId = messageId;
+	return events;
+}
+function mapModelDelta(event, data, state) {
+	const nested = asRecord(data?.event);
+	const kind = text(nested, "type");
+	if (nested === void 0 || kind === void 0) return [];
+	const operationId = text(data, "operationId") ?? "model";
+	const messageId = state.messageId ?? durableChatMessageId(event.runId, operationId);
+	state.messageId = messageId;
+	const turn = number(nested, "turn");
+	if (kind === "text_delta") {
+		const delta = text(nested, "delta");
+		if (delta === void 0) return [];
+		return withStart(state, messageId, "text", void 0, event.runId, turn, (partId, started) => {
+			const events = [];
+			if (!started) events.push(part(event.runId, turn, {
+				type: "text_start",
+				messageId,
+				partId
+			}));
+			events.push(part(event.runId, turn, {
+				type: "text_delta",
+				messageId,
+				partId,
+				delta
+			}));
+			return events;
+		});
+	}
+	if (kind === "reasoning_delta") {
+		const delta = text(nested, "delta");
+		if (delta === void 0) return [];
+		const reasoningId = text(nested, "id");
+		return withStart(state, messageId, "reasoning", reasoningId ?? "default", event.runId, turn, (partId, started) => {
+			const events = [];
+			if (!started) {
+				const start = part(event.runId, turn, {
+					type: "reasoning_start",
+					messageId,
+					partId
+				});
+				if (reasoningId !== void 0 && start.type === "reasoning_start") start.reasoningId = reasoningId;
+				events.push(start);
+			}
+			const deltaEvent = part(event.runId, turn, {
+				type: "reasoning_delta",
+				messageId,
+				partId,
+				delta
+			});
+			const contentType = reasoningType(text(nested, "contentType"));
+			const signature = text(nested, "signature");
+			if (deltaEvent.type === "reasoning_delta") {
+				if (contentType !== void 0) deltaEvent.contentType = contentType;
+				if (signature !== void 0) deltaEvent.signature = signature;
+			}
+			events.push(deltaEvent);
+			return events;
+		});
+	}
+	if (kind === "tool_call_delta") {
+		const toolCallId = text(nested, "id");
+		if (toolCallId === void 0) return [];
+		return withStart(state, messageId, "tool", toolCallId, event.runId, turn, (partId, started) => {
+			const events = [];
+			const callId = text(nested, "callId");
+			const toolName = text(nested, "name");
+			if (!started) {
+				const start = part(event.runId, turn, {
+					type: "tool_call_start",
+					messageId,
+					partId,
+					toolCallId
+				});
+				if (start.type === "tool_call_start") {
+					if (callId !== void 0) start.callId = callId;
+					if (toolName !== void 0) start.toolName = toolName;
+				}
+				events.push(start);
+			}
+			const delta = text(nested, "argumentsDelta");
+			if (delta === void 0) return events;
+			const tool = part(event.runId, turn, {
+				type: "tool_call_delta",
+				messageId,
+				partId,
+				toolCallId,
+				delta,
+				mode: nested.argumentsMode === "replace" ? "replace" : "append"
+			});
+			if (tool.type === "tool_call_delta") {
+				if (callId !== void 0) tool.callId = callId;
+				if (toolName !== void 0) tool.toolName = toolName;
+				const signature = text(nested, "signature");
+				if (signature !== void 0) tool.signature = signature;
+			}
+			events.push(tool);
+			return events;
+		});
+	}
+	if (kind === "tool_call") {
+		const call = asToolCall(nested.toolCall);
+		return call === void 0 ? [] : [toolCallEnd(event.runId, messageId, call, turn)];
+	}
+	if (kind === "source") {
+		const source = asSource(nested.source);
+		if (source === void 0) return [];
+		return [part(event.runId, turn, {
+			type: "source",
+			messageId,
+			partId: partId(messageId, "source", JSON.stringify(source)),
+			source
+		})];
+	}
+	if (kind === "provider_tool_call") {
+		const toolCall = asProviderToolCall(nested.toolCall);
+		return toolCall === void 0 ? [] : [part(event.runId, turn, {
+			type: "provider_tool_call",
+			toolCall
+		})];
+	}
+	return [];
+}
+function mapAttemptFailed(event, data, state) {
+	const attemptId = text(data, "attemptId");
+	return [located(event, {
+		type: "data",
+		name: "durable_model_attempt_failed",
+		data: {
+			operationId: text(data, "operationId") ?? null,
+			attemptId: attemptId ?? null,
+			messageId: state.messageId ?? null,
+			error: text(data, "error") ?? "Durable model attempt failed."
+		},
+		transient: true
+	})];
+}
+function mapModelCompleted(event, data, state) {
+	const operationId = text(data, "operationId") ?? "model";
+	const messageId = state.messageId ?? durableChatMessageId(event.runId, operationId);
+	state.messageId = messageId;
+	const result = asRecord(data?.result);
+	const choice = assistantParts(result?.choice);
+	const events = [];
+	const texts = choice.filter((part) => part.type === "text");
+	const textJoined = texts.map((part) => part.text).join("");
+	const textPartId = partId(messageId, "text");
+	if (textJoined.length > 0 || state.openedParts.has(textPartId)) {
+		if (!state.openedParts.has(textPartId)) {
+			state.openedParts.add(textPartId);
+			events.push({
+				type: "text_start",
+				messageId,
+				partId: textPartId,
+				runId: event.runId
+			});
+		}
+		const end = {
+			type: "text_end",
+			messageId,
+			partId: textPartId,
+			text: textJoined,
+			runId: event.runId
+		};
+		const signature = texts.length === 1 ? texts[0]?.signature : void 0;
+		if (signature !== void 0 && end.type === "text_end") end.signature = signature;
+		events.push(end);
+	}
+	for (const content of choice) {
+		if (content.type === "reasoning") events.push(reasoningEnd(event.runId, messageId, content, state));
+		if (content.type === "tool-call") events.push(toolCallEnd(event.runId, messageId, content));
+	}
+	const messageEnd = {
+		type: "message_end",
+		messageId,
+		runId: event.runId
+	};
+	const usage = asUsage(result?.usage);
+	const contextUsage = asContextUsage(result?.contextUsage);
+	if (usage !== void 0 && messageEnd.type === "message_end") messageEnd.usage = usage;
+	if (contextUsage !== void 0 && messageEnd.type === "message_end") messageEnd.contextUsage = contextUsage;
+	if (typeof result?.messageId === "string" && messageEnd.type === "message_end") messageEnd.modelMessageId = result.messageId;
+	events.push(messageEnd);
+	return events;
+}
+function mapToolStarted(event, data, state) {
+	const operationId = text(data, "operationId");
+	const call = asToolCall(asRecord(data?.input)?.toolCall);
+	if (operationId === void 0 || call === void 0) return [];
+	state.tools.set(operationId, call);
+	const messageId = state.messageId ?? durableChatMessageId(event.runId, operationId);
+	return [toolCallEnd(event.runId, messageId, call)];
+}
+function mapToolCompleted(event, data, state) {
+	const operationId = text(data, "operationId");
+	const call = operationId === void 0 ? void 0 : state.tools.get(operationId);
+	const saved = asRecord(data?.result);
+	const output = asToolOutput(saved?.output);
+	if (output === void 0) return [];
+	const messageId = state.messageId ?? durableChatMessageId(event.runId, operationId ?? "tools");
+	const toolCallId = call?.toolCallId ?? operationId ?? "tool";
+	const failed = saved?.failed === true;
+	const result = {
+		type: "tool_result",
+		messageId,
+		partId: partId(messageId, "tool", toolCallId),
+		toolCallId,
+		toolName: call?.toolName ?? "tool",
+		input: call?.input ?? null,
+		runId: event.runId,
+		result: failed ? {
+			status: "error",
+			error: {
+				message: text(saved, "error") ?? "Tool failed.",
+				retryable: false
+			}
+		} : {
+			status: "success",
+			output: toolOutputValue(output)
+		}
+	};
+	if (call?.callId !== void 0 && result.type === "tool_result") result.callId = call.callId;
+	return [result];
+}
+function mapCompaction(event, data) {
+	const info = asCompaction(data);
+	return info === void 0 ? [] : [located(event, {
+		type: "memory_compaction",
+		...info
+	})];
+}
+function needsAttention(event, data) {
+	const operationId = text(data, "blockedOperation");
+	const details = { retryable: true };
+	if (operationId !== void 0) details.operationId = operationId;
+	return [located(event, {
+		type: "error",
+		error: {
+			name: "DurableNeedsAttention",
+			message: text(data, "error") ?? "Durable run needs attention.",
+			code: "needs_attention",
+			retryable: true,
+			details
+		}
+	}), located(event, {
+		type: "run_end",
+		status: "error"
+	})];
+}
+function failed(event, data, outcome) {
+	const error = located(event, {
+		type: "error",
+		error: {
+			name: "DurableRunError",
+			message: text(data, "error") ?? "Durable run failed.",
+			code: "failed",
+			retryable: false
+		}
+	});
+	const usage = asUsage(outcome?.usage);
+	if (usage !== void 0 && error.type === "error") error.usage = usage;
+	return [error, runEnd(event, outcome, "error")];
+}
+function settled(event, outcome, status) {
+	const outcomeType = text(outcome, "type");
+	if (status === "waiting" || outcomeType === "interaction") {
+		const interaction = asInteraction(outcome?.interaction);
+		const events = [];
+		if (interaction !== void 0) events.push(located(event, {
+			type: "interaction",
+			interaction
+		}));
+		events.push(runEnd(event, outcome, "suspended"));
+		return events;
+	}
+	if (outcomeType === "blocked") return [runEnd(event, outcome, "blocked")];
+	return [runEnd(event, outcome, "completed")];
+}
+function runEnd(event, outcome, status) {
+	const end = located(event, {
+		type: "run_end",
+		status
+	});
+	if (end.type !== "run_end") return end;
+	const value = text(outcome, "text");
+	const usage = asUsage(outcome?.usage);
+	const contextUsage = asContextUsage(outcome?.contextUsage);
+	const trace = asTrace(outcome?.trace);
+	const compaction = asCompaction(asRecord(outcome?.memoryCompaction));
+	if (value !== void 0) end.text = value;
+	if (outcome?.output !== void 0 && isJsonValue(outcome.output)) end.output = outcome.output;
+	if (usage !== void 0) end.usage = usage;
+	if (contextUsage !== void 0) end.contextUsage = contextUsage;
+	if (trace !== void 0) end.trace = trace;
+	if (compaction !== void 0) end.memoryCompaction = compaction;
+	return end;
+}
+function reasoningEnd(runId, messageId, content, state) {
+	const id = partId(messageId, "reasoning", content.id ?? "default");
+	const end = {
+		type: "reasoning_end",
+		messageId,
+		partId: id,
+		text: content.text,
+		runId
+	};
+	if (!state.openedParts.has(id)) state.openedParts.add(id);
+	if (content.details !== void 0 && end.type === "reasoning_end") end.content = content.details;
+	return end;
+}
+function toolCallEnd(runId, messageId, call, turn) {
+	const event = part(runId, turn, {
+		type: "tool_call_end",
+		messageId,
+		partId: partId(messageId, "tool", call.toolCallId),
+		toolCallId: call.toolCallId,
+		toolName: call.toolName,
+		input: call.input
+	});
+	if (event.type !== "tool_call_end") return event;
+	if (call.callId !== void 0) event.callId = call.callId;
+	if (call.signature !== void 0) event.signature = call.signature;
+	return event;
+}
+function withStart(state, messageId, kind, suffix, runId, turn, build) {
+	const id = partId(messageId, kind, suffix);
+	const started = state.openedParts.has(id);
+	if (!started) state.openedParts.add(id);
+	return build(id, started);
+}
+function part(runId, turn, event) {
+	const locatedEvent = {
+		...event,
+		runId
+	};
+	if (turn !== void 0 && "turn" in locatedEvent) locatedEvent.turn = turn;
+	else if (turn !== void 0) return {
+		...locatedEvent,
+		turn
+	};
+	return locatedEvent;
+}
+function located(event, fields) {
+	return {
+		...fields,
+		runId: event.runId
+	};
+}
+function fork(state, sequence) {
+	return {
+		messageId: state.messageId,
+		sequence,
+		openedOperations: new Set(state.openedOperations),
+		openedParts: new Set(state.openedParts),
+		tools: new Map(state.tools),
+		runOpened: state.runOpened
+	};
+}
+function partId(messageId, kind, suffix) {
+	return suffix === void 0 ? `${messageId}:${kind}` : `${messageId}:${kind}:${suffix}`;
+}
+function asRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value) || !isJsonValue(value)) return;
+	return value;
+}
+function text(value, key) {
+	const field = value?.[key];
+	return typeof field === "string" ? field : void 0;
+}
+function number(value, key) {
+	const field = value?.[key];
+	return typeof field === "number" && Number.isFinite(field) ? field : void 0;
+}
+function modelOf(data) {
+	const input = asRecord(data?.input);
+	const provider = text(input, "provider");
+	const modelId = text(input, "modelId");
+	return provider === void 0 || modelId === void 0 ? void 0 : {
+		provider,
+		modelId
+	};
+}
+const REASONING = [
+	"text",
+	"summary",
+	"encrypted",
+	"redacted"
+];
+function reasoningType(value) {
+	return REASONING.find((type) => type === value);
+}
+function asToolCall(value) {
+	const call = asRecord(value);
+	if (call?.type !== "tool-call") return void 0;
+	const toolCallId = text(call, "toolCallId");
+	const toolName = text(call, "toolName");
+	if (toolCallId === void 0 || toolName === void 0 || !isJsonValue(call.input)) return void 0;
+	const parsed = {
+		type: "tool-call",
+		toolCallId,
+		toolName,
+		input: call.input
+	};
+	const callId = text(call, "callId");
+	const signature = text(call, "signature");
+	if (callId === void 0) return signature === void 0 ? parsed : {
+		...parsed,
+		signature
+	};
+	if (signature === void 0) return {
+		...parsed,
+		callId
+	};
+	return {
+		...parsed,
+		callId,
+		signature
+	};
+}
+function asSource(value) {
+	return asRecord(value);
+}
+function asProviderToolCall(value) {
+	const call = asRecord(value);
+	return call === void 0 ? void 0 : call;
+}
+function assistantParts(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => {
+		const part = assistantPart(item);
+		return part === void 0 ? [] : [part];
+	});
+}
+function assistantPart(value) {
+	const part = asRecord(value);
+	const type = text(part, "type");
+	if (part === void 0 || type === void 0) return void 0;
+	if (type === "text" && typeof part.text === "string") return typeof part.signature === "string" ? {
+		type: "text",
+		text: part.text,
+		signature: part.signature
+	} : {
+		type: "text",
+		text: part.text
+	};
+	if (type === "reasoning" && typeof part.text === "string") {
+		const details = asReasoningDetails(part.details);
+		const base = {
+			type: "reasoning",
+			text: part.text
+		};
+		if (typeof part.id !== "string") return details === void 0 ? base : {
+			...base,
+			details
+		};
+		return details === void 0 ? {
+			...base,
+			id: part.id
+		} : {
+			...base,
+			id: part.id,
+			details
+		};
+	}
+	if (type === "tool-call") return asToolCall(part);
+}
+function asReasoningDetails(value) {
+	if (!Array.isArray(value) || !isJsonValue(value)) return void 0;
+	return value;
+}
+function asUsage(value) {
+	const usage = asRecord(value);
+	if (usage === void 0) return void 0;
+	const keys = [
+		"inputTokens",
+		"outputTokens",
+		"totalTokens",
+		"cachedInputTokens",
+		"cacheCreationInputTokens"
+	];
+	const counts = {};
+	for (const key of keys) {
+		const count = number(usage, key);
+		if (count === void 0) return void 0;
+		counts[key] = count;
+	}
+	const parsed = counts;
+	const details = asRecord(usage.details);
+	if (details !== void 0 && Object.values(details).every((item) => typeof item === "number")) parsed.details = details;
+	return parsed;
+}
+function asContextUsage(value) {
+	const usage = asRecord(value);
+	const model = asRecord(usage?.model);
+	const context = asRecord(model?.context);
+	if (usage === void 0 || typeof model?.modelId !== "string" || context === void 0) return void 0;
+	const contextWindow = number(context, "contextWindow");
+	const usedTokens = number(usage, "usedTokens");
+	const remainingTokens = number(usage, "remainingTokens");
+	const usedPercent = number(usage, "usedPercent");
+	const remainingPercent = number(usage, "remainingPercent");
+	if (contextWindow === void 0 || usedTokens === void 0 || remainingTokens === void 0 || usedPercent === void 0 || remainingPercent === void 0) return;
+	const parsed = {
+		model: {
+			modelId: model.modelId,
+			context: { contextWindow }
+		},
+		usedTokens,
+		remainingTokens,
+		usedPercent,
+		remainingPercent
+	};
+	const maxInputTokens = number(context, "maxInputTokens");
+	const maxOutputTokens = number(context, "maxOutputTokens");
+	if (maxInputTokens !== void 0) parsed.model.context.maxInputTokens = maxInputTokens;
+	if (maxOutputTokens !== void 0) parsed.model.context.maxOutputTokens = maxOutputTokens;
+	return parsed;
+}
+function asTrace(value) {
+	const trace = asRecord(value);
+	const observer = text(trace, "observer");
+	if (observer === void 0) return void 0;
+	const parsed = { observer };
+	const traceId = text(trace, "traceId");
+	const observationId = text(trace, "observationId");
+	if (traceId !== void 0) parsed.traceId = traceId;
+	if (observationId !== void 0) parsed.observationId = observationId;
+	return parsed;
+}
+function asCompaction(value) {
+	if (value === void 0) return void 0;
+	const keys = [
+		"originalMessageCount",
+		"compactedMessageCount",
+		"retainedMessageCount",
+		"originalTokenCount",
+		"compactedTokenCount",
+		"retainedTokenCount",
+		"resultTokenCount",
+		"attempts"
+	];
+	const info = {};
+	for (const key of keys) {
+		const count = number(value, key);
+		if (count === void 0) return void 0;
+		info[key] = count;
+	}
+	const usage = asUsage(value.usage);
+	if (usage === void 0) return void 0;
+	return {
+		...info,
+		usage
+	};
+}
+function asInteraction(value) {
+	const request = asRecord(value);
+	const type = text(request, "type");
+	const id = text(request, "id");
+	const toolName = text(request, "toolName");
+	const toolCallId = text(request, "toolCallId");
+	const internalCallId = text(request, "internalCallId");
+	if (request === void 0 || id === void 0 || toolName === void 0 || toolCallId === void 0 || internalCallId === void 0) return;
+	const callId = text(request, "callId");
+	const base = {
+		id,
+		toolName,
+		toolCallId,
+		internalCallId
+	};
+	if (callId !== void 0) base.callId = callId;
+	if (type === "tool-approval" && isJsonValue(request.input)) {
+		const approval = {
+			...base,
+			type: "tool-approval",
+			input: request.input
+		};
+		const reason = text(request, "reason");
+		return reason === void 0 ? approval : {
+			...approval,
+			reason
+		};
+	}
+	if (type === "tool-question" && Array.isArray(request.questions) && isJsonValue(request.questions)) return {
+		...base,
+		type,
+		questions: request.questions
+	};
+}
+function asToolOutput(value) {
+	const output = asRecord(value);
+	const type = text(output, "type");
+	if (output === void 0 || type === void 0) return void 0;
+	if ((type === "text" || type === "error-text") && typeof output.value === "string") return {
+		type,
+		value: output.value
+	};
+	if ((type === "json" || type === "error-json") && isJsonValue(output.value)) return {
+		type,
+		value: output.value
+	};
+	if (type === "execution-denied") {
+		const reason = text(output, "reason");
+		return reason === void 0 ? { type } : {
+			type,
+			reason
+		};
+	}
+	if (type === "content" && Array.isArray(output.value) && isJsonValue(output.value)) return {
+		type,
+		value: output.value
+	};
+}
+function toolOutputValue(output) {
+	if (output.type === "execution-denied") return output.reason === void 0 ? { type: output.type } : {
+		type: output.type,
+		reason: output.reason
+	};
+	return output.value;
+}
+// src/durable-chat.ts
+/**
+* Thrown when a submission is rejected because the session already has unfinished work (HTTP 409).
+* `runId` is that run when it could be read back from the session; `undefined` when the lookup
+* failed. Reattach to `runId` instead of submitting again. Aborting a stream never raises this.
+*/
+var DurableBusyError = class extends Error {
+	runId;
+	code = "session_busy";
+	constructor(runId, message = "Session already has unfinished work.") {
+		super(message);
+		this.runId = runId;
+		this.name = "DurableBusyError";
+	}
+};
+const UNFINISHED = /* @__PURE__ */ new Set([
+	"queued",
+	"retry_wait",
+	"pending",
+	"running",
+	"waiting",
+	"needs_attention"
+]);
+/**
+* Transport `useChat` can pass to talk to `@anvia/durable`.
+*
+* Only the last user message of a `messages` request is submitted; durable keeps the transcript,
+* so the rest of the client history is discarded. An `interaction_response` is delivered to the
+* remembered run and then the stream resumes from the last applied sequence. Abort detaches the
+* SSE subscription and does not cancel the run.
+*/
+function createDurableChatTransport(options) {
+	const session = {
+		cursor: 0,
+		map: createDurableChatMapState()
+	};
+	return {
+		controller: {
+			get activeRunId() {
+				return session.activeRunId;
+			},
+			reattach(runId, after = 0) {
+				assertCursor(after);
+				session.activeRunId = requireId(runId, "runId");
+				session.cursor = after;
+				session.map = createDurableChatMapState(after);
+			},
+			cancel(runId) {
+				return options.client.cancel(resolveRun(session, runId));
+			},
+			retry(runId) {
+				return options.client.retry(resolveRun(session, runId));
+			},
+			resolveTool(operationId, output, runId) {
+				return options.client.resolveTool(resolveRun(session, runId), operationId, output);
+			},
+			resolveMemoryWrite(operationKey, resolution, runId) {
+				const resolve = options.client.resolveMemoryWrite;
+				if (resolve === void 0) return Promise.reject(/* @__PURE__ */ new TypeError("The durable client does not support resolveMemoryWrite."));
+				return resolve.call(options.client, resolveRun(session, runId), operationKey, resolution);
+			}
+		},
+		async *send(send) {
+			const target = await begin(options, session, send);
+			if (session.activeRunId !== target.runId || target.after < session.cursor) session.map = createDurableChatMapState(target.after);
+			session.activeRunId = target.runId;
+			session.cursor = target.after;
+			yield* streamFrames(options.client, session, target.runId, send.abortSignal);
+		}
+	};
+}
+async function begin(options, session, send) {
+	const resume = send.resume ?? send.request.resume;
+	if (resume !== void 0) {
+		assertCursor(resume.after);
+		return {
+			runId: requireId(resume.streamId, "streamId"),
+			after: resume.after
+		};
+	}
+	if (send.request.type === "interaction_response") {
+		if (session.activeRunId === void 0) throw new Error("No active durable run to receive the interaction response.");
+		await options.client.respond(session.activeRunId, send.request.interactionId, send.request.response, send.abortSignal === void 0 ? {} : { abortSignal: send.abortSignal });
+		return {
+			runId: session.activeRunId,
+			after: session.cursor
+		};
+	}
+	return {
+		runId: await submitPrompt(options, send),
+		after: 0
+	};
+}
+async function submitPrompt(options, send) {
+	if (send.request.type !== "messages") throw new TypeError("Unsupported durable chat request.");
+	const prompt = lastUserPrompt(send.request.messages);
+	const requestId = options.requestId?.() ?? createClientId("durable");
+	const requestOptions = { enqueue: options.enqueue ?? true };
+	if (send.abortSignal !== void 0) requestOptions.abortSignal = send.abortSignal;
+	try {
+		return (await options.client.submit({
+			agentId: options.agentId,
+			sessionId: options.sessionId,
+			requestId,
+			prompt
+		}, requestOptions)).run.id;
+	} catch (error) {
+		if (!isSessionBusy(error)) throw error;
+		throw new DurableBusyError(await findBusyRun(options, send.abortSignal), error.message);
+	}
+}
+async function* streamFrames(client, session, runId, abortSignal) {
+	yield {
+		type: "stream_start",
+		protocol: CLIENT_STREAM_PROTOCOL,
+		streamId: runId,
+		eventId: 0,
+		resumable: true
+	};
+	let lastEventId = session.cursor;
+	const streamOptions = abortSignal === void 0 ? { after: session.cursor } : {
+		after: session.cursor,
+		abortSignal
+	};
+	try {
+		for await (const event of client.stream(runId, streamOptions)) {
+			const settled = needsSettledOutcome(event) ? await snapshotOutcome(client, runId, event, abortSignal) : void 0;
+			const mapped = mapDurableChatEvent(event, session.map, settled);
+			session.map = mapped.state;
+			session.cursor = mapped.state.sequence;
+			lastEventId = mapped.state.sequence;
+			for (const clientEvent of mapped.events) yield {
+				type: "stream_event",
+				streamId: runId,
+				eventId: event.sequence,
+				event: clientEvent
+			};
+		}
+	} catch (error) {
+		if (!isAbort(error, abortSignal)) yield {
+			type: "stream_end",
+			streamId: runId,
+			eventId: lastEventId,
+			status: "error"
+		};
+		throw error;
+	}
+	yield {
+		type: "stream_end",
+		streamId: runId,
+		eventId: lastEventId,
+		status: "completed"
+	};
+}
+/**
+* The outcome for a settled status event, read from the run snapshot (DUR-07 keeps it out of the
+* event). If the run has moved past that status, the snapshot describes a later point, so nothing
+* is returned and the event maps without its outcome.
+*/
+async function snapshotOutcome(client, runId, event, abortSignal) {
+	const snapshot = await client.snapshot(runId, abortSignal === void 0 ? {} : { abortSignal });
+	if (snapshot.run.status !== statusEventStatus(event)) return void 0;
+	const outcome = snapshot.run.outcome;
+	return typeof outcome === "object" && outcome !== null && !Array.isArray(outcome) && isJsonValue(outcome) ? outcome : void 0;
+}
+function lastUserPrompt(messages) {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message?.role === "user") return message;
+	}
+	throw new TypeError("Durable chat requires a user message to submit.");
+}
+function isSessionBusy(error) {
+	return error instanceof DurableHttpError && error.status === 409;
+}
+async function findBusyRun(options, abortSignal) {
+	try {
+		return (await options.client.listRuns({
+			sessionId: options.sessionId,
+			limit: 100
+		}, abortSignal === void 0 ? {} : { abortSignal })).runs.find((run) => UNFINISHED.has(run.status))?.id;
+	} catch {
+		return;
+	}
+}
+function resolveRun(session, runId) {
+	return requireId(runId ?? session.activeRunId, "run");
+}
+function requireId(value, label) {
+	if (value === void 0 || value.trim().length === 0) throw new Error(label === "run" ? "No active durable run." : `${label} must not be empty.`);
+	return value;
+}
+function assertCursor(after) {
+	if (!Number.isSafeInteger(after) || after < 0) throw new TypeError("Invalid durable resume cursor.");
+}
+function isAbort(error, signal) {
+	return signal?.aborted === true || error instanceof Error && error.name === "AbortError";
+}
+export { DurableBusyError, createDurableChatTransport };
+
+//# sourceMappingURL=durable-chat.js.map