@assistant-ui/eve 0.0.24 → 0.0.25

package/dist/convertEveMessages.d.ts

@@ -1,11 +1,11 @@
 import { type AppendMessage, type RespondToToolApprovalOptions, type ThreadMessage } from "@assistant-ui/core";
-import type { EveAuthorizationOutcome, EveAuthorizationPart, EveMessage, EveMessageData, EveMessageInputRequest } from "eve/react";
-import type { InputResponse } from "eve/client";
-import type { MessageStreamEvent } from "eve/client";
+import type { EveMessage, Interaction } from "eve/react";
+import type { ConversationState, SessionStreamEvent } from "eve/client";
+import { type Answer } from "eve/events";
 export type ConvertEveMessagesOptions = {
     /**
-     * Marks the last assistant message as running while Eve is submitting or
-     * streaming. When omitted, a message carrying Eve's `"streaming"` marker is
+     * Marks the last assistant message as running while Eve has a turn in
+     * flight. When omitted, a message carrying Eve's `"streaming"` marker is
      * treated as running; pass `false` to settle interrupted messages to a
      * terminal status.
      */
@@ -16,25 +16,22 @@ export type ConvertEveMessagesOptions = {
     readonly error?: unknown;
     readonly getCreatedAt?: ((message: EveMessage) => Date) | undefined;
     /**
-     * The session's stream events. A `turn.failed` or `turn.cancelled` event
-     * marks its turn's assistant message as incomplete, with a failure's code
-     * and message as its error.
+     * The session's stream events. A failed or cancelled turn marks its
+     * assistant message as incomplete, with a failure's code and message as its
+     * error.
      */
-    readonly events?: readonly MessageStreamEvent[] | undefined;
+    readonly events?: readonly SessionStreamEvent[] | undefined;
 };
 /**
- * Payload of the `authorization` data part the Eve runtime emits for a
- * connector authorization challenge. `state` discriminates a pending challenge
- * from a settled one; every other field is present only when Eve projected it.
- * This converter drops a `url` whose scheme is not `http(s)`, so a renderer can
- * link to it without checking the scheme itself; Eve itself passes through
- * whatever the connector supplied. Eve's
- * `turnId` and `stepIndex` part identity is omitted: a renderer receives the
- * one part it renders, in Eve's own step order, so display never has to
- * re-identify a challenge among several.
+ * Payload of the `authorization` data part the Eve runtime emits for a sign-in
+ * interaction. `state` discriminates a pending sign-in from a settled one;
+ * every other field is present only when Eve projected it. This converter
+ * drops a `url` whose scheme is not `http(s)`, so a renderer can link to it
+ * without checking the scheme itself; Eve itself passes through whatever the
+ * connector supplied.
  */
 export type EveAuthorizationData = {
-    readonly state: EveAuthorizationPart["state"];
+    readonly state: "required" | "completed";
     readonly name: string;
     readonly displayName?: string;
     readonly description?: string;
@@ -42,7 +39,7 @@ export type EveAuthorizationData = {
     readonly userCode?: string;
     readonly instructions?: string;
     readonly expiresAt?: string;
-    readonly outcome?: EveAuthorizationOutcome;
+    readonly outcome?: "authorized" | "declined" | "failed" | "timed-out" | "cancelled";
     readonly reason?: string;
 };
 /**
@@ -50,23 +47,18 @@ export type EveAuthorizationData = {
  */
 export declare const convertEveMessage: (message: EveMessage, index: number, messages: readonly EveMessage[], options?: ConvertEveMessagesOptions) => ThreadMessage;
 export type InterruptedTurnEventCache = {
-    lastEvents: readonly MessageStreamEvent[];
-    interruptions: readonly MessageStreamEvent[];
+    lastEvents: readonly SessionStreamEvent[];
+    interruptions: readonly SessionStreamEvent[];
 };
+export declare const collectInterruptedTurnEvents: (events: readonly SessionStreamEvent[], cache: InterruptedTurnEventCache) => readonly SessionStreamEvent[];
 /**
- * Collects the `turn.failed` and `turn.cancelled` events of an append-only
- * event log, scanning only the events appended since the cached call. The
- * returned array keeps its identity until a new interruption arrives.
+ * Converts Eve's conversation messages into assistant-ui thread messages.
  */
-export declare const collectInterruptedTurnEvents: (events: readonly MessageStreamEvent[], cache: InterruptedTurnEventCache) => readonly MessageStreamEvent[];
+export declare const convertEveMessages: (data: Pick<ConversationState, "messages">, options?: ConvertEveMessagesOptions) => ThreadMessage[];
 /**
- * Converts the full Eve message data object into assistant-ui thread messages.
- */
-export declare const convertEveMessages: (data: EveMessageData, options?: ConvertEveMessagesOptions) => ThreadMessage[];
-/**
- * Structural subset of the `string | UserContent` message content Eve's `send`
- * API accepts. The helpers declare the shapes they produce and leave
- * assignability to the send call site, checked against the installed version.
+ * Structural subset of the message content Eve's `send` API accepts. The
+ * helpers declare the shapes they produce and leave assignability to the send
+ * call site, checked against the installed version.
  */
 export type EveMessageContent = string | ({
     readonly type: "text";
@@ -83,34 +75,31 @@ export type EveMessageContent = string | ({
  */
 export declare const getEveMessageContent: (message: AppendMessage) => EveMessageContent;
 /**
- * Finds the pending input request answered by the given approval id, so the
- * response mapping can honor the request's display mode.
+ * Finds the request of the interaction answered by the given approval id, so
+ * the answer mapping can honor the request's display mode.
  */
-export declare const findEveInputRequest: (data: EveMessageData, approvalId: string) => EveMessageInputRequest | undefined;
+export declare const findEveInputRequest: (data: Pick<ConversationState, "messages">, approvalId: string) => Interaction["request"] | undefined;
 /**
- * Converts an assistant-ui tool approval response into an Eve input response.
+ * Converts an assistant-ui tool approval response into an Eve `Answer`.
  *
- * When `inputRequest` is known, every returned response carries either an
- * option the request declares or a free-form answer. A literal option match
- * wins, then the `"approve"` / `"cancel"` option the response's boolean decision
+ * When `inputRequest` is known, every returned answer carries an option the
+ * request declares, the literal `"approve"` / `"deny"` for an approval that
+ * declares no options, or a free-form answer. A literal option match wins,
+ * then the `"approve"` / `"deny"` option the response's boolean decision
  * names, then the response's `text` (or its `reason`, for a caller that
  * predates the first-class answer field) when the request takes a free-form
  * answer (`display: "text"`, `allowFreeform`, or no options at all, and never
  * `display: "confirmation"`) and the response is not a refusal.
- * A one-argument call, or a part with no request, still forwards a caller
- * `optionId` as it always has, including ids the request never declared.
  *
  * A response the known request cannot record as the answer it asked for throws
- * instead of being submitted, because eve resolves a request the moment any
- * response for it arrives, and an empty one is recorded as an answer with no
- * content. Not sending leaves the request pending, so the caller can retry or
+ * instead of being submitted, because Eve resolves an interaction the moment
+ * any answer for it arrives, and an empty one is recorded as an answer with no
+ * content. Not sending leaves the interaction open, so the caller can retry or
  * the user can answer it as an ordinary message.
  *
- * With no request to map against — a one-argument call, or a part carrying no
- * `toolMetadata.eve.inputRequest` — the response maps as it always has, to the
- * literal `"approve"` / `"cancel"` option every eve approval declares. Guessing
- * a display mode is what this mapper stopped doing; an unknown request is not
- * a guess about one.
+ * With no request to map against, a one-argument call forwards a caller
+ * `optionId` as is and otherwise maps the decision to the literal `"approve"` /
+ * `"deny"` option every Eve approval declares.
  */
-export declare const toEveInputResponse: (response: RespondToToolApprovalOptions, inputRequest?: EveMessageInputRequest) => InputResponse;
+export declare const toEveInputResponse: (response: RespondToToolApprovalOptions, inputRequest?: Interaction["request"]) => Answer;
 //# sourceMappingURL=convertEveMessages.d.ts.map

package/dist/convertEveMessages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convertEveMessages.d.ts","sourceRoot":"","sources":["../src/convertEveMessages.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"convertEveMessages.d.ts","sourceRoot":"","sources":["../src/convertEveMessages.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAOlB,KAAK,4BAA4B,EAEjC,KAAK,aAAa,EAMnB,MAAM,oBAAoB,CAAC;AAQ5B,OAAO,KAAK,EACV,UAAU,EAGV,WAAW,EACZ,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACxE,OAAO,EAGL,KAAK,MAAM,EAEZ,MAAM,YAAY,CAAC;AAqBpB,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACzC;;OAEG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,UAAU,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IACpE;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,kBAAkB,EAAE,GAAG,SAAS,CAAC;CAC7D,CAAC;AA4PF;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EACb,YAAY,GACZ,UAAU,GACV,QAAQ,GACR,WAAW,GACX,WAAW,CAAC;IAChB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAyKF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,UAAU,EACnB,OAAO,MAAM,EACb,UAAU,SAAS,UAAU,EAAE,EAC/B,UAAS,yBAA8B,KACtC,aAOA,CAAC;AA8CJ,MAAM,MAAM,yBAAyB,GAAG;IACtC,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC1C,aAAa,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAC9C,CAAC;AAMF,eAAO,MAAM,4BAA4B,GACvC,QAAQ,SAAS,kBAAkB,EAAE,EACrC,OAAO,yBAAyB,KAC/B,SAAS,kBAAkB,EAqB7B,CAAC;AAqCF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC7B,MAAM,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC,EACzC,UAAS,yBAA8B,KACtC,aAAa,EAWf,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GACzB,MAAM,GACN,CACI;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,CACJ,EAAE,CAAC;AAMR;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS,aAAa,KACrB,iBA8EF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC9B,MAAM,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC,EACzC,YAAY,MAAM,KACjB,WAAW,CAAC,SAAS,CAAC,GAAG,SAa3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,kBAAkB,GAC7B,UAAU,4BAA4B,EACtC,eAAe,WAAW,CAAC,SAAS,CAAC,KACpC,MAmDF,CAAC"}

package/dist/convertEveMessages.js

@@ -1,6 +1,7 @@
 import { fromThreadMessageLike, toAssistantError } from "@assistant-ui/core";
 import { httpUrlPattern, resolveFileMediaType, resolveFilePartSource, resolveImageMediaType, toMediaWireUrl } from "@assistant-ui/core/internal";
-//#region src/convertEveMessages.ts
+import { APPROVE_OPTION_ID, DENY_OPTION_ID } from "eve/events";
+// src/convertEveMessages.ts
 const ASSISTANT_COMPLETE_STATUS = {
 	type: "complete",
 	reason: "stop"
@@ -32,8 +33,9 @@ const toMessageStatus = (message, index, messages, options, interruptedTurns) =>
 	const interrupted = message.metadata?.turnId === void 0 ? void 0 : interruptedTurns.get(message.metadata.turnId);
 	if (interrupted) return interrupted;
 	const isLast = index === messages.length - 1;
-	const hasPendingApproval = message.parts.some((part) => part.type === "dynamic-tool" && part.state === "approval-requested");
-	const hasPendingAuthorization = message.metadata?.status === "streaming" && (!isLast || options.error === void 0) && message.parts.some((part) => part.type === "authorization" && part.state === "required");
+	const interactions = message.parts.flatMap((part) => part.type === "interaction" ? [part] : part.type === "tool" && part.interaction ? [part.interaction] : []);
+	const hasPendingApproval = interactions.some((interaction) => interaction.status === "open" && interaction.request.kind !== "sign-in");
+	const hasPendingAuthorization = message.metadata?.status === "streaming" && (!isLast || options.error === void 0) && interactions.some((interaction) => interaction.status === "open" && interaction.request.kind === "sign-in");
 	if (hasPendingApproval) return {
 		type: "requires-action",
 		reason: "tool-calls"
@@ -63,19 +65,19 @@ const toolApprovalOptionsFromInputRequest = (inputRequest) => {
 	if (!options || options.length === 0) return void 0;
 	return options.map((option) => ({
 		id: option.id,
-		kind: option.id === "approve" ? "allow-once" : option.id === "cancel" ? "reject-once" : `_${option.id}`,
+		kind: option.id === APPROVE_OPTION_ID ? "allow-once" : option.id === DENY_OPTION_ID ? "reject-once" : `_${option.id}`,
 		...option.label && { label: option.label },
 		...option.description && { description: option.description }
 	}));
 };
 /**
-* Eve resolves a request the moment any response for it arrives, so the answer
-* shapes it accepts decide both what the renderer may offer and what
+* Eve resolves an interaction the moment any answer for it arrives, so the
+* answer shapes it accepts decide both what the renderer may offer and what
 * {@link toEveInputResponse} may submit. A request with no options and no
 * `display` takes a typed answer, which is why the absence of both is not the
 * same as a confirmation.
 */
-const isDroppedOptionApproval = (inputRequest) => inputRequest.kind === "tool-approval" && !inputRequest.options?.length;
+const isDroppedOptionApproval = (inputRequest) => inputRequest.kind === "approval" && !inputRequest.options?.length;
 const acceptsFreeformAnswer = (inputRequest) => inputRequest.display !== "confirmation" && !isDroppedOptionApproval(inputRequest) && (inputRequest.display === "text" || inputRequest.allowFreeform === true || !inputRequest.options?.length);
 const toolApprovalDisplay = (inputRequest) => {
 	if (isDroppedOptionApproval(inputRequest)) return "decision";
@@ -84,93 +86,119 @@ const toolApprovalDisplay = (inputRequest) => {
 		case "select": return "select";
 		case "text": return "text";
 		default:
-			if (inputRequest.kind === "tool-approval") return "decision";
+			if (inputRequest.kind === "approval") return "decision";
 			return inputRequest.options?.length ? "select" : "text";
 	}
 };
-const toApproval = (part) => {
-	if (part.state !== "approval-requested" && part.state !== "approval-responded" && part.state !== "output-available" && part.state !== "output-error" && part.state !== "output-denied") return;
-	const approval = part.approval;
-	if (!approval) return void 0;
-	const inputRequest = part.toolMetadata?.eve?.inputRequest;
-	const options = toolApprovalOptionsFromInputRequest(inputRequest);
+const toApproval = (interaction) => {
+	const request = interaction.request;
+	const options = toolApprovalOptionsFromInputRequest(request);
+	const settled = interaction.status === "settled";
+	const approved = interaction.outcome === "accepted" ? true : interaction.outcome === "declined" ? false : void 0;
 	return {
-		id: approval.id,
-		...inputRequest && {
-			prompt: inputRequest.prompt,
-			display: toolApprovalDisplay(inputRequest),
-			...acceptsFreeformAnswer(inputRequest) && { allowFreeform: true }
-		},
-		...approval.approved !== void 0 && { approved: approval.approved },
-		...approval.reason && { reason: approval.reason },
-		...approval.isAutomatic !== void 0 && { isAutomatic: approval.isAutomatic },
+		id: interaction.interactionId,
+		prompt: request.prompt,
+		display: toolApprovalDisplay(request),
+		...acceptsFreeformAnswer(request) && { allowFreeform: true },
+		...settled && approved !== void 0 && { approved },
+		...settled && approved === void 0 && { resolution: interaction.outcome === "expired" ? "expired" : "cancelled" },
+		...interaction.reason && { reason: interaction.reason },
+		...settled && interaction.answer?.optionId !== void 0 && { optionId: interaction.answer.optionId },
+		...settled && interaction.answer?.text !== void 0 && { text: interaction.answer.text },
 		...options && { options }
 	};
 };
-const toJsonSafeInputRequest = (inputRequest) => ({
-	requestId: inputRequest.requestId,
-	prompt: inputRequest.prompt,
-	kind: inputRequest.kind,
-	...inputRequest.display !== void 0 && { display: inputRequest.display },
-	...inputRequest.allowFreeform !== void 0 && { allowFreeform: inputRequest.allowFreeform },
-	...inputRequest.options && { options: inputRequest.options.map((option) => ({
-		id: option.id,
-		label: option.label,
-		...option.description !== void 0 && { description: option.description },
-		...option.style !== void 0 && { style: option.style }
-	})) }
-});
-const toToolProviderMetadata = (part) => {
-	const inputRequest = part.toolMetadata?.eve?.inputRequest;
-	if (!inputRequest) return void 0;
-	return { eve: { inputRequest: toJsonSafeInputRequest(inputRequest) } };
+const toToolProviderMetadata = (interaction) => {
+	const request = interaction.request;
+	return { eve: { interaction: {
+		interactionId: interaction.interactionId,
+		prompt: request.prompt,
+		kind: request.kind,
+		...request.display !== void 0 && { display: request.display },
+		...request.allowFreeform !== void 0 && { allowFreeform: request.allowFreeform },
+		...request.options && { options: request.options.map((option) => ({ ...option })) }
+	} } };
 };
-const convertDynamicToolPart = (part) => {
-	const approval = toApproval(part);
-	const providerMetadata = toToolProviderMetadata(part);
+const convertToolPart = (part) => {
 	const toolCall = {
 		type: "tool-call",
-		toolCallId: part.toolCallId,
-		toolName: part.toolName,
-		args: toJsonObject(part.input),
-		argsText: part.state === "input-streaming" ? "" : stringifyArgs(part.input),
-		...approval && { approval },
-		...providerMetadata && { providerMetadata }
+		toolCallId: part.callId,
+		toolName: part.name,
+		...part.state !== "streaming" && { args: toJsonObject(part.input) },
+		argsText: part.state === "streaming" ? part.inputText : stringifyArgs(part.input),
+		...part.interaction && {
+			approval: toApproval(part.interaction),
+			providerMetadata: toToolProviderMetadata(part.interaction)
+		}
 	};
 	switch (part.state) {
-		case "output-available": return {
+		case "completed": return {
 			...toolCall,
 			result: part.output
 		};
-		case "output-error": return {
+		case "failed":
+		case "rejected":
+		case "cancelled": return {
 			...toolCall,
-			result: { error: part.errorText },
+			result: { error: part.error?.message ?? part.interaction?.reason ?? (part.state === "rejected" ? "Tool approval denied" : part.state === "cancelled" ? "Tool call cancelled" : "Tool call failed") },
 			isError: true
 		};
-		case "output-denied": return {
+		default: return part.output === void 0 ? toolCall : {
 			...toolCall,
-			result: { error: part.approval?.reason ?? "Tool approval denied" },
-			isError: true
+			result: part.output,
+			isPreliminary: true
 		};
-		default: return toolCall;
 	}
 };
-const convertAuthorizationPart = (part) => ({
-	type: "data",
-	name: "authorization",
-	data: {
-		state: part.state,
-		name: part.name,
-		...part.displayName !== void 0 && { displayName: part.displayName },
-		...part.description !== void 0 && { description: part.description },
-		...part.authorization?.url !== void 0 && httpUrlPattern.test(part.authorization.url) && { url: part.authorization.url },
-		...part.authorization?.userCode !== void 0 && { userCode: part.authorization.userCode },
-		...part.authorization?.instructions !== void 0 && { instructions: part.authorization.instructions },
-		...part.authorization?.expiresAt !== void 0 && { expiresAt: part.authorization.expiresAt },
-		...part.outcome !== void 0 && { outcome: part.outcome },
-		...part.reason !== void 0 && { reason: part.reason }
+const toAuthorizationOutcome = (outcome) => {
+	switch (outcome) {
+		case "accepted": return "authorized";
+		case "declined":
+		case "invalid": return "declined";
+		case "expired": return "timed-out";
+		case "failed": return "failed";
+		default: return "cancelled";
 	}
-});
+};
+const convertAuthorizationPart = (interaction) => {
+	const signIn = interaction.request.signIn;
+	return {
+		type: "data",
+		name: "authorization",
+		data: {
+			state: interaction.status === "open" ? "required" : "completed",
+			name: signIn?.name ?? interaction.request.title ?? "sign-in",
+			...signIn?.displayName !== void 0 && { displayName: signIn.displayName },
+			description: interaction.request.prompt,
+			...signIn?.url !== void 0 && httpUrlPattern.test(signIn.url) && { url: signIn.url },
+			...signIn?.userCode !== void 0 && { userCode: signIn.userCode },
+			...signIn?.instructions !== void 0 && { instructions: signIn.instructions },
+			...signIn?.expiresAt !== void 0 && { expiresAt: signIn.expiresAt },
+			...interaction.outcome !== void 0 && { outcome: toAuthorizationOutcome(interaction.outcome) },
+			...interaction.reason !== void 0 && { reason: interaction.reason }
+		}
+	};
+};
+const convertInteractionPart = (interaction) => {
+	if (interaction.request.kind === "sign-in") return convertAuthorizationPart(interaction);
+	const approval = toApproval(interaction);
+	return {
+		type: "tool-call",
+		toolCallId: interaction.interactionId,
+		toolName: interaction.call?.name ?? interaction.request.kind,
+		args: toJsonObject(interaction.call?.input),
+		argsText: stringifyArgs(interaction.call?.input),
+		approval,
+		providerMetadata: toToolProviderMetadata(interaction),
+		...interaction.status === "settled" && {
+			result: interaction.answer ?? {
+				outcome: interaction.outcome,
+				reason: interaction.reason
+			},
+			...interaction.outcome !== "accepted" && { isError: true }
+		}
+	};
+};
 const convertFilePart = (part) => {
 	if (part.url === void 0) return null;
 	return {
@@ -193,9 +221,8 @@ const convertAssistantPart = (part) => {
 				...status && { status }
 			};
 		}
-		case "step-start": return null;
-		case "dynamic-tool": return convertDynamicToolPart(part);
-		case "authorization": return convertAuthorizationPart(part);
+		case "tool": return convertToolPart(part);
+		case "interaction": return convertInteractionPart(part);
 		case "file": return convertFilePart(part);
 		default: return null;
 	}
@@ -265,40 +292,43 @@ const convertEveMessageWithInterruptions = (message, index, messages, options, i
 	};
 	return fromThreadMessageLike(like, message.id, toMessageStatus(message, index, messages, options, interruptedTurns));
 };
-const isTurnInterruption = (event) => event.type === "turn.failed" || event.type === "turn.cancelled";
-/**
-* Collects the `turn.failed` and `turn.cancelled` events of an append-only
-* event log, scanning only the events appended since the cached call. The
-* returned array keeps its identity until a new interruption arrives.
-*/
+const isTurnInterruption = (event) => event.type === "turn.settled" && event.data.outcome !== "completed" || event.type === "session.ended" && event.data.outcome === "failed";
 const collectInterruptedTurnEvents = (events, cache) => {
 	if (events === cache.lastEvents) return cache.interruptions;
 	const scanned = cache.lastEvents;
 	const resumesScan = scanned.length === 0 || events[scanned.length - 1] === scanned[scanned.length - 1];
-	let interruptions = resumesScan ? cache.interruptions : [];
+	const interruptions = resumesScan ? cache.interruptions : [];
+	let nextInterruptions;
 	for (let i = resumesScan ? scanned.length : 0; i < events.length; i++) {
 		const event = events[i];
-		if (isTurnInterruption(event)) interruptions = [...interruptions, event];
+		if (isTurnInterruption(event)) {
+			nextInterruptions ??= [...interruptions];
+			nextInterruptions.push(event);
+		}
 	}
 	cache.lastEvents = events;
-	cache.interruptions = interruptions;
-	return interruptions;
+	cache.interruptions = nextInterruptions ?? interruptions;
+	return cache.interruptions;
 };
 const getInterruptedTurns = (events) => {
 	const interrupted = /* @__PURE__ */ new Map();
-	for (const event of events ?? []) if (event.type === "turn.failed") interrupted.set(event.data.turnId, {
+	const sessionFailures = /* @__PURE__ */ new Map();
+	for (const event of events ?? []) if (event.type === "turn.settled" && event.data.outcome === "failed") interrupted.set(event.data.turnId, {
 		type: "incomplete",
 		reason: "error",
-		error: {
-			code: event.data.code,
-			message: event.data.message
-		}
+		...event.data.error && { error: toAssistantError(event.data.error) }
 	});
-	else if (event.type === "turn.cancelled") interrupted.set(event.data.turnId, ASSISTANT_CANCELLED_STATUS);
+	else if (event.type === "turn.settled" && event.data.outcome === "cancelled") interrupted.set(event.data.turnId, ASSISTANT_CANCELLED_STATUS);
+	else if (event.type === "session.ended" && event.data.outcome === "failed" && event.data.cause && "turnId" in event.data.cause) sessionFailures.set(event.data.cause.turnId, {
+		type: "incomplete",
+		reason: "error",
+		...event.data.error && { error: toAssistantError(event.data.error) }
+	});
+	for (const [turnId, status] of sessionFailures) interrupted.set(turnId, status);
 	return interrupted;
 };
 /**
-* Converts the full Eve message data object into assistant-ui thread messages.
+* Converts Eve's conversation messages into assistant-ui thread messages.
 */
 const convertEveMessages = (data, options = {}) => {
 	const interruptedTurns = getInterruptedTurns(options.events);
@@ -358,63 +388,62 @@ const getEveMessageContent = (message) => {
 	return parts;
 };
 /**
-* Finds the pending input request answered by the given approval id, so the
-* response mapping can honor the request's display mode.
+* Finds the request of the interaction answered by the given approval id, so
+* the answer mapping can honor the request's display mode.
 */
 const findEveInputRequest = (data, approvalId) => {
-	for (const message of data.messages) for (const part of message.parts) if (part.type === "dynamic-tool" && part.approval?.id === approvalId) return part.toolMetadata?.eve?.inputRequest;
+	for (const message of data.messages) for (const part of message.parts) {
+		const interaction = part.type === "interaction" ? part : part.type === "tool" ? part.interaction : void 0;
+		if (interaction?.interactionId === approvalId) return interaction.request;
+	}
 };
 /**
-* Converts an assistant-ui tool approval response into an Eve input response.
+* Converts an assistant-ui tool approval response into an Eve `Answer`.
 *
-* When `inputRequest` is known, every returned response carries either an
-* option the request declares or a free-form answer. A literal option match
-* wins, then the `"approve"` / `"cancel"` option the response's boolean decision
+* When `inputRequest` is known, every returned answer carries an option the
+* request declares, the literal `"approve"` / `"deny"` for an approval that
+* declares no options, or a free-form answer. A literal option match wins,
+* then the `"approve"` / `"deny"` option the response's boolean decision
 * names, then the response's `text` (or its `reason`, for a caller that
 * predates the first-class answer field) when the request takes a free-form
 * answer (`display: "text"`, `allowFreeform`, or no options at all, and never
 * `display: "confirmation"`) and the response is not a refusal.
-* A one-argument call, or a part with no request, still forwards a caller
-* `optionId` as it always has, including ids the request never declared.
 *
 * A response the known request cannot record as the answer it asked for throws
-* instead of being submitted, because eve resolves a request the moment any
-* response for it arrives, and an empty one is recorded as an answer with no
-* content. Not sending leaves the request pending, so the caller can retry or
+* instead of being submitted, because Eve resolves an interaction the moment
+* any answer for it arrives, and an empty one is recorded as an answer with no
+* content. Not sending leaves the interaction open, so the caller can retry or
 * the user can answer it as an ordinary message.
 *
-* With no request to map against — a one-argument call, or a part carrying no
-* `toolMetadata.eve.inputRequest` — the response maps as it always has, to the
-* literal `"approve"` / `"cancel"` option every eve approval declares. Guessing
-* a display mode is what this mapper stopped doing; an unknown request is not
-* a guess about one.
+* With no request to map against, a one-argument call forwards a caller
+* `optionId` as is and otherwise maps the decision to the literal `"approve"` /
+* `"deny"` option every Eve approval declares.
 */
 const toEveInputResponse = (response, inputRequest) => {
-	const requestId = response.approvalId;
+	const interactionId = response.approvalId;
 	const options = inputRequest?.options;
 	const text = response.text ?? response.reason;
 	if (response.optionId !== void 0) {
 		if (!inputRequest || options?.some((option) => option.id === response.optionId)) return {
-			requestId,
+			interactionId,
 			optionId: response.optionId,
 			...text && { text }
 		};
-		throw new Error(`Eve input request "${requestId}" has no option with id "${response.optionId}"; respond with one of: ${options?.length ? options.map((option) => option.id).join(", ") : "(the request carries no options)"}`);
+		throw new Error(`Eve interaction "${interactionId}" has no option with id "${response.optionId}"; respond with one of: ${options?.length ? options.map((option) => option.id).join(", ") : "(the request carries no options)"}`);
 	}
-	const decisionOptionId = response.approved ? "approve" : "cancel";
-	if (!inputRequest || inputRequest.kind === "tool-approval" && !options?.length || options?.some((option) => option.id === decisionOptionId)) return {
-		requestId,
+	const decisionOptionId = response.approved ? APPROVE_OPTION_ID : DENY_OPTION_ID;
+	if (!inputRequest || inputRequest.kind === "approval" && !options?.length || options?.some((option) => option.id === decisionOptionId)) return {
+		interactionId,
 		optionId: decisionOptionId,
 		...text && { text }
 	};
 	const acceptsText = acceptsFreeformAnswer(inputRequest);
 	if (acceptsText && text && response.approved !== false) return {
-		requestId,
+		interactionId,
 		text
 	};
-	throw new Error(`Eve input request "${requestId}" (${inputRequest.prompt}) was not answered by this response; ${options?.length ? `respond with one of: ${options.map((option) => option.id).join(", ")}` : !acceptsText ? "the request declares no options to respond with" : response.approved === false ? "a refusal carries no answer for a free-form request; resend with `approved` unset or true and the answer in the response text" : "pass the answer as the response text, because the request takes a free-form answer"}`);
+	throw new Error(`Eve interaction "${interactionId}" (${inputRequest.prompt}) was not answered by this response; ${options?.length ? `respond with one of: ${options.map((option) => option.id).join(", ")}` : !acceptsText ? "the request declares no options to respond with" : response.approved === false ? "a refusal carries no answer for a free-form request; resend with `approved` unset or true and the answer in the response text" : "pass the answer as the response text, because the request takes a free-form answer"}`);
 };
-//#endregion
 export { collectInterruptedTurnEvents, convertEveMessage, convertEveMessages, findEveInputRequest, getEveMessageContent, toEveInputResponse };
 
 //# sourceMappingURL=convertEveMessages.js.map