@syntrologie/adapt-chatbot 2.28.0 → 2.29.1

package/dist/{chunk-KUO67E2W.js → chunk-A3TIGA4G.js}

@@ -4,7 +4,7 @@ import {
   TILE_REPLAY_REQUEST_EVENT,
   TILE_UNMOUNTED_EVENT,
   stripMountPlumbing
-} from "./chunk-435KJD27.js";
+} from "./chunk-EACGDSJI.js";
 import {
   __export
 } from "./chunk-UVKRO5ER.js";
@@ -209,6 +209,20 @@ var ToolSchema = z.object({
   parameters: z.any(),
   metadata: z.record(z.any()).optional()
 });
+var InterruptSchema = z.object({
+  id: z.string(),
+  reason: z.string(),
+  message: z.string().optional(),
+  toolCallId: z.string().optional(),
+  responseSchema: z.record(z.any()).optional(),
+  expiresAt: z.string().optional(),
+  metadata: z.record(z.any()).optional()
+});
+var ResumeEntrySchema = z.object({
+  interruptId: z.string(),
+  status: z.enum(["resolved", "cancelled"]),
+  payload: z.any().optional()
+});
 var RunAgentInputSchema = z.object({
   threadId: z.string(),
   runId: z.string(),
@@ -217,7 +231,8 @@ var RunAgentInputSchema = z.object({
   messages: z.array(MessageSchema),
   tools: z.array(ToolSchema),
   context: z.array(ContextSchema),
-  forwardedProps: z.any()
+  forwardedProps: z.any(),
+  resume: z.array(ResumeEntrySchema).optional()
 });
 var StateSchema = z.any();
 var AGUIError = class extends Error {
@@ -302,7 +317,9 @@ var HumanInTheLoopCapabilitiesSchema = z.object({
   supported: z.boolean().optional(),
   approvals: z.boolean().optional(),
   interventions: z.boolean().optional(),
-  feedback: z.boolean().optional()
+  feedback: z.boolean().optional(),
+  interrupts: z.boolean().optional(),
+  approveWithEdits: z.boolean().optional()
 });
 var AgentCapabilitiesSchema = z.object({
   identity: IdentityCapabilitiesSchema.optional(),
@@ -468,26 +485,12 @@ var RunStartedEventSchema = BaseEventSchema.extend({
   parentRunId: z.string().optional(),
   input: RunAgentInputSchema.optional()
 });
-var InterruptSchema = z.object({
-  id: z.string(),
-  reason: z.string(),
-  message: z.string().optional(),
-  toolCallId: z.string().optional(),
-  responseSchema: z.record(z.any()).optional(),
-  expiresAt: z.string().optional(),
-  metadata: z.record(z.any()).optional()
-});
-var RunFinishedSuccessOutcomeSchema = z.object({
-  type: z.literal("success")
-}).strict();
+var RunFinishedSuccessOutcomeSchema = z.object({ type: z.literal("success") }).strict();
 var RunFinishedInterruptOutcomeSchema = z.object({
   type: z.literal("interrupt"),
   interrupts: z.array(InterruptSchema).min(1)
 }).strict();
-var RunFinishedOutcomeSchema = z.discriminatedUnion("type", [
-  RunFinishedSuccessOutcomeSchema,
-  RunFinishedInterruptOutcomeSchema
-]);
+var RunFinishedOutcomeSchema = z.discriminatedUnion("type", [RunFinishedSuccessOutcomeSchema, RunFinishedInterruptOutcomeSchema]);
 var RunFinishedEventSchema = BaseEventSchema.extend({
   type: z.literal(EventType.RUN_FINISHED),
   threadId: z.string(),
@@ -4897,6 +4900,84 @@ var Message = {
     return message;
   }
 };
+function createBaseInterrupt() {
+  return {
+    id: "",
+    reason: "",
+    message: void 0,
+    toolCallId: void 0,
+    responseSchema: void 0,
+    expiresAt: void 0,
+    metadata: void 0
+  };
+}
+var Interrupt = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.id !== "") writer.uint32(10).string(message.id);
+    if (message.reason !== "") writer.uint32(18).string(message.reason);
+    if (message.message !== void 0) writer.uint32(26).string(message.message);
+    if (message.toolCallId !== void 0) writer.uint32(34).string(message.toolCallId);
+    if (message.responseSchema !== void 0) Value.encode(Value.wrap(message.responseSchema), writer.uint32(42).fork()).join();
+    if (message.expiresAt !== void 0) writer.uint32(50).string(message.expiresAt);
+    if (message.metadata !== void 0) Value.encode(Value.wrap(message.metadata), writer.uint32(58).fork()).join();
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseInterrupt();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) break;
+          message.id = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) break;
+          message.reason = reader.string();
+          continue;
+        case 3:
+          if (tag !== 26) break;
+          message.message = reader.string();
+          continue;
+        case 4:
+          if (tag !== 34) break;
+          message.toolCallId = reader.string();
+          continue;
+        case 5:
+          if (tag !== 42) break;
+          message.responseSchema = Value.unwrap(Value.decode(reader, reader.uint32()));
+          continue;
+        case 6:
+          if (tag !== 50) break;
+          message.expiresAt = reader.string();
+          continue;
+        case 7:
+          if (tag !== 58) break;
+          message.metadata = Value.unwrap(Value.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) break;
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  create(base) {
+    return Interrupt.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseInterrupt();
+    message.id = object.id ?? "";
+    message.reason = object.reason ?? "";
+    message.message = object.message ?? void 0;
+    message.toolCallId = object.toolCallId ?? void 0;
+    message.responseSchema = object.responseSchema ?? void 0;
+    message.expiresAt = object.expiresAt ?? void 0;
+    message.metadata = object.metadata ?? void 0;
+    return message;
+  }
+};
 var EventType$1 = /* @__PURE__ */ (function(EventType2) {
   EventType2[EventType2["TEXT_MESSAGE_START"] = 0] = "TEXT_MESSAGE_START";
   EventType2[EventType2["TEXT_MESSAGE_CONTENT"] = 1] = "TEXT_MESSAGE_CONTENT";
@@ -5551,7 +5632,9 @@ function createBaseRunFinishedEvent() {
     baseEvent: void 0,
     threadId: "",
     runId: "",
-    result: void 0
+    result: void 0,
+    outcome: "",
+    interrupts: []
   };
 }
 var RunFinishedEvent = {
@@ -5560,6 +5643,8 @@ var RunFinishedEvent = {
     if (message.threadId !== "") writer.uint32(18).string(message.threadId);
     if (message.runId !== "") writer.uint32(26).string(message.runId);
     if (message.result !== void 0) Value.encode(Value.wrap(message.result), writer.uint32(34).fork()).join();
+    if (message.outcome !== "") writer.uint32(42).string(message.outcome);
+    for (const v of message.interrupts) Interrupt.encode(v, writer.uint32(50).fork()).join();
     return writer;
   },
   decode(input, length) {
@@ -5585,6 +5670,14 @@ var RunFinishedEvent = {
           if (tag !== 34) break;
           message.result = Value.unwrap(Value.decode(reader, reader.uint32()));
           continue;
+        case 5:
+          if (tag !== 42) break;
+          message.outcome = reader.string();
+          continue;
+        case 6:
+          if (tag !== 50) break;
+          message.interrupts.push(Interrupt.decode(reader, reader.uint32()));
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) break;
       reader.skip(tag & 7);
@@ -5600,6 +5693,8 @@ var RunFinishedEvent = {
     message.threadId = object.threadId ?? "";
     message.runId = object.runId ?? "";
     message.result = object.result ?? void 0;
+    message.outcome = object.outcome ?? "";
+    message.interrupts = object.interrupts?.map((e) => Interrupt.fromPartial(e)) || [];
     return message;
   }
 };
@@ -6075,6 +6170,7 @@ function decode(data) {
   decoded.type = EventType$1[decoded.baseEvent.type];
   decoded.timestamp = decoded.baseEvent.timestamp;
   decoded.rawEvent = decoded.baseEvent.rawEvent;
+  delete decoded.baseEvent;
   if (decoded.type === EventType.MESSAGES_SNAPSHOT) for (const message of decoded.messages) {
     const untypedMessage = message;
     if (untypedMessage.role === "user" && Array.isArray(untypedMessage.contentParts)) {
@@ -6084,6 +6180,18 @@ function decode(data) {
     if (Array.isArray(untypedMessage.contentParts) && untypedMessage.contentParts.length === 0) untypedMessage.contentParts = void 0;
     if (untypedMessage.toolCalls?.length === 0) untypedMessage.toolCalls = void 0;
   }
+  if (decoded.type === EventType.RUN_FINISHED) {
+    const runFinished = decoded;
+    const wireOutcome = typeof runFinished.outcome === "string" && runFinished.outcome !== "" ? runFinished.outcome : void 0;
+    const wireInterrupts = Array.isArray(runFinished.interrupts) ? runFinished.interrupts : [];
+    delete runFinished.interrupts;
+    if (wireOutcome === "interrupt") runFinished.outcome = {
+      type: "interrupt",
+      interrupts: wireInterrupts
+    };
+    else if (wireOutcome === "success") runFinished.outcome = { type: "success" };
+    else delete runFinished.outcome;
+  }
   if (decoded.type === EventType.STATE_DELTA) for (const operation of decoded.delta) {
     operation.op = JsonPatchOperationType[operation.op].toLowerCase();
     Object.keys(operation).forEach((key) => {
@@ -6098,7 +6206,7 @@ function decode(data) {
 var AGUI_MEDIA_TYPE = "application/vnd.ag-ui.event+proto";
 
 // ../../../node_modules/@ag-ui/client/dist/index.mjs
-import { z as E } from "zod";
+import { z as T } from "zod";
 
 // ../../../node_modules/compare-versions/lib/esm/utils.js
 var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
@@ -6156,7 +6264,7 @@ var compareVersions = (v1, v2) => {
 };
 
 // ../../../node_modules/@ag-ui/client/dist/index.mjs
-var O = (e) => {
+var D = (e) => {
   if (typeof structuredClone == `function`) return structuredClone(e);
   try {
     return JSON.parse(JSON.stringify(e));
@@ -6164,20 +6272,20 @@ var O = (e) => {
     return Array.isArray(e) ? [...e] : { ...e };
   }
 };
-function k() {
+function O() {
   return v4_default();
 }
-function A(e) {
-  if (Object.freeze(e), typeof e == `object` && e) for (let t of Object.values(e)) typeof t == `object` && t && !Object.isFrozen(t) && A(t);
+function k(e) {
+  if (Object.freeze(e), typeof e == `object` && e) for (let t of Object.values(e)) typeof t == `object` && t && !Object.isFrozen(t) && k(t);
   return e;
 }
-async function j(e, t, n, r) {
-  let i = typeof process < `u` && process.env !== void 0, a = i && false, o = i && false, s = O(t), c = O(n), l = s, u = c, d;
+async function A(e, t, n, r) {
+  let i = typeof process < `u` && process.env !== void 0, a = i && false, o = i && false, s = D(t), c = D(n), l = s, u = c, d;
   for (let t2 of e) try {
-    o && (A(l), A(u));
+    o && (k(l), k(u));
     let e2 = await r(t2, l, u);
     if (e2 === void 0) continue;
-    if (e2.messages !== void 0 && e2.messages !== l && (l = O(e2.messages)), e2.state !== void 0 && e2.state !== u && (u = O(e2.state)), d = e2.stopPropagation, d === true) break;
+    if (e2.messages !== void 0 && e2.messages !== l && (l = D(e2.messages)), e2.state !== void 0 && e2.state !== u && (u = D(e2.state)), d = e2.stopPropagation, d === true) break;
   } catch (e2) {
     if (o && e2 instanceof TypeError) {
       if (a) throw e2;
@@ -6185,19 +6293,19 @@ async function j(e, t, n, r) {
     } else a || console.error(`Subscriber error:`, e2);
     continue;
   }
-  return { ...l === s ? {} : { messages: o && Object.isFrozen(l) ? O(l) : l }, ...u === c ? {} : { state: o && Object.isFrozen(u) ? O(u) : u }, ...d === void 0 ? {} : { stopPropagation: d } };
+  return { ...l === s ? {} : { messages: o && Object.isFrozen(l) ? D(l) : l }, ...u === c ? {} : { state: o && Object.isFrozen(u) ? D(u) : u }, ...d === void 0 ? {} : { stopPropagation: d } };
 }
-function M(e) {
+function j(e) {
   if (!e) return { enabled: false, events: false, lifecycle: false, verbose: false };
   if (e === true) return { enabled: true, events: true, lifecycle: true, verbose: true };
   let t = e.events ?? true, n = e.lifecycle ?? true, r = e.verbose ?? false;
   return { enabled: t || n, events: t, lifecycle: n, verbose: r };
 }
-function N(e) {
-  if (e instanceof P) return e;
-  if (e === true) return new P(M(true));
+function M(e) {
+  if (e instanceof N) return e;
+  if (e === true) return new N(j(true));
 }
-var P = class {
+var N = class {
   constructor(e) {
     this.config = e;
   }
@@ -6217,10 +6325,10 @@ var P = class {
     return this.config.enabled;
   }
 };
-function F(e) {
-  return e.enabled ? new P(e) : void 0;
+function P(e) {
+  return e.enabled ? new N(e) : void 0;
 }
-function ae(e, t, n) {
+function oe(e, t, n) {
   if (t) {
     let r2 = e.find((e2) => e2.id === t);
     if (r2?.role === `assistant`) return r2;
@@ -6231,19 +6339,19 @@ function ae(e, t, n) {
   let r = { id: n, role: `assistant`, toolCalls: [] };
   return e.push(r), r;
 }
-var I = (e, t, n, r, s) => {
-  let c = N(s), l = O(n.messages), u = O(e.state), d = {}, f = (e2) => {
+var F = (e, t, n, r, s) => {
+  let c = M(s), l = D(n.messages), u = D(e.state), d = {}, f = (e2) => {
     e2.messages !== void 0 && (l = e2.messages, d.messages = e2.messages), e2.state !== void 0 && (u = e2.state, d.state = e2.state);
   }, p = () => {
-    let e2 = O(d);
+    let e2 = D(d);
     return d = {}, e2.messages !== void 0 || e2.state !== void 0 ? of(e2) : EMPTY;
   };
   return t.pipe(concatMap(async (t2) => {
-    let o = await j(r, l, u, (r2, i, a) => r2.onEvent?.({ event: t2, agent: n, input: e, messages: i, state: a }));
+    let o = await A(r, l, u, (r2, i, a) => r2.onEvent?.({ event: t2, agent: n, input: e, messages: i, state: a }));
     if (f(o), o.stopPropagation === true ? c?.event(`APPLY`, `Event dropped:`, t2, { type: t2.type, reason: `stopPropagation by subscriber` }) : c?.event(`APPLY`, `Event applied:`, t2, { type: t2.type, subscribers: r.length }), o.stopPropagation === true) return p();
     switch (t2.type) {
       case EventType.TEXT_MESSAGE_START: {
-        let i = await j(r, l, u, (r2, i2, a) => r2.onTextMessageStartEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
+        let i = await A(r, l, u, (r2, i2, a) => r2.onTextMessageStartEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
         if (f(i), i.stopPropagation !== true) {
           let { messageId: e2, role: n2 = `assistant`, name: r2 } = t2;
           if (!l.find((t3) => t3.id === e2)) {
@@ -6256,19 +6364,19 @@ var I = (e, t, n, r, s) => {
       case EventType.TEXT_MESSAGE_CONTENT: {
         let { messageId: i, delta: a } = t2, o2 = l.find((e2) => e2.id === i);
         if (!o2) return console.warn(`TEXT_MESSAGE_CONTENT: No message found with ID '${i}'`), p();
-        let s2 = await j(r, l, u, (r2, i2, a2) => r2.onTextMessageContentEvent?.({ event: t2, messages: i2, state: a2, agent: n, input: e, textMessageBuffer: typeof o2.content == `string` ? o2.content : `` }));
+        let s2 = await A(r, l, u, (r2, i2, a2) => r2.onTextMessageContentEvent?.({ event: t2, messages: i2, state: a2, agent: n, input: e, textMessageBuffer: typeof o2.content == `string` ? o2.content : `` }));
         return f(s2), s2.stopPropagation !== true && (o2.content = `${typeof o2.content == `string` ? o2.content : ``}${a}`, f({ messages: l })), p();
       }
       case EventType.TEXT_MESSAGE_END: {
         let { messageId: i } = t2, a = l.find((e2) => e2.id === i);
-        return a ? (f(await j(r, l, u, (r2, i2, o2) => r2.onTextMessageEndEvent?.({ event: t2, messages: i2, state: o2, agent: n, input: e, textMessageBuffer: typeof a.content == `string` ? a.content : `` }))), await Promise.all(r.map((t3) => {
+        return a ? (f(await A(r, l, u, (r2, i2, o2) => r2.onTextMessageEndEvent?.({ event: t2, messages: i2, state: o2, agent: n, input: e, textMessageBuffer: typeof a.content == `string` ? a.content : `` }))), await Promise.all(r.map((t3) => {
           t3.onNewMessage?.({ message: a, messages: l, state: u, agent: n, input: e });
         })), p()) : (console.warn(`TEXT_MESSAGE_END: No message found with ID '${i}'`), p());
       }
       case EventType.TOOL_CALL_START: {
-        let i = await j(r, l, u, (r2, i2, a) => r2.onToolCallStartEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
+        let i = await A(r, l, u, (r2, i2, a) => r2.onToolCallStartEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
         if (f(i), i.stopPropagation !== true) {
-          let { toolCallId: e2, toolCallName: n2, parentMessageId: r2 } = t2, i2 = ae(l, r2, e2);
+          let { toolCallId: e2, toolCallName: n2, parentMessageId: r2 } = t2, i2 = oe(l, r2, e2);
           i2.toolCalls ?? (i2.toolCalls = []), i2.toolCalls.push({ id: e2, type: `function`, function: { name: n2, arguments: `` } }), f({ messages: l });
         }
         return p();
@@ -6278,7 +6386,7 @@ var I = (e, t, n, r, s) => {
         if (!o2) return console.warn(`TOOL_CALL_ARGS: No message found containing tool call with ID '${i}'`), p();
         let s2 = o2.toolCalls?.find((e2) => e2.id === i);
         if (!s2) return console.warn(`TOOL_CALL_ARGS: No tool call found with ID '${i}'`), p();
-        let c2 = await j(r, l, u, (r2, i2, a2) => {
+        let c2 = await A(r, l, u, (r2, i2, a2) => {
           let o3 = s2.function.arguments, c3 = s2.function.name, l2 = {};
           try {
             l2 = untruncateJson(o3);
@@ -6292,7 +6400,7 @@ var I = (e, t, n, r, s) => {
         let { toolCallId: i } = t2, a = l.find((e2) => e2.toolCalls?.some((e3) => e3.id === i));
         if (!a) return console.warn(`TOOL_CALL_END: No message found containing tool call with ID '${i}'`), p();
         let o2 = a.toolCalls?.find((e2) => e2.id === i);
-        return o2 ? (f(await j(r, l, u, (r2, i2, a2) => {
+        return o2 ? (f(await A(r, l, u, (r2, i2, a2) => {
           let s2 = o2.function.arguments, c2 = o2.function.name, l2 = {};
           try {
             l2 = JSON.parse(s2);
@@ -6304,17 +6412,23 @@ var I = (e, t, n, r, s) => {
         })), p()) : (console.warn(`TOOL_CALL_END: No tool call found with ID '${i}'`), p());
       }
       case EventType.TOOL_CALL_RESULT: {
-        let i = await j(r, l, u, (r2, i2, a) => r2.onToolCallResultEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
+        let i = await A(r, l, u, (r2, i2, a) => r2.onToolCallResultEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
         if (f(i), i.stopPropagation !== true) {
-          let { messageId: i2, toolCallId: a, content: o2, role: s2 } = t2, c2 = { id: i2, toolCallId: a, role: s2 || `tool`, content: o2 };
-          l.push(c2), await Promise.all(r.map((t3) => {
+          let { messageId: i2, toolCallId: a, content: o2, role: s2 } = t2, c2 = { id: i2, toolCallId: a, role: s2 || `tool`, content: o2 }, d2 = l.findIndex((e2) => e2.role === `assistant` && e2.toolCalls?.some((e3) => e3.id === a));
+          if (d2 === -1) l.push(c2);
+          else {
+            let e2 = d2 + 1;
+            for (; e2 < l.length && l[e2].role === `tool`; ) e2++;
+            l.splice(e2, 0, c2);
+          }
+          await Promise.all(r.map((t3) => {
             t3.onNewMessage?.({ message: c2, messages: l, state: u, agent: n, input: e });
           })), f({ messages: l });
         }
         return p();
       }
       case EventType.STATE_SNAPSHOT: {
-        let i = await j(r, l, u, (r2, i2, a) => r2.onStateSnapshotEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
+        let i = await A(r, l, u, (r2, i2, a) => r2.onStateSnapshotEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
         if (f(i), i.stopPropagation !== true) {
           let { snapshot: e2 } = t2;
           u = e2, f({ state: u });
@@ -6322,7 +6436,7 @@ var I = (e, t, n, r, s) => {
         return p();
       }
       case EventType.STATE_DELTA: {
-        let i = await j(r, l, u, (r2, i2, a) => r2.onStateDeltaEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
+        let i = await A(r, l, u, (r2, i2, a) => r2.onStateDeltaEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
         if (f(i), i.stopPropagation !== true) {
           let { delta: e2 } = t2;
           try {
@@ -6338,7 +6452,7 @@ Error: ${n2}`);
         return p();
       }
       case EventType.MESSAGES_SNAPSHOT: {
-        let i = await j(r, l, u, (r2, i2, a) => r2.onMessagesSnapshotEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
+        let i = await A(r, l, u, (r2, i2, a) => r2.onMessagesSnapshotEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
         if (f(i), i.stopPropagation !== true) {
           let { messages: e2 } = t2, n2 = new Map(e2.map((e3) => [e3.id, e3])), r2 = (e3) => e3 === `activity` || e3 === `reasoning`;
           l = l.filter((e3) => r2(e3.role) || n2.has(e3.id)).map((e3) => r2(e3.role) ? e3 : n2.get(e3.id));
@@ -6349,10 +6463,10 @@ Error: ${n2}`);
         return p();
       }
       case EventType.ACTIVITY_SNAPSHOT: {
-        let i = t2, a = l.findIndex((e2) => e2.id === i.messageId), o2 = a >= 0 ? l[a] : void 0, s2 = o2?.role === `activity` ? o2 : void 0, c2 = i.replace ?? true, d2 = await j(r, l, u, (t3, r2, a2) => t3.onActivitySnapshotEvent?.({ event: i, messages: r2, state: a2, agent: n, input: e, activityMessage: s2, existingMessage: o2 }));
+        let i = t2, a = l.findIndex((e2) => e2.id === i.messageId), o2 = a >= 0 ? l[a] : void 0, s2 = o2?.role === `activity` ? o2 : void 0, c2 = i.replace ?? true, d2 = await A(r, l, u, (t3, r2, a2) => t3.onActivitySnapshotEvent?.({ event: i, messages: r2, state: a2, agent: n, input: e, activityMessage: s2, existingMessage: o2 }));
         if (f(d2), d2.stopPropagation !== true) {
-          let t3 = { id: i.messageId, role: `activity`, activityType: i.activityType, content: O(i.content) }, o3;
-          a === -1 ? (l.push(t3), o3 = t3) : s2 ? c2 && (l[a] = { ...s2, activityType: i.activityType, content: O(i.content) }) : c2 && (l[a] = t3, o3 = t3), f({ messages: l }), o3 && await Promise.all(r.map((t4) => t4.onNewMessage?.({ message: o3, messages: l, state: u, agent: n, input: e })));
+          let t3 = { id: i.messageId, role: `activity`, activityType: i.activityType, content: D(i.content) }, o3;
+          a === -1 ? (l.push(t3), o3 = t3) : s2 ? c2 && (l[a] = { ...s2, activityType: i.activityType, content: D(i.content) }) : c2 && (l[a] = t3, o3 = t3), f({ messages: l }), o3 && await Promise.all(r.map((t4) => t4.onNewMessage?.({ message: o3, messages: l, state: u, agent: n, input: e })));
         }
         return p();
       }
@@ -6361,10 +6475,10 @@ Error: ${n2}`);
         if (o2 === -1) return p();
         let s2 = l[o2];
         if (s2.role !== `activity`) return console.warn(`ACTIVITY_DELTA: Message '${i.messageId}' is not an activity message`), p();
-        let c2 = s2, d2 = await j(r, l, u, (t3, r2, a) => t3.onActivityDeltaEvent?.({ event: i, messages: r2, state: a, agent: n, input: e, activityMessage: c2 }));
+        let c2 = s2, d2 = await A(r, l, u, (t3, r2, a) => t3.onActivityDeltaEvent?.({ event: i, messages: r2, state: a, agent: n, input: e, activityMessage: c2 }));
         if (f(d2), d2.stopPropagation !== true) try {
-          let e2 = O(c2.content ?? {}), t3 = fast_json_patch_default.applyPatch(e2, i.patch ?? [], true, false).newDocument;
-          l[o2] = { ...c2, content: O(t3), activityType: i.activityType }, f({ messages: l });
+          let e2 = D(c2.content ?? {}), t3 = fast_json_patch_default.applyPatch(e2, i.patch ?? [], true, false).newDocument;
+          l[o2] = { ...c2, content: D(t3), activityType: i.activityType }, f({ messages: l });
         } catch (e2) {
           let t3 = e2 instanceof Error ? e2.message : String(e2);
           console.warn(`Failed to apply activity patch for '${i.messageId}': ${t3}`);
@@ -6372,11 +6486,11 @@ Error: ${n2}`);
         return p();
       }
       case EventType.RAW:
-        return f(await j(r, l, u, (r2, i, a) => r2.onRawEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
+        return f(await A(r, l, u, (r2, i, a) => r2.onRawEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
       case EventType.CUSTOM:
-        return f(await j(r, l, u, (r2, i, a) => r2.onCustomEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
+        return f(await A(r, l, u, (r2, i, a) => r2.onCustomEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
       case EventType.RUN_STARTED: {
-        let i = await j(r, l, u, (r2, i2, a) => r2.onRunStartedEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
+        let i = await A(r, l, u, (r2, i2, a) => r2.onRunStartedEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
         if (f(i), i.stopPropagation !== true) {
           let e2 = t2;
           if (e2.input?.messages) {
@@ -6386,14 +6500,16 @@ Error: ${n2}`);
         }
         return p();
       }
-      case EventType.RUN_FINISHED:
-        return f(await j(r, l, u, (r2, i, a) => r2.onRunFinishedEvent?.({ event: t2, messages: i, state: a, agent: n, input: e, result: t2.result }))), p();
+      case EventType.RUN_FINISHED: {
+        let i = t2, a = i.outcome?.type === `interrupt` ? { event: i, outcome: `interrupt`, interrupts: i.outcome.interrupts } : { event: i, outcome: `success`, result: i.result }, o2 = await A(r, l, u, (t3, r2, i2) => t3.onRunFinishedEvent?.({ ...a, messages: r2, state: i2, agent: n, input: e }));
+        return f(o2), o2.stopPropagation !== true && (n.pendingInterrupts = a.outcome === `interrupt` ? [...a.interrupts] : []), p();
+      }
       case EventType.RUN_ERROR:
-        return f(await j(r, l, u, (r2, i, a) => r2.onRunErrorEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
+        return f(await A(r, l, u, (r2, i, a) => r2.onRunErrorEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
       case EventType.STEP_STARTED:
-        return f(await j(r, l, u, (r2, i, a) => r2.onStepStartedEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
+        return f(await A(r, l, u, (r2, i, a) => r2.onStepStartedEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
       case EventType.STEP_FINISHED:
-        return f(await j(r, l, u, (r2, i, a) => r2.onStepFinishedEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
+        return f(await A(r, l, u, (r2, i, a) => r2.onStepFinishedEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
       case EventType.TEXT_MESSAGE_CHUNK:
         throw Error(`TEXT_MESSAGE_CHUNK must be tranformed before being applied`);
       case EventType.TOOL_CALL_CHUNK:
@@ -6409,9 +6525,9 @@ Error: ${n2}`);
       case EventType.THINKING_TEXT_MESSAGE_END:
         return p();
       case EventType.REASONING_START:
-        return f(await j(r, l, u, (r2, i, a) => r2.onReasoningStartEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
+        return f(await A(r, l, u, (r2, i, a) => r2.onReasoningStartEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
       case EventType.REASONING_MESSAGE_START: {
-        let i = await j(r, l, u, (r2, i2, a) => r2.onReasoningMessageStartEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
+        let i = await A(r, l, u, (r2, i2, a) => r2.onReasoningMessageStartEvent?.({ event: t2, messages: i2, state: a, agent: n, input: e }));
         if (f(i), i.stopPropagation !== true) {
           let { messageId: e2 } = t2;
           if (!l.find((t3) => t3.id === e2)) {
@@ -6424,21 +6540,21 @@ Error: ${n2}`);
       case EventType.REASONING_MESSAGE_CONTENT: {
         let { messageId: i, delta: a } = t2, o2 = l.find((e2) => e2.id === i);
         if (!o2) return console.warn(`REASONING_MESSAGE_CONTENT: No message found with ID '${i}'`), p();
-        let s2 = await j(r, l, u, (r2, i2, a2) => r2.onReasoningMessageContentEvent?.({ event: t2, messages: i2, state: a2, agent: n, input: e, reasoningMessageBuffer: typeof o2.content == `string` ? o2.content : `` }));
+        let s2 = await A(r, l, u, (r2, i2, a2) => r2.onReasoningMessageContentEvent?.({ event: t2, messages: i2, state: a2, agent: n, input: e, reasoningMessageBuffer: typeof o2.content == `string` ? o2.content : `` }));
         return f(s2), s2.stopPropagation !== true && (o2.content = `${typeof o2.content == `string` ? o2.content : ``}${a}`, f({ messages: l })), p();
       }
       case EventType.REASONING_MESSAGE_END: {
         let { messageId: i } = t2, a = l.find((e2) => e2.id === i);
-        return a ? (f(await j(r, l, u, (r2, i2, o2) => r2.onReasoningMessageEndEvent?.({ event: t2, messages: i2, state: o2, agent: n, input: e, reasoningMessageBuffer: typeof a.content == `string` ? a.content : `` }))), await Promise.all(r.map((t3) => {
+        return a ? (f(await A(r, l, u, (r2, i2, o2) => r2.onReasoningMessageEndEvent?.({ event: t2, messages: i2, state: o2, agent: n, input: e, reasoningMessageBuffer: typeof a.content == `string` ? a.content : `` }))), await Promise.all(r.map((t3) => {
           t3.onNewMessage?.({ message: a, messages: l, state: u, agent: n, input: e });
         })), p()) : (console.warn(`REASONING_MESSAGE_END: No message found with ID '${i}'`), p());
       }
       case EventType.REASONING_MESSAGE_CHUNK:
         throw Error(`REASONING_MESSAGE_CHUNK must be transformed before being applied`);
       case EventType.REASONING_END:
-        return f(await j(r, l, u, (r2, i, a) => r2.onReasoningEndEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
+        return f(await A(r, l, u, (r2, i, a) => r2.onReasoningEndEvent?.({ event: t2, messages: i, state: a, agent: n, input: e }))), p();
       case EventType.REASONING_ENCRYPTED_VALUE: {
-        let { subtype: i, entityId: a, encryptedValue: o2 } = t2, s2 = await j(r, l, u, (r2, i2, a2) => r2.onReasoningEncryptedValueEvent?.({ event: t2, messages: i2, state: a2, agent: n, input: e }));
+        let { subtype: i, entityId: a, encryptedValue: o2 } = t2, s2 = await A(r, l, u, (r2, i2, a2) => r2.onReasoningEncryptedValueEvent?.({ event: t2, messages: i2, state: a2, agent: n, input: e }));
         if (f(s2), s2.stopPropagation !== true) {
           let e2 = false;
           if (i === `tool-call`) {
@@ -6461,8 +6577,8 @@ Error: ${n2}`);
     return t2.type, p();
   }), mergeAll(), r.length > 0 ? defaultIfEmpty({}) : (e2) => e2);
 };
-var L = (e) => (t) => {
-  let r = N(e), a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = false, c = false, l = false, u = /* @__PURE__ */ new Map(), d = false, f = false, p = false, m = () => {
+var I = (e) => (t) => {
+  let r = M(e), a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = false, c = false, l = false, u = /* @__PURE__ */ new Map(), d = false, f = false, p = false, m = () => {
     a.clear(), o.clear(), u.clear(), d = false, f = false, s = false, c = false, p = true;
   };
   return t.pipe(mergeMap((e2) => {
@@ -6543,15 +6659,15 @@ var L = (e) => (t) => {
     }
   }));
 };
-var R = (function(e) {
+var L = (function(e) {
   return e.HEADERS = `headers`, e.DATA = `data`, e;
 })({});
-var z2 = (e, t) => defer(() => from(fetch(e, t))).pipe(switchMap((e2) => {
+var R = (e) => defer(() => from(e())).pipe(switchMap((e2) => {
   if (!e2.ok) {
-    let t3 = e2.headers.get(`content-type`) || ``;
+    let t2 = e2.headers.get(`content-type`) || ``;
     return from(e2.text()).pipe(mergeMap((n2) => {
       let r = n2;
-      if (t3.includes(`application/json`)) try {
+      if (t2.includes(`application/json`)) try {
         r = JSON.parse(n2);
       } catch {
       }
@@ -6559,18 +6675,18 @@ var z2 = (e, t) => defer(() => from(fetch(e, t))).pipe(switchMap((e2) => {
       return i.status = e2.status, i.payload = r, throwError(() => i);
     }));
   }
-  let t2 = { type: R.HEADERS, status: e2.status, headers: e2.headers }, n = e2.body?.getReader();
-  return n ? new Observable((e3) => (e3.next(t2), (async () => {
+  let t = { type: L.HEADERS, status: e2.status, headers: e2.headers }, n = e2.body?.getReader();
+  return n ? new Observable((e3) => (e3.next(t), (async () => {
     try {
       for (; ; ) {
-        let { done: t3, value: r } = await n.read();
-        if (t3) break;
-        let i = { type: R.DATA, data: r };
+        let { done: t2, value: r } = await n.read();
+        if (t2) break;
+        let i = { type: L.DATA, data: r };
         e3.next(i);
       }
       e3.complete();
-    } catch (t3) {
-      e3.error(t3);
+    } catch (t2) {
+      e3.error(t2);
     }
   })(), () => {
     n.cancel().catch((e4) => {
@@ -6578,10 +6694,10 @@ var z2 = (e, t) => defer(() => from(fetch(e, t))).pipe(switchMap((e2) => {
     });
   })) : throwError(() => Error(`Failed to getReader() from response`));
 }));
-var B = (e, t) => {
-  let n = N(t), r = new Subject(), i = new TextDecoder(`utf-8`, { fatal: false }), a = ``;
+var z2 = (e, t) => {
+  let n = M(t), r = new Subject(), i = new TextDecoder(`utf-8`, { fatal: false }), a = ``;
   e.subscribe({ next: (e2) => {
-    if (e2.type !== R.HEADERS && e2.type === R.DATA && e2.data) {
+    if (e2.type !== L.HEADERS && e2.type === L.DATA && e2.data) {
       let t2 = i.decode(e2.data, { stream: true });
       a += t2;
       let n2 = a.split(/\n\n/);
@@ -6605,10 +6721,10 @@ var B = (e, t) => {
   }
   return r.asObservable();
 };
-var V = (e) => {
+var B = (e) => {
   let t = new Subject(), n = new Uint8Array();
   e.subscribe({ next: (e2) => {
-    if (e2.type !== R.HEADERS && e2.type === R.DATA && e2.data) {
+    if (e2.type !== L.HEADERS && e2.type === L.DATA && e2.data) {
       let t2 = new Uint8Array(n.length + e2.data.length);
       t2.set(n, 0), t2.set(e2.data, n.length), n = t2, r();
     }
@@ -6636,13 +6752,13 @@ var V = (e) => {
   }
   return t.asObservable();
 };
-var H = (e, t) => {
-  let n = N(t), a = new Subject(), o = new ReplaySubject(), s = false;
+var V = (e, t) => {
+  let n = M(t), a = new Subject(), o = new ReplaySubject(), s = false;
   return e.subscribe({ next: (e2) => {
-    if (o.next(e2), e2.type === R.HEADERS && !s) {
+    if (o.next(e2), e2.type === L.HEADERS && !s) {
       s = true;
       let t2 = e2.headers.get(`content-type`);
-      n?.lifecycle(`HTTP`, `Stream format detected:`, { contentType: t2, parser: t2 === AGUI_MEDIA_TYPE ? `protobuf` : `sse` }), t2 === AGUI_MEDIA_TYPE ? V(o).subscribe({ next: (e3) => a.next(e3), error: (e3) => a.error(e3), complete: () => a.complete() }) : B(o, n).subscribe({ next: (e3) => {
+      n?.lifecycle(`HTTP`, `Stream format detected:`, { contentType: t2, parser: t2 === AGUI_MEDIA_TYPE ? `protobuf` : `sse` }), t2 === AGUI_MEDIA_TYPE ? B(o).subscribe({ next: (e3) => a.next(e3), error: (e3) => a.error(e3), complete: () => a.complete() }) : z2(o, n).subscribe({ next: (e3) => {
         try {
           let t3 = EventSchemas.parse(e3);
           n?.event(`HTTP`, `Event validated:`, t3, { type: t3.type, valid: true }), a.next(t3);
@@ -6663,27 +6779,27 @@ var H = (e, t) => {
     o.complete();
   } }), a.asObservable();
 };
-var U = E.enum([`TextMessageStart`, `TextMessageContent`, `TextMessageEnd`, `ActionExecutionStart`, `ActionExecutionArgs`, `ActionExecutionEnd`, `ActionExecutionResult`, `AgentStateMessage`, `MetaEvent`, `RunStarted`, `RunFinished`, `RunError`, `NodeStarted`, `NodeFinished`]);
-var oe = E.enum([`LangGraphInterruptEvent`, `PredictState`, `Exit`]);
-var se = E.object({ type: E.literal(U.enum.TextMessageStart), messageId: E.string(), parentMessageId: E.string().optional(), role: E.string().optional() });
-var ce = E.object({ type: E.literal(U.enum.TextMessageContent), messageId: E.string(), content: E.string() });
-var le = E.object({ type: E.literal(U.enum.TextMessageEnd), messageId: E.string() });
-var ue = E.object({ type: E.literal(U.enum.ActionExecutionStart), actionExecutionId: E.string(), actionName: E.string(), parentMessageId: E.string().optional() });
-var de = E.object({ type: E.literal(U.enum.ActionExecutionArgs), actionExecutionId: E.string(), args: E.string() });
-var fe = E.object({ type: E.literal(U.enum.ActionExecutionEnd), actionExecutionId: E.string() });
-var pe = E.object({ type: E.literal(U.enum.ActionExecutionResult), actionName: E.string(), actionExecutionId: E.string(), result: E.string() });
-var me = E.object({ type: E.literal(U.enum.AgentStateMessage), threadId: E.string(), agentName: E.string(), nodeName: E.string(), runId: E.string(), active: E.boolean(), role: E.string(), state: E.string(), running: E.boolean() });
-var he = E.object({ type: E.literal(U.enum.MetaEvent), name: oe, value: E.any() });
-var ge = E.object({ type: E.literal(U.enum.RunError), message: E.string(), code: E.string().optional() });
-E.discriminatedUnion(`type`, [se, ce, le, ue, de, fe, pe, me, he, ge]), E.object({ id: E.string(), role: E.string(), content: E.string(), parentMessageId: E.string().optional() }), E.object({ id: E.string(), name: E.string(), arguments: E.any(), parentMessageId: E.string().optional() }), E.object({ id: E.string(), result: E.any(), actionExecutionId: E.string(), actionName: E.string() });
-var _e = (e) => {
+var H = T.enum([`TextMessageStart`, `TextMessageContent`, `TextMessageEnd`, `ActionExecutionStart`, `ActionExecutionArgs`, `ActionExecutionEnd`, `ActionExecutionResult`, `AgentStateMessage`, `MetaEvent`, `RunStarted`, `RunFinished`, `RunError`, `NodeStarted`, `NodeFinished`]);
+var se = T.enum([`LangGraphInterruptEvent`, `PredictState`, `Exit`]);
+var ce = T.object({ type: T.literal(H.enum.TextMessageStart), messageId: T.string(), parentMessageId: T.string().optional(), role: T.string().optional() });
+var le = T.object({ type: T.literal(H.enum.TextMessageContent), messageId: T.string(), content: T.string() });
+var ue = T.object({ type: T.literal(H.enum.TextMessageEnd), messageId: T.string() });
+var de = T.object({ type: T.literal(H.enum.ActionExecutionStart), actionExecutionId: T.string(), actionName: T.string(), parentMessageId: T.string().optional() });
+var fe = T.object({ type: T.literal(H.enum.ActionExecutionArgs), actionExecutionId: T.string(), args: T.string() });
+var pe = T.object({ type: T.literal(H.enum.ActionExecutionEnd), actionExecutionId: T.string() });
+var me = T.object({ type: T.literal(H.enum.ActionExecutionResult), actionName: T.string(), actionExecutionId: T.string(), result: T.string() });
+var he = T.object({ type: T.literal(H.enum.AgentStateMessage), threadId: T.string(), agentName: T.string(), nodeName: T.string(), runId: T.string(), active: T.boolean(), role: T.string(), state: T.string(), running: T.boolean() });
+var ge = T.object({ type: T.literal(H.enum.MetaEvent), name: se, value: T.any() });
+var _e = T.object({ type: T.literal(H.enum.RunError), message: T.string(), code: T.string().optional() });
+T.discriminatedUnion(`type`, [ce, le, ue, de, fe, pe, me, he, ge, _e]), T.object({ id: T.string(), role: T.string(), content: T.string(), parentMessageId: T.string().optional() }), T.object({ id: T.string(), name: T.string(), arguments: T.any(), parentMessageId: T.string().optional() }), T.object({ id: T.string(), result: T.any(), actionExecutionId: T.string(), actionName: T.string() });
+var ve = (e) => {
   if (typeof e == `string`) return e;
   if (!Array.isArray(e)) return;
   let t = e.filter((e2) => e2.type === `text`).map((e2) => e2.text).filter((e2) => e2.length > 0);
   if (t.length !== 0) return t.join(`
 `);
 };
-var ve = (e, t, n) => (r) => {
+var U = (e, t, n) => (r) => {
   let o = {}, s = true, c = true, l = ``, u = null, d = null, f = [], p = {}, m = (e2) => {
     typeof e2 == `object` && e2 && (`messages` in e2 && delete e2.messages, o = e2);
   };
@@ -6691,19 +6807,19 @@ var ve = (e, t, n) => (r) => {
     switch (r2.type) {
       case EventType.TEXT_MESSAGE_START: {
         let e2 = r2;
-        return [{ type: U.enum.TextMessageStart, messageId: e2.messageId, role: e2.role }];
+        return [{ type: H.enum.TextMessageStart, messageId: e2.messageId, role: e2.role }];
       }
       case EventType.TEXT_MESSAGE_CONTENT: {
         let e2 = r2;
-        return [{ type: U.enum.TextMessageContent, messageId: e2.messageId, content: e2.delta }];
+        return [{ type: H.enum.TextMessageContent, messageId: e2.messageId, content: e2.delta }];
       }
       case EventType.TEXT_MESSAGE_END: {
         let e2 = r2;
-        return [{ type: U.enum.TextMessageEnd, messageId: e2.messageId }];
+        return [{ type: H.enum.TextMessageEnd, messageId: e2.messageId }];
       }
       case EventType.TOOL_CALL_START: {
         let e2 = r2;
-        return f.push({ id: e2.toolCallId, type: `function`, function: { name: e2.toolCallName, arguments: `` } }), c = true, p[e2.toolCallId] = e2.toolCallName, [{ type: U.enum.ActionExecutionStart, actionExecutionId: e2.toolCallId, actionName: e2.toolCallName, parentMessageId: e2.parentMessageId }];
+        return f.push({ id: e2.toolCallId, type: `function`, function: { name: e2.toolCallName, arguments: `` } }), c = true, p[e2.toolCallId] = e2.toolCallName, [{ type: H.enum.ActionExecutionStart, actionExecutionId: e2.toolCallId, actionName: e2.toolCallName, parentMessageId: e2.parentMessageId }];
       }
       case EventType.TOOL_CALL_ARGS: {
         let i = r2, a = f.find((e2) => e2.id === i.toolCallId);
@@ -6718,15 +6834,15 @@ var ve = (e, t, n) => (r) => {
           } catch {
           }
         }
-        return [{ type: U.enum.ActionExecutionArgs, actionExecutionId: i.toolCallId, args: i.delta }, ...u2 ? [{ type: U.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify(o), active: c }] : []];
+        return [{ type: H.enum.ActionExecutionArgs, actionExecutionId: i.toolCallId, args: i.delta }, ...u2 ? [{ type: H.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify(o), active: c }] : []];
       }
       case EventType.TOOL_CALL_END: {
         let e2 = r2;
-        return [{ type: U.enum.ActionExecutionEnd, actionExecutionId: e2.toolCallId }];
+        return [{ type: H.enum.ActionExecutionEnd, actionExecutionId: e2.toolCallId }];
       }
       case EventType.TOOL_CALL_RESULT: {
         let e2 = r2;
-        return [{ type: U.enum.ActionExecutionResult, actionExecutionId: e2.toolCallId, result: e2.content, actionName: p[e2.toolCallId] || `unknown` }];
+        return [{ type: H.enum.ActionExecutionResult, actionExecutionId: e2.toolCallId, result: e2.content, actionName: p[e2.toolCallId] || `unknown` }];
       }
       case EventType.RAW:
         return [];
@@ -6740,28 +6856,28 @@ var ve = (e, t, n) => (r) => {
             d = e2.value;
             break;
         }
-        return [{ type: U.enum.MetaEvent, name: e2.name, value: e2.value }];
+        return [{ type: H.enum.MetaEvent, name: e2.name, value: e2.value }];
       }
       case EventType.STATE_SNAPSHOT:
-        return m(r2.snapshot), [{ type: U.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify(o), active: c }];
+        return m(r2.snapshot), [{ type: H.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify(o), active: c }];
       case EventType.STATE_DELTA: {
         let i = r2, u2 = fast_json_patch_default.applyPatch(o, i.delta, true, false);
-        return u2 ? (m(u2.newDocument), [{ type: U.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify(o), active: c }]) : [];
+        return u2 ? (m(u2.newDocument), [{ type: H.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify(o), active: c }]) : [];
       }
       case EventType.MESSAGES_SNAPSHOT:
-        return u = r2.messages, [{ type: U.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify({ ...o, ...u ? { messages: u } : {} }), active: true }];
+        return u = r2.messages, [{ type: H.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify({ ...o, ...u ? { messages: u } : {} }), active: true }];
       case EventType.RUN_STARTED:
         return [];
       case EventType.RUN_FINISHED:
-        return u && (o.messages = u), Object.keys(o).length === 0 ? [] : [{ type: U.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify({ ...o, ...u ? { messages: ye(u) } : {} }), active: false }];
+        return u && (o.messages = u), Object.keys(o).length === 0 ? [] : [{ type: H.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify({ ...o, ...u ? { messages: ye(u) } : {} }), active: false }];
       case EventType.RUN_ERROR: {
         let e2 = r2;
-        return [{ type: U.enum.RunError, message: e2.message, code: e2.code }];
+        return [{ type: H.enum.RunError, message: e2.message, code: e2.code }];
       }
       case EventType.STEP_STARTED:
-        return l = r2.stepName, f = [], d = null, [{ type: U.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify(o), active: true }];
+        return l = r2.stepName, f = [], d = null, [{ type: H.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify(o), active: true }];
       case EventType.STEP_FINISHED:
-        return f = [], d = null, [{ type: U.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify(o), active: false }];
+        return f = [], d = null, [{ type: H.enum.AgentStateMessage, threadId: e, agentName: n, nodeName: l, runId: t, running: s, role: `assistant`, state: JSON.stringify(o), active: false }];
       default:
         return [];
     }
@@ -6770,7 +6886,7 @@ var ve = (e, t, n) => (r) => {
 function ye(e) {
   let t = [];
   for (let n of e) if (n.role === `assistant` || n.role === `user` || n.role === `system`) {
-    let e2 = _e(n.content);
+    let e2 = ve(n.content);
     if (e2) {
       let r = { id: n.id, role: n.role, content: e2 };
       t.push(r);
@@ -6793,7 +6909,7 @@ function ye(e) {
   return t;
 }
 var W = (e) => (t) => {
-  let n = N(e), r, a, o, s, c = () => {
+  let n = M(e), r, a, o, s, c = () => {
     if (!r || s !== `text`) throw Error(`No text message to close`);
     let e2 = { type: EventType.TEXT_MESSAGE_END, messageId: r.messageId };
     return s = void 0, r = void 0, n?.event(`TRANSFORM`, `TEXT_MESSAGE_END`, e2, { messageId: e2.messageId }), e2;
@@ -6886,18 +7002,21 @@ var W = (e) => (t) => {
     f();
   }));
 };
-var G = class {
+function G(e, t = /* @__PURE__ */ new Date()) {
+  return e.expiresAt === void 0 ? false : new Date(e.expiresAt) <= t;
+}
+var K = class {
   runNext(e, t) {
     return t.run(e).pipe(W(false));
   }
   runNextWithState(e, t) {
-    let n = O(e.messages || []), r = O(e.state || {}), i = new ReplaySubject();
-    return I(e, i, t, []).subscribe((e2) => {
+    let n = D(e.messages || []), r = D(e.state || {}), i = new ReplaySubject();
+    return F(e, i, t, []).subscribe((e2) => {
       e2.messages !== void 0 && (n = e2.messages), e2.state !== void 0 && (r = e2.state);
-    }), this.runNext(e, t).pipe(concatMap(async (e2) => (i.next(e2), await new Promise((e3) => setTimeout(e3, 0)), { event: e2, messages: O(n), state: O(r) })));
+    }), this.runNext(e, t).pipe(concatMap(async (e2) => (i.next(e2), await new Promise((e3) => setTimeout(e3, 0)), { event: e2, messages: D(n), state: D(r) })));
   }
 };
-var K = class extends G {
+var q = class extends K {
   constructor(e) {
     super(), this.fn = e;
   }
@@ -6905,7 +7024,7 @@ var K = class extends G {
     return this.fn(e, t);
   }
 };
-function xe(e) {
+function Ce(e) {
   let t = e.content;
   if (Array.isArray(t)) {
     let n = t.filter((e2) => typeof e2 == `object` && !!e2 && `type` in e2 && e2.type === `text` && typeof e2.text == `string`).map((e2) => e2.text).join(``);
@@ -6913,18 +7032,18 @@ function xe(e) {
   }
   return typeof t == `string` ? e : { ...e, content: `` };
 }
-var q = class extends G {
+var J = class extends K {
   run(e, t) {
-    let { parentRunId: n, ...r } = e, i = { ...r, messages: r.messages.map(xe) };
+    let { parentRunId: n, ...r } = e, i = { ...r, messages: r.messages.map(Ce) };
     return this.runNext(i, t);
   }
 };
-var J = `THINKING_START`;
-var Y = `THINKING_END`;
-var X = `THINKING_TEXT_MESSAGE_START`;
-var Z = `THINKING_TEXT_MESSAGE_CONTENT`;
-var Se = `THINKING_TEXT_MESSAGE_END`;
-var Ce = class extends G {
+var Y = `THINKING_START`;
+var X = `THINKING_END`;
+var Z = `THINKING_TEXT_MESSAGE_START`;
+var we = `THINKING_TEXT_MESSAGE_CONTENT`;
+var Te = `THINKING_TEXT_MESSAGE_END`;
+var Ee = class extends K {
   constructor(...e) {
     super(...e), this.currentReasoningId = null, this.currentMessageId = null;
   }
@@ -6936,71 +7055,71 @@ var Ce = class extends G {
   }
   transformEvent(e) {
     switch (e.type) {
-      case J: {
-        this.currentReasoningId = k();
+      case Y: {
+        this.currentReasoningId = O();
         let { title: t, ...n } = e;
-        return this.warnAboutTransformation(J, EventType.REASONING_START), { ...n, type: EventType.REASONING_START, messageId: this.currentReasoningId };
+        return this.warnAboutTransformation(Y, EventType.REASONING_START), { ...n, type: EventType.REASONING_START, messageId: this.currentReasoningId };
       }
-      case X:
-        return this.currentMessageId = k(), this.warnAboutTransformation(X, EventType.REASONING_MESSAGE_START), { ...e, type: EventType.REASONING_MESSAGE_START, messageId: this.currentMessageId, role: `assistant` };
-      case Z: {
+      case Z:
+        return this.currentMessageId = O(), this.warnAboutTransformation(Z, EventType.REASONING_MESSAGE_START), { ...e, type: EventType.REASONING_MESSAGE_START, messageId: this.currentMessageId, role: `assistant` };
+      case we: {
         let { delta: t, ...n } = e;
-        return this.warnAboutTransformation(Z, EventType.REASONING_MESSAGE_CONTENT), { ...n, type: EventType.REASONING_MESSAGE_CONTENT, messageId: this.currentMessageId ?? k(), delta: t };
+        return this.warnAboutTransformation(we, EventType.REASONING_MESSAGE_CONTENT), { ...n, type: EventType.REASONING_MESSAGE_CONTENT, messageId: this.currentMessageId ?? O(), delta: t };
       }
-      case Se: {
-        let t = this.currentMessageId ?? k();
-        return this.warnAboutTransformation(Se, EventType.REASONING_MESSAGE_END), { ...e, type: EventType.REASONING_MESSAGE_END, messageId: t };
+      case Te: {
+        let t = this.currentMessageId ?? O();
+        return this.warnAboutTransformation(Te, EventType.REASONING_MESSAGE_END), { ...e, type: EventType.REASONING_MESSAGE_END, messageId: t };
       }
-      case Y: {
-        let t = this.currentReasoningId ?? k();
-        return this.warnAboutTransformation(Y, EventType.REASONING_END), { ...e, type: EventType.REASONING_END, messageId: t };
+      case X: {
+        let t = this.currentReasoningId ?? O();
+        return this.warnAboutTransformation(X, EventType.REASONING_END), { ...e, type: EventType.REASONING_END, messageId: t };
       }
       default:
         return e;
     }
   }
 };
-function we(e) {
+function De(e) {
   return e.startsWith(`image/`) ? `image` : e.startsWith(`audio/`) ? `audio` : e.startsWith(`video/`) ? `video` : `document`;
 }
-function Te(e) {
+function Oe(e) {
   return typeof e == `object` && !!e && `type` in e && e.type === `binary` && `mimeType` in e && typeof e.mimeType == `string`;
 }
-function Ee(e) {
-  let t = we(e.mimeType);
+function ke(e) {
+  let t = De(e.mimeType);
   return e.data ? { type: t, source: { type: `data`, value: e.data, mimeType: e.mimeType }, ...e.filename ? { metadata: { filename: e.filename } } : {} } : e.url ? { type: t, source: { type: `url`, value: e.url, mimeType: e.mimeType }, ...e.filename ? { metadata: { filename: e.filename } } : {} } : e;
 }
-function De(e) {
+function Ae(e) {
   let t = e.content;
   if (!Array.isArray(t)) return e;
-  let n = t.map((e2) => Te(e2) ? Ee(e2) : e2);
+  let n = t.map((e2) => Oe(e2) ? ke(e2) : e2);
   return { ...e, content: n };
 }
-var Oe = class extends G {
+var je = class extends K {
   run(e, t) {
-    let n = { ...e, messages: e.messages.map(De) };
+    let n = { ...e, messages: e.messages.map(Ae) };
     return this.runNext(n, t);
   }
 };
-var ke = `0.0.53`;
-var Ae = class {
+var Me = `0.0.55`;
+var Ne = class {
   get maxVersion() {
-    return ke;
+    return Me;
   }
   get debug() {
     return this._debug;
   }
   set debug(e) {
-    this._debug = M(e), this._debugLogger = F(this._debug);
+    this._debug = j(e), this._debugLogger = P(this._debug);
   }
   get debugLogger() {
     return this._debugLogger;
   }
   set debugLogger(e) {
-    typeof e == `boolean` ? this._debugLogger = e ? F(M(true)) : void 0 : this._debugLogger = e;
+    typeof e == `boolean` ? this._debugLogger = e ? P(j(true)) : void 0 : this._debugLogger = e;
   }
   constructor({ agentId: t, description: n, threadId: r, initialMessages: i, initialState: a, debug: o } = {}) {
-    this.subscribers = [], this.isRunning = false, this.middlewares = [], this.agentId = t, this.description = n ?? ``, this.threadId = r ?? v4_default(), this.messages = O(i ?? []), this.state = O(a ?? {}), this._debug = M(o), this._debugLogger = F(this._debug), compareVersions(this.maxVersion, `0.0.39`) <= 0 && this.middlewares.unshift(new q()), compareVersions(this.maxVersion, `0.0.45`) <= 0 && this.middlewares.unshift(new Ce()), compareVersions(this.maxVersion, `0.0.47`) <= 0 && this.middlewares.unshift(new Oe());
+    this.subscribers = [], this.isRunning = false, this.pendingInterrupts = [], this.middlewares = [], this.agentId = t, this.description = n ?? ``, this.threadId = r ?? v4_default(), this.messages = D(i ?? []), this.state = D(a ?? {}), this._debug = j(o), this._debugLogger = P(this._debug), compareVersions(this.maxVersion, `0.0.39`) <= 0 && this.middlewares.unshift(new J()), compareVersions(this.maxVersion, `0.0.45`) <= 0 && this.middlewares.unshift(new Ee()), compareVersions(this.maxVersion, `0.0.47`) <= 0 && this.middlewares.unshift(new je());
   }
   subscribe(e) {
     return this.subscribers.push(e), { unsubscribe: () => {
@@ -7008,7 +7127,7 @@ var Ae = class {
     } };
   }
   use(...e) {
-    let t = e.map((e2) => typeof e2 == `function` ? new K(e2) : e2);
+    let t = e.map((e2) => typeof e2 == `function` ? new q(e2) : e2);
     return this.middlewares.push(...t), this;
   }
   async runAgent(t, n) {
@@ -7017,7 +7136,7 @@ var Ae = class {
       let r = this.prepareRunAgentInput(t);
       this.debugLogger?.lifecycle(`LIFECYCLE`, `Run started:`, { agentId: this.agentId, threadId: this.threadId });
       let i, a = new Set(this.messages.map((e) => e.id)), o = [{ onRunFinishedEvent: (e) => {
-        i = e.result;
+        e.outcome === `success` && (i = e.result);
       } }, ...this.subscribers, n ?? {}];
       await this.onInitialize(r, o), this.activeRunDetach$ = new Subject();
       let s;
@@ -7027,10 +7146,10 @@ var Ae = class {
         return e.messages;
       }, get state() {
         return e.state;
-      } }), this).run(r), W(this.debugLogger), L(this.debugLogger), (e) => e.pipe(takeUntil(this.activeRunDetach$)), (e) => this.apply(r, e, o), (e) => this.processApplyEvents(r, e, o), catchError((e) => (this.debugLogger?.lifecycle(`LIFECYCLE`, `Run errored:`, { agentId: this.agentId, error: e instanceof Error ? e.message : String(e) }), this.isRunning = false, this.onError(r, e, o))), finalize(() => {
+      } }), this).run(r), W(this.debugLogger), I(this.debugLogger), (e) => e.pipe(takeUntil(this.activeRunDetach$)), (e) => this.apply(r, e, o), (e) => this.processApplyEvents(r, e, o), catchError((e) => (this.debugLogger?.lifecycle(`LIFECYCLE`, `Run errored:`, { agentId: this.agentId, error: e instanceof Error ? e.message : String(e) }), this.isRunning = false, this.onError(r, e, o))), finalize(() => {
         this.debugLogger?.lifecycle(`LIFECYCLE`, `Run finished:`, { agentId: this.agentId, threadId: this.threadId }), this.isRunning = false, this.onFinalize(r, o), s?.(), s = void 0, this.activeRunCompletionPromise = void 0, this.activeRunDetach$ = void 0;
       }))(of(null)));
-      let c = O(this.messages).filter((e) => !a.has(e.id));
+      let c = D(this.messages).filter((e) => !a.has(e.id));
       return { result: i, newMessages: c };
     } finally {
       this.isRunning = false;
@@ -7043,16 +7162,16 @@ var Ae = class {
     try {
       this.isRunning = true, this.agentId = this.agentId ?? v4_default();
       let i = this.prepareRunAgentInput(n), a, s = new Set(this.messages.map((e) => e.id)), c = [{ onRunFinishedEvent: (e) => {
-        a = e.result;
+        e.outcome === `success` && (a = e.result);
       } }, ...this.subscribers, r ?? {}];
       await this.onInitialize(i, c), this.activeRunDetach$ = new Subject();
       let d;
       this.activeRunCompletionPromise = new Promise((e) => {
         d = e;
-      }), await lastValueFrom(pipe(() => defer(() => this.connect(i)), W(this.debugLogger), L(this.debugLogger), (e) => e.pipe(takeUntil(this.activeRunDetach$)), (e) => this.apply(i, e, c), (e) => this.processApplyEvents(i, e, c), catchError((e) => (this.isRunning = false, e instanceof AGUIConnectNotImplementedError ? EMPTY : this.onError(i, e, c))), finalize(() => {
+      }), await lastValueFrom(pipe(() => defer(() => this.connect(i)), W(this.debugLogger), I(this.debugLogger), (e) => e.pipe(takeUntil(this.activeRunDetach$)), (e) => this.apply(i, e, c), (e) => this.processApplyEvents(i, e, c), catchError((e) => (this.isRunning = false, e instanceof AGUIConnectNotImplementedError ? EMPTY : this.onError(i, e, c))), finalize(() => {
         this.isRunning = false, this.onFinalize(i, c), d?.(), d = void 0, this.activeRunCompletionPromise = void 0, this.activeRunDetach$ = void 0;
       }))(of(null)), { defaultValue: void 0 });
-      let f = O(this.messages).filter((e) => !s.has(e.id));
+      let f = D(this.messages).filter((e) => !s.has(e.id));
       return { result: a, newMessages: f };
     } finally {
       this.isRunning = false;
@@ -7066,7 +7185,7 @@ var Ae = class {
     this.activeRunDetach$.next(), this.activeRunDetach$?.complete(), await e;
   }
   apply(e, t, n) {
-    return I(e, t, this, n, this.debugLogger);
+    return F(e, t, this, n, this.debugLogger);
   }
   processApplyEvents(e, t, n) {
     return t.pipe(tap((t2) => {
@@ -7078,19 +7197,24 @@ var Ae = class {
     }));
   }
   prepareRunAgentInput(t) {
-    let n = O(this.messages).filter((e) => e.role !== `activity`);
-    return { threadId: this.threadId, runId: t?.runId || v4_default(), tools: O(t?.tools ?? []), context: O(t?.context ?? []), forwardedProps: O(t?.forwardedProps ?? {}), state: O(this.state), messages: n };
+    let n = D(this.messages).filter((e) => e.role !== `activity`);
+    return { threadId: this.threadId, runId: t?.runId || v4_default(), tools: D(t?.tools ?? []), context: D(t?.context ?? []), forwardedProps: D(t?.forwardedProps ?? {}), state: D(this.state), messages: n, ...t?.resume === void 0 ? {} : { resume: D(t.resume) } };
   }
   async onInitialize(e, t) {
-    let n = await j(t, this.messages, this.state, (t2, n2, r) => t2.onRunInitialized?.({ messages: n2, state: r, agent: this, input: e }));
-    (n.messages !== void 0 || n.state !== void 0) && (n.messages && (this.messages = n.messages, e.messages = n.messages, t.forEach((t2) => {
+    if (this.pendingInterrupts.length > 0) {
+      let t2 = new Set((e.resume ?? []).map((e2) => e2.interruptId)), r2 = this.pendingInterrupts.map((e2) => e2.id).filter((e2) => !t2.has(e2));
+      if (r2.length > 0) throw new AGUIError(`Thread has ${r2.length} pending interrupt(s) not addressed by resume: ${r2.join(`, `)}`);
+      for (let e2 of this.pendingInterrupts) if (G(e2)) throw new AGUIError(`Interrupt ${e2.id} expired at ${e2.expiresAt}`);
+    }
+    let r = await A(t, this.messages, this.state, (t2, n, r2) => t2.onRunInitialized?.({ messages: n, state: r2, agent: this, input: e }));
+    (r.messages !== void 0 || r.state !== void 0) && (r.messages && (this.messages = r.messages, e.messages = r.messages, t.forEach((t2) => {
       t2.onMessagesChanged?.({ messages: this.messages, state: this.state, agent: this, input: e });
-    })), n.state && (this.state = n.state, e.state = n.state, t.forEach((t2) => {
+    })), r.state && (this.state = r.state, e.state = r.state, t.forEach((t2) => {
       t2.onStateChanged?.({ state: this.state, messages: this.messages, agent: this, input: e });
     })));
   }
   onError(e, t, n) {
-    return from(j(n, this.messages, this.state, (n2, r, i) => n2.onRunFailed?.({ error: t, messages: r, state: i, agent: this, input: e }))).pipe(map((r) => {
+    return from(A(n, this.messages, this.state, (n2, r, i) => n2.onRunFailed?.({ error: t, messages: r, state: i, agent: this, input: e }))).pipe(map((r) => {
       let i = r;
       if ((i.messages !== void 0 || i.state !== void 0) && (i.messages !== void 0 && (this.messages = i.messages, n.forEach((t2) => {
         t2.onMessagesChanged?.({ messages: this.messages, state: this.state, agent: this, input: e });
@@ -7104,7 +7228,7 @@ var Ae = class {
     }));
   }
   async onFinalize(e, t) {
-    let n = await j(t, this.messages, this.state, (t2, n2, r) => t2.onRunFinalized?.({ messages: n2, state: r, agent: this, input: e }));
+    let n = await A(t, this.messages, this.state, (t2, n2, r) => t2.onRunFinalized?.({ messages: n2, state: r, agent: this, input: e }));
     (n.messages !== void 0 || n.state !== void 0) && (n.messages !== void 0 && (this.messages = n.messages, t.forEach((t2) => {
       t2.onMessagesChanged?.({ messages: this.messages, state: this.state, agent: this, input: e });
     })), n.state !== void 0 && (this.state = n.state, t.forEach((t2) => {
@@ -7113,7 +7237,7 @@ var Ae = class {
   }
   clone() {
     let e = Object.create(Object.getPrototypeOf(this));
-    return e.agentId = this.agentId, e.description = this.description, e.threadId = this.threadId, e.messages = O(this.messages), e.state = O(this.state), e._debug = this._debug, e._debugLogger = this._debugLogger, e.isRunning = this.isRunning, e.subscribers = [...this.subscribers], e.middlewares = [...this.middlewares], e;
+    return e.agentId = this.agentId, e.description = this.description, e.threadId = this.threadId, e.messages = D(this.messages), e.state = D(this.state), e._debug = this._debug, e._debugLogger = this._debugLogger, e.isRunning = this.isRunning, e.subscribers = [...this.subscribers], e.middlewares = [...this.middlewares], e.pendingInterrupts = D(this.pendingInterrupts), e;
   }
   addMessage(e) {
     this.messages.push(e), (async () => {
@@ -7132,12 +7256,12 @@ var Ae = class {
     })();
   }
   setMessages(e) {
-    this.messages = O(e), (async () => {
+    this.messages = D(e), (async () => {
       for (let e2 of this.subscribers) await e2.onMessagesChanged?.({ messages: this.messages, state: this.state, agent: this });
     })();
   }
   setState(e) {
-    this.state = O(e), (async () => {
+    this.state = D(e), (async () => {
       for (let e2 of this.subscribers) await e2.onStateChanged?.({ messages: this.messages, state: this.state, agent: this });
     })();
   }
@@ -7148,10 +7272,10 @@ var Ae = class {
       return e.messages;
     }, get state() {
       return e.state;
-    } }), this).run(n)).pipe(W(this.debugLogger), L(this.debugLogger), ve(this.threadId, n.runId, this.agentId), (e) => e.pipe(map((e2) => (this.debugLogger?.event(`LEGACY`, `Event:`, e2, { type: e2.type }), e2))));
+    } }), this).run(n)).pipe(W(this.debugLogger), I(this.debugLogger), U(this.threadId, n.runId, this.agentId), (e) => e.pipe(map((e2) => (this.debugLogger?.event(`LEGACY`, `Event:`, e2, { type: e2.type }), e2))));
   }
 };
-var je = class extends Ae {
+var Pe = class extends Ne {
   requestInit(e) {
     return { method: `POST`, headers: { ...this.headers, "Content-Type": `application/json`, Accept: `text/event-stream` }, body: JSON.stringify(e), signal: this.abortController.signal };
   }
@@ -7162,21 +7286,21 @@ var je = class extends Ae {
     this.abortController.abort(), super.abortRun();
   }
   constructor(e) {
-    super(e), this.abortController = new AbortController(), this.url = e.url, this.headers = O(e.headers ?? {});
+    super(e), this.abortController = new AbortController(), this.url = e.url, this.headers = D(e.headers ?? {}), this.fetch = e.fetch ?? fetch;
   }
   run(e) {
-    return H(z2(this.url, this.requestInit(e)), this.debugLogger);
+    return V(R(() => this.fetch(this.url, this.requestInit(e))), this.debugLogger);
   }
   clone() {
     let e = super.clone();
-    e.url = this.url, e.headers = O(this.headers ?? {});
+    e.url = this.url, e.headers = D(this.headers ?? {}), e.fetch = this.fetch;
     let t = new AbortController(), n = this.abortController.signal;
     return n.aborted && t.abort(n.reason), e.abortController = t, e;
   }
 };
 
 // ../../chat/dist/transport/agui.js
-var ConfigurableCredentialsHttpAgent = class extends je {
+var ConfigurableCredentialsHttpAgent = class extends Pe {
   constructor(config2, credentials) {
     super(config2);
     this._credentials = credentials;
@@ -7193,6 +7317,13 @@ var _idCounter = 0;
 function generateId() {
   return `agui-${Date.now()}-${++_idCounter}`;
 }
+var MAX_TRANSIENT_RETRIES = 2;
+var TRANSIENT_RETRY_BACKOFF_MS = [400, 1200];
+function isTransientRunFailure(status, errorName) {
+  if (errorName === "AbortError") return false;
+  if (status == null) return errorName === "TypeError";
+  return status === 408 || status === 425 || status === 429 || status >= 500;
+}
 var AgUiTransport = class {
   constructor(options) {
     this._agent = null;
@@ -7200,6 +7331,10 @@ var AgUiTransport = class {
     this._handlers = /* @__PURE__ */ new Set();
     this._pendingResume = false;
     this._currentAssistantMessageId = null;
+    this._toolCallMessageIds = /* @__PURE__ */ new Map();
+    this._localPendingInterrupts = /* @__PURE__ */ new Map();
+    this._runProducedOutput = false;
+    this._retryTimer = null;
     this._url = options.url;
     this._headers = options.headers ?? {};
     this._threadId = options.threadId;
@@ -7207,6 +7342,7 @@ var AgUiTransport = class {
     this._credentials = options.credentials;
     this._onA2UIEvent = options.onA2UIEvent;
     this._forwardedProps = options.forwardedProps;
+    this._serverOwnedHistory = options.serverOwnedHistory ?? false;
   }
   get connected() {
     return this._connected;
@@ -7217,7 +7353,12 @@ var AgUiTransport = class {
       {
         url: this._url,
         headers: resolvedHeaders,
-        threadId: this._threadId || void 0
+        threadId: this._threadId || void 0,
+        // @ag-ui/client@0.0.54+ stores `fetch` as a plain instance field and
+        // invokes it as `this.fetch(...)`. The browser's `window.fetch`
+        // throws "Illegal invocation" when called with a `this` other than
+        // `window`, so we must hand them an explicitly-bound function.
+        fetch: typeof globalThis !== "undefined" && typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0
       },
       this._credentials
     );
@@ -7227,22 +7368,32 @@ var AgUiTransport = class {
     this._emit({ type: "messages-snapshot", messages: [] });
   }
   disconnect() {
+    if (this._retryTimer != null) {
+      clearTimeout(this._retryTimer);
+      this._retryTimer = null;
+    }
     if (this._agent?.isRunning) {
       this._agent.abortRun();
     }
     this._agent = null;
     this._connected = false;
     this._pendingResume = false;
+    this._currentAssistantMessageId = null;
+    this._toolCallMessageIds.clear();
+    this._localPendingInterrupts.clear();
   }
   send(action) {
     if (!this._agent) return;
     switch (action.type) {
       case "user-message":
-        this._sendUserMessage(action.text);
+        this._sendUserMessage(action.text, action.id);
         break;
       case "tool-result":
         this._sendToolResult(action.toolCallId, action.result, action.approved);
         break;
+      case "deferred-tool-resume":
+        this._sendDeferredToolResume(action);
+        break;
       case "stop-generation":
         this._agent.abortRun();
         break;
@@ -7257,14 +7408,35 @@ var AgUiTransport = class {
   // ---------------------------------------------------------------------------
   // Private — user message flow
   // ---------------------------------------------------------------------------
-  _sendUserMessage(text) {
+  _sendUserMessage(text, id) {
+    if (!text || !text.trim()) return;
     const agent = this._agent;
+    const upstream = (agent.pendingInterrupts ?? []).map((i) => i).filter(
+      (i) => typeof i?.id === "string" && i.id.length > 0
+    );
+    const byId = /* @__PURE__ */ new Map();
+    for (const i of this._localPendingInterrupts.values()) byId.set(i.id, i);
+    for (const i of upstream) byId.set(i.id, i);
+    const pendingInterrupts = [...byId.values()];
+    const cancelResume = pendingInterrupts.length > 0 ? pendingInterrupts.map((i) => {
+      const toolCallId = i.toolCallId ?? i.tool_call_id;
+      if (toolCallId) {
+        this._emit({ type: "tool-call-cancelled", toolCallId });
+      }
+      return {
+        interruptId: i.id,
+        status: "cancelled"
+      };
+    }) : void 0;
+    if (cancelResume) this._localPendingInterrupts.clear();
     agent.addMessage({
-      id: generateId(),
+      // Caller-minted id (id parity with the server transcript,
+      // FEAT-1783701440) or a transport-local fallback.
+      id: id ?? generateId(),
       role: "user",
       content: text
     });
-    this._runAgent();
+    this._runAgent(cancelResume);
   }
   // ---------------------------------------------------------------------------
   // Private — tool result flow
@@ -7288,34 +7460,128 @@ var AgUiTransport = class {
     this._runAgent();
   }
   // ---------------------------------------------------------------------------
+  // Private — deferred-tool resume (HITL approve/deny via AG-UI resume[])
+  // ---------------------------------------------------------------------------
+  _sendDeferredToolResume(action) {
+    let entry;
+    this._localPendingInterrupts.delete(action.interruptId);
+    if (action.decision === "cancel") {
+      entry = { interruptId: action.interruptId, status: "cancelled" };
+    } else if (action.decision === "approve") {
+      const payload = { approved: true };
+      if (action.editedArgs !== void 0) payload.editedArgs = action.editedArgs;
+      entry = { interruptId: action.interruptId, status: "resolved", payload };
+    } else {
+      const payload = { approved: false };
+      if (typeof action.reason === "string" && action.reason.length > 0) {
+        payload.reason = action.reason;
+      }
+      entry = { interruptId: action.interruptId, status: "resolved", payload };
+    }
+    this._runAgent([entry]);
+  }
+  // ---------------------------------------------------------------------------
   // Private — run agent with subscriber
   // ---------------------------------------------------------------------------
-  _runAgent() {
+  _runAgent(resume, attempt = 0) {
     const agent = this._agent;
     if (!agent) return;
     this._currentAssistantMessageId = null;
+    this._runProducedOutput = false;
     this._emit({ type: "typing", isTyping: true });
     if (typeof this._headers === "function") {
       agent.headers = this._headers();
     }
+    const sentMessageIds = new Set((agent.messages ?? []).map((m) => m.id));
     const fwd = typeof this._forwardedProps === "function" ? this._forwardedProps() : this._forwardedProps;
-    const runParams = fwd ? { forwardedProps: fwd } : void 0;
-    agent.runAgent(runParams, this._buildSubscriber()).catch((err) => {
+    const runParams = {
+      ...fwd ? { forwardedProps: fwd } : {},
+      ...resume && resume.length > 0 ? { resume: [...resume] } : {}
+    };
+    const runPromise = agent.runAgent(runParams, this._buildSubscriber());
+    runPromise.then(() => {
+      this._resetAgentMessages(agent, sentMessageIds);
+    }).catch(() => {
+    });
+    runPromise.catch((err) => {
       const message = err instanceof Error ? err.message : "Agent run failed";
       const errorName = err instanceof Error ? err.name : null;
       const e = err;
       const status = typeof e.status === "number" ? e.status : typeof e.statusCode === "number" ? e.statusCode : typeof e.response?.status === "number" ? e.response.status : null;
       const rawBody = e.body ?? e.response?.body ?? null;
       const body = typeof rawBody === "string" ? rawBody.slice(0, 500) : rawBody != null ? JSON.stringify(rawBody).slice(0, 500) : null;
+      if (isTransientRunFailure(status, errorName) && !this._runProducedOutput && attempt < MAX_TRANSIENT_RETRIES && this._agent === agent) {
+        const delay = TRANSIENT_RETRY_BACKOFF_MS[attempt] ?? TRANSIENT_RETRY_BACKOFF_MS[TRANSIENT_RETRY_BACKOFF_MS.length - 1];
+        this._currentAssistantMessageId = null;
+        this._retryTimer = setTimeout(() => {
+          this._retryTimer = null;
+          if (this._agent === agent) this._runAgent(resume, attempt + 1);
+        }, delay);
+        return;
+      }
+      this._pendingResume = false;
+      this._currentAssistantMessageId = null;
+      this._resetAgentMessages(agent, sentMessageIds);
       this._emit({ type: "error", message, status, body, errorName });
       this._emit({ type: "typing", isTyping: false });
     });
   }
+  /**
+   * Reset `agent.messages` after a settled run (server-owned history).
+   *
+   * The backend owns conversation state (`chat_threads.native_messages`);
+   * the agent object is only a request builder, so anything that already
+   * shipped in a run is dropped. The ONLY retention is undelivered
+   * client-tool state: an assistant message carrying `toolCalls` for a
+   * tool in `clientTools` whose result either doesn't exist yet (the UI
+   * is still computing/asking) or was queued mid-run and never shipped
+   * (`_sendToolResult` while `isRunning`). The retained pair makes the
+   * next run's wire self-consistent — a `role: "tool"` message without
+   * its matching call in the SAME client list is dropped by the backend
+   * filter and the result would be lost.
+   *
+   * No-op unless `serverOwnedHistory` is set: the adaptive runtime and
+   * editor chat backends still build the model conversation from the
+   * client's `messages` array.
+   */
+  _resetAgentMessages(agent, sentMessageIds) {
+    if (!this._serverOwnedHistory) return;
+    if (agent !== this._agent) return;
+    const messages = agent.messages ?? [];
+    const resultsByCallId = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      if (msg.role === "tool" && typeof msg.toolCallId === "string") {
+        resultsByCallId.set(msg.toolCallId, msg);
+      }
+    }
+    const retained = [];
+    for (const msg of messages) {
+      if (msg.role !== "assistant" || !Array.isArray(msg.toolCalls)) continue;
+      const pendingCalls = msg.toolCalls.filter((tc) => {
+        if (!this._clientTools.has(tc.function?.name)) return false;
+        const result = resultsByCallId.get(tc.id);
+        return result === void 0 || !sentMessageIds.has(result.id);
+      });
+      if (pendingCalls.length === 0) continue;
+      retained.push({ ...msg, toolCalls: pendingCalls });
+      for (const tc of pendingCalls) {
+        const result = resultsByCallId.get(tc.id);
+        if (result !== void 0) retained.push(result);
+      }
+    }
+    if (typeof agent.setMessages === "function") {
+      agent.setMessages(retained);
+    } else {
+      agent.messages = retained;
+    }
+  }
   _buildSubscriber() {
     return {
       onTextMessageStartEvent: (params) => {
         const { event } = params;
+        this._runProducedOutput = true;
         this._currentAssistantMessageId = event.messageId;
+        this._emit({ type: "thinking-clear" });
         const message = {
           id: event.messageId,
           role: "assistant",
@@ -7337,9 +7603,35 @@ var AgUiTransport = class {
         const { event } = params;
         this._emit({ type: "message-complete", messageId: event.messageId });
       },
+      // pydantic-ai's AG-UI adapter emits REASONING_MESSAGE_CONTENT for
+      // every reasoning delta the model produces between turns. We forward
+      // the deltas verbatim — the model already narrates its intent ("Let
+      // me check what we have for student athletes…") in its own words, so
+      // surfacing them gives the visitor real progress instead of silent
+      // loading dots during the tool-call gap between two assistant
+      // messages. REASONING_START/END just bracket the deltas; only the
+      // content carries the narration we care about.
+      //
+      // Naming history: AG-UI 0.0.45+ renamed THINKING_* to REASONING_*
+      // and dropped the THINKING callback names from `AgentSubscriber`.
+      // Registering `onThinkingTextMessageContentEvent` here used to be
+      // a silent no-op — the AG-UI client never invoked it — so reasoning
+      // deltas never reached the trail despite the backend emitting them.
+      // The matching test in agui-transport.test.ts faked the same
+      // callback name, hiding the drift. Both fixed together.
+      onReasoningMessageContentEvent: (params) => {
+        const { event } = params;
+        this._emit({
+          type: "thinking-delta",
+          delta: event.delta ?? ""
+        });
+      },
       onToolCallStartEvent: (params) => {
         const { event } = params;
+        this._runProducedOutput = true;
+        this._emit({ type: "thinking-clear" });
         const messageId = event.parentMessageId ?? this._currentAssistantMessageId ?? event.toolCallId;
+        this._toolCallMessageIds.set(event.toolCallId, messageId);
         this._emit({
           type: "tool-call",
           messageId,
@@ -7362,8 +7654,10 @@ var AgUiTransport = class {
       },
       onToolCallEndEvent: (params) => {
         const { event, toolCallName, toolCallArgs } = params;
+        const startMessageId = this._toolCallMessageIds.get(event.toolCallId);
+        this._toolCallMessageIds.delete(event.toolCallId);
         if (this._clientTools.has(toolCallName)) {
-          const messageId = this._currentAssistantMessageId ?? event.toolCallId;
+          const messageId = startMessageId ?? this._currentAssistantMessageId ?? event.toolCallId;
           this._emit({
             type: "tool-call",
             messageId,
@@ -7378,12 +7672,46 @@ var AgUiTransport = class {
         } else {
           this._emit({
             type: "tool-call-done",
-            toolCallId: event.toolCallId
+            toolCallId: event.toolCallId,
+            ...toolCallArgs && Object.keys(toolCallArgs).length > 0 ? { args: toolCallArgs, argsBuffer: JSON.stringify(toolCallArgs) } : {}
           });
         }
       },
-      onRunFinishedEvent: (_params) => {
+      onToolCallResultEvent: (params) => {
+        const { event } = params;
+        const raw = event?.content;
+        const result = (() => {
+          if (raw === void 0 || raw === null) return null;
+          if (typeof raw !== "string") return raw;
+          try {
+            return JSON.parse(raw);
+          } catch {
+            return raw;
+          }
+        })();
+        this._emit({ type: "tool-call-result", toolCallId: event.toolCallId, result });
+      },
+      onRunFinishedEvent: (params) => {
         this._emit({ type: "typing", isTyping: false });
+        const outcome = params?.event?.outcome;
+        if (outcome?.type === "interrupt" && Array.isArray(outcome.interrupts)) {
+          for (const interrupt of outcome.interrupts) {
+            const toolCallId = interrupt.toolCallId ?? interrupt.tool_call_id;
+            if (typeof interrupt.id === "string" && interrupt.id) {
+              this._localPendingInterrupts.set(interrupt.id, {
+                id: interrupt.id,
+                toolCallId: typeof toolCallId === "string" ? toolCallId : void 0
+              });
+            }
+            if (typeof toolCallId === "string" && typeof interrupt.id === "string") {
+              this._emit({
+                type: "tool-call-deferred",
+                toolCallId,
+                interruptId: interrupt.id
+              });
+            }
+          }
+        }
         if (this._pendingResume) {
           this._pendingResume = false;
           this._runAgent();
@@ -7391,11 +7719,16 @@ var AgUiTransport = class {
       },
       onRunErrorEvent: (params) => {
         const { event } = params;
-        this._emit({ type: "error", message: event.message });
+        const code = typeof event.code === "string" ? event.code : void 0;
+        this._emit({ type: "error", message: event.message, ...code ? { code } : {} });
         this._emit({ type: "typing", isTyping: false });
       },
       onCustomEvent: (params) => {
         const { event } = params;
+        if (typeof event.name === "string" && event.name.startsWith("syntro.recovery.")) {
+          return;
+        }
+        this._runProducedOutput = true;
         const payload = event.value;
         this._onA2UIEvent?.(payload);
         this._emit({ type: "a2ui", payload });
@@ -7406,6 +7739,7 @@ var AgUiTransport = class {
   // Private — emit to subscribers
   // ---------------------------------------------------------------------------
   _emit(event) {
+    if (!this._connected) return;
     for (const handler of this._handlers) {
       handler(event);
     }
@@ -7434,9 +7768,7 @@ var ActionHandler = class {
     const action = this._actionFromInstance(instance);
     await ctx.actions.applyBatch([action]);
   }
-  async patch(instance, ctx) {
-    const action = this._actionFromInstance(instance);
-    await ctx.actions.applyBatch([action]);
+  async patch(_instance, _ctx) {
   }
   async unmount(_instance, _ctx) {
   }
@@ -7459,11 +7791,15 @@ var ActionHandler = class {
 // src/elements/ElementInstanceStore.ts
 var COMPOSITIONAL_REPLAY_REQUEST_EVENT = "element.compositional_replay_request";
 var COMPOSITIONAL_APPEND_EVENT = "element.compositional_append";
+var CHAT_INLINE_SLOT = "chat-inline";
 var ElementInstanceStore = class {
   constructor(options) {
     this._instances = /* @__PURE__ */ new Map();
     /** Active TTL timeout — replaced on each call to `scheduleClientTtl`. */
     this._ttlTimer = null;
+    /** Instance IDs the client has dismissed. Persists across canvas remounts
+     *  so a dismissed tile never silently reappears on replay/broadcast. */
+    this._dismissedIds = /* @__PURE__ */ new Set();
     this._actions = options.actions;
     this._events = options.events;
     this._resolveTileWidget = options.resolveTileWidget;
@@ -7488,8 +7824,19 @@ var ElementInstanceStore = class {
     const publish = this._events?.publish;
     if (!subscribe || !publish) return;
     subscribe(
-      { names: [COMPOSITIONAL_REPLAY_REQUEST_EVENT, TILE_REPLAY_REQUEST_EVENT] },
+      {
+        names: [
+          COMPOSITIONAL_REPLAY_REQUEST_EVENT,
+          TILE_REPLAY_REQUEST_EVENT,
+          TILE_UNMOUNTED_EVENT
+        ]
+      },
       (event) => {
+        if (event.name === TILE_UNMOUNTED_EVENT) {
+          const id = String(event.props?.instance_id ?? "");
+          if (id) this._dismissedIds.add(id);
+          return;
+        }
         if (event.name === COMPOSITIONAL_REPLAY_REQUEST_EVENT) {
           const tileId = String(event.props?.tile_id ?? "");
           if (!tileId) return;
@@ -7522,6 +7869,7 @@ var ElementInstanceStore = class {
       if (instance.element_type !== "tile") continue;
       if (instance.placement.type !== "slot") continue;
       if (instance.state !== "active") continue;
+      if (this._dismissedIds.has(instance.instance_id)) continue;
       const props = {
         slot: instance.placement.slot,
         instance_id: instance.instance_id,
@@ -7534,6 +7882,89 @@ var ElementInstanceStore = class {
   registerHandler(handler) {
     this._handlers.set(handler.typeName, handler);
   }
+  isDismissed(instanceId) {
+    return this._dismissedIds.has(instanceId);
+  }
+  getDismissedIds() {
+    return this._dismissedIds;
+  }
+  /** Store-driven receipt source for the chat trail (one per active slot-tile). */
+  listTileReceipts() {
+    const out = [];
+    for (const inst of this._instances.values()) {
+      if (inst.element_type !== "tile" || inst.placement.type !== "slot") continue;
+      if (inst.state !== "active") continue;
+      if (inst.placement.slot === CHAT_INLINE_SLOT) continue;
+      const content = inst.content;
+      const productName = content?.product?.name;
+      const contentTitle = content?.title;
+      const contentHeading = content?.heading;
+      const title = typeof productName === "string" && productName ? productName : typeof contentTitle === "string" && contentTitle ? contentTitle : typeof contentHeading === "string" && contentHeading ? contentHeading : (
+        // Never show a raw template id (kebab-case machine name) in the
+        // chat — prettify the last-resort fallback into Title Case.
+        inst.template_id.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase())
+      );
+      if (inst.placement.slot === "alert") {
+        out.push({
+          kind: "alert",
+          instanceId: inst.instance_id,
+          title,
+          turnId: inst.mounted_by?.turn_id,
+          toolCallId: inst.tool_call_id ?? void 0
+        });
+      } else {
+        out.push({
+          kind: "tile",
+          instanceId: inst.instance_id,
+          title,
+          dismissed: this._dismissedIds.has(inst.instance_id),
+          turnId: inst.mounted_by?.turn_id,
+          toolCallId: inst.tool_call_id ?? void 0
+        });
+      }
+    }
+    return out;
+  }
+  /**
+   * Store-driven inline-widget source for the chat trail — one entry per
+   * active `chat-inline` slot-tile. The trail mounts each entry's widget
+   * element (by tag name, via `document.createElement`) inline in the
+   * conversation flow. Distinct from {@link listTileReceipts}: those are
+   * chips that recall a deck tile; these ARE the rendered widget.
+   */
+  listInlineWidgets() {
+    const out = [];
+    for (const inst of this._instances.values()) {
+      if (inst.element_type !== "tile" || inst.placement.type !== "slot") continue;
+      if (inst.placement.slot !== CHAT_INLINE_SLOT) continue;
+      if (inst.state !== "active") continue;
+      if (this._dismissedIds.has(inst.instance_id)) continue;
+      out.push({
+        instanceId: inst.instance_id,
+        tag: this._resolveTileWidget?.(inst.template_id) ?? inst.template_id,
+        props: inst.content ?? {},
+        turnId: inst.mounted_by?.turn_id,
+        toolCallId: inst.tool_call_id ?? void 0
+      });
+    }
+    return out;
+  }
+  /** Clear a client dismissal and re-publish the tile's mount from retained content. */
+  recreate(instanceId) {
+    const instance = this._instances.get(instanceId);
+    const publish = this._events?.publish;
+    if (!instance || instance.element_type !== "tile" || instance.placement.type !== "slot" || !publish) {
+      return;
+    }
+    this._dismissedIds.delete(instanceId);
+    const props = {
+      slot: instance.placement.slot,
+      instance_id: instance.instance_id,
+      widget: this._resolveTileWidget?.(instance.template_id) ?? instance.template_id,
+      props: instance.content ?? {}
+    };
+    publish(TILE_MOUNTED_EVENT, props);
+  }
   /**
    * Apply the server-provided boot snapshot. For each instance:
    *   - stateful: validated + mounted via the type handler;
@@ -7674,8 +8105,16 @@ var ElementInstanceStore = class {
       const isActiveStateful = mutation.instance.state === "active" && handler.lifecycle !== "imperative";
       const isAppliedImperative = mutation.instance.state === "applied" && handler.lifecycle === "imperative";
       if (isActiveStateful || isAppliedImperative) {
+        this._instances.set(mutation.instance.instance_id, mutation.instance);
         const applied = await this._mount(handler, mutation.instance);
-        if (!applied) return;
+        if (!applied) {
+          if (existing) {
+            this._instances.set(mutation.instance.instance_id, existing);
+          } else {
+            this._instances.delete(mutation.instance.instance_id);
+          }
+        }
+        return;
       }
       this._instances.set(mutation.instance.instance_id, mutation.instance);
       return;
@@ -7688,6 +8127,12 @@ var ElementInstanceStore = class {
         });
         return;
       }
+      if (typeof mutation.resulting_version !== "number" || mutation.resulting_content == null || typeof mutation.resulting_content !== "object") {
+        this._logger.warn("elements: patch dropped \u2014 malformed envelope (missing resulting_*)", {
+          instance_id: mutation.instance_id
+        });
+        return;
+      }
       if (mutation.resulting_version <= existing.version) {
         return;
       }
@@ -7731,6 +8176,7 @@ var ElementInstanceStore = class {
         try {
           await handler.unmount(reverted, this._ctx());
         } catch (err) {
+          this._instances.set(mutation.instance_id, existing);
           this._logger.warn("elements: handler.unmount threw", {
             instance_id: mutation.instance_id,
             err
@@ -7785,11 +8231,15 @@ async function fetchMountedElements(options = {}) {
   if (typeof fetchImpl !== "function") {
     return null;
   }
-  const token = options.token ?? _tokenFromGlobalConfig();
+  const token = options.token;
   const headers = {};
   if (token) {
     headers.Authorization = `Bearer ${token}`;
   }
+  const did = _runtimeId("getDistinctId");
+  if (did) headers["X-Distinct-Id"] = did;
+  const sid = _runtimeId("getSessionId");
+  if (sid) headers["X-Syntro-Session"] = sid;
   let response;
   try {
     response = await fetchImpl(endpoint, {
@@ -7812,16 +8262,31 @@ async function fetchMountedElements(options = {}) {
     return null;
   }
   try {
-    return await response.json();
+    const parsed = await response.json();
+    if (!isMountedElementsResponse(parsed)) {
+      logger.warn("elements.fetcher: invalid response shape", { endpoint });
+      return null;
+    }
+    return parsed;
   } catch (err) {
     logger.warn("elements.fetcher: malformed JSON", { endpoint, err });
     return null;
   }
 }
-function _tokenFromGlobalConfig() {
-  if (typeof globalThis === "undefined") return void 0;
-  const cfg = globalThis.__SYNTRO_CONFIG__;
-  return cfg?.token;
+function isMountedElementsResponse(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const response = value;
+  return Array.isArray(response.mounted_elements) && (response.session_expires_at === null || typeof response.session_expires_at === "string") && response.schema_version === "v0";
+}
+function _runtimeId(method) {
+  if (typeof window === "undefined") return void 0;
+  const rt = window.SynOS?.runtime;
+  try {
+    const v = rt?.telemetry?.[method]?.();
+    return typeof v === "string" && v.length > 0 ? v : void 0;
+  } catch {
+    return void 0;
+  }
 }
 
 // src/elements/ItemHandler.ts
@@ -7906,6 +8371,9 @@ var TileHandler = class {
     if (typeof instance.template_id !== "string" || instance.template_id.length === 0) {
       return { accepted: false, reason: "missing_template_id" };
     }
+    if (this.resolveWidget && this.resolveWidget(instance.template_id) === void 0) {
+      return { accepted: false, reason: "unknown_template_id", detail: instance.template_id };
+    }
     return { accepted: true };
   }
   async mount(instance, ctx) {
@@ -7980,6 +8448,7 @@ async function acquireTurnstileToken(opts = {}) {
   const appearance = opts.appearance ?? "interaction-only";
   if (!TURNSTILE_SITEKEY) return null;
   if (typeof window === "undefined" || typeof document === "undefined") return null;
+  if (opts.signal?.aborted) return null;
   let turnstile;
   try {
     turnstile = await Promise.race([
@@ -8138,10 +8607,8 @@ async function acquireTokenWithChallenge(options = {}) {
 
 // src/ChatAssistantLit.ts
 var ERROR_DEBOUNCE_MS = 1500;
-function readSyntroToken() {
-  if (typeof window === "undefined") return void 0;
-  const cfg = window.__SYNTRO_CONFIG__;
-  const token = cfg?.token;
+function readRuntimeToken(runtime) {
+  const token = runtime?.token;
   return typeof token === "string" && token.startsWith("syn_") ? token : void 0;
 }
 var FALLBACK_DEFAULTS = {
@@ -8211,25 +8678,30 @@ var ChatAssistantLitMountable = {
     const flatLooksLikeChatbotConfig = typeof flat.backendUrl === "string";
     const chatbotConfig = nestedConfig ?? (flatLooksLikeChatbotConfig ? flat : void 0);
     const resolvedTileId = tileId ?? instanceId ?? "chatbot-widget";
-    if (!chatbotConfig?.backendUrl || !runtime) {
-      container.innerHTML = '<div style="padding:16px;color:var(--sc-content-text-secondary-color,#87919f)">Chat widget requires config and runtime.</div>';
+    const backendUrl = runtime?.backendUrl;
+    if (!backendUrl || !runtime) {
+      container.innerHTML = '<div style="padding:16px;color:var(--sc-content-text-secondary-color,#87919f)">Chat widget requires runtime + backendUrl.</div>';
       return () => {
         container.innerHTML = "";
       };
     }
-    const baseUrl = chatbotConfig.backendUrl.replace(/\/$/, "");
-    const token = readSyntroToken();
+    const baseUrl = backendUrl.replace(/\/$/, "");
+    const token = readRuntimeToken(runtime);
     const streamUrl = `${baseUrl}/api/adaptive/stream`;
     const buildHeaders = (cft) => {
       const h = {};
       if (token) h.Authorization = `Bearer ${token}`;
       if (cft) h["CF-Turnstile-Token"] = cft;
       try {
-        const ph = window.posthog;
-        const did = ph?.get_distinct_id?.();
+        const rt = runtime;
+        const did = rt?.telemetry?.getDistinctId?.();
         if (typeof did === "string" && did.length > 0) {
           h["X-Distinct-Id"] = did;
         }
+        const sid = rt?.telemetry?.getSessionId?.();
+        if (typeof sid === "string" && sid.length > 0) {
+          h["X-Syntro-Session"] = sid;
+        }
       } catch {
       }
       return h;
@@ -8256,25 +8728,21 @@ var ChatAssistantLitMountable = {
       elementStore.scheduleClientTtl(response.session_expires_at);
     });
     const el = document.createElement("syntro-chat");
-    el.greeting = chatbotConfig.greeting;
-    if (chatbotConfig.suggestions) {
+    el.greeting = chatbotConfig?.greeting;
+    if (chatbotConfig?.suggestions) {
       el.suggestions = chatbotConfig.suggestions;
     }
+    el.voiceInput = chatbotConfig?.voiceInput ?? false;
     el.style.cssText = "display:flex;flex-direction:column;height:100%;width:100%;";
     let transport = null;
     let hasSucceeded = false;
     let isUnmounted = false;
     let unsubscribe = null;
-    let failureTimer = null;
     let errorDebounceTimer = null;
     let fallbackRendered = false;
     let messagesSent = 0;
     let lastErrorPayload = null;
     const clearTimers = () => {
-      if (failureTimer) {
-        clearTimeout(failureTimer);
-        failureTimer = null;
-      }
       if (errorDebounceTimer) {
         clearTimeout(errorDebounceTimer);
         errorDebounceTimer = null;
@@ -8316,13 +8784,13 @@ var ChatAssistantLitMountable = {
       );
       transport?.disconnect();
       el.remove();
-      container.innerHTML = renderFallbackHtml(chatbotConfig.fallback);
+      container.innerHTML = renderFallbackHtml(chatbotConfig?.fallback);
     };
     const setupTransport = (cftToken) => {
       if (isUnmounted) return;
       transport = new AgUiTransport({
         url: streamUrl,
-        headers: buildHeaders(cftToken),
+        headers: () => buildHeaders(cftToken),
         // Adaptive runtime SDK needs the `syntro_chat_session` cookie to
         // round-trip cross-origin so subsequent boot fetches can rehydrate
         // LLM-authored UI elements. Editor / action-plan chat surfaces
@@ -8359,6 +8827,19 @@ var ChatAssistantLitMountable = {
         debug("transport event", { type: event.type, hasSucceeded, fallbackRendered });
         if (event.type === "error") {
           const errEvent = event;
+          if (errEvent.code === "USAGE_LIMIT") {
+            runtime.events.publish("chatbot.usage_limit_exhausted", {
+              tileId: resolvedTileId,
+              mountId,
+              mountAgeMs: mountAgeMs(),
+              messagesSentBeforeExhaust: messagesSent
+            });
+            if (!hasSucceeded) {
+              hasSucceeded = true;
+              debug("hasSucceeded transitioned to true via USAGE_LIMIT");
+            }
+            return;
+          }
           lastErrorPayload = {
             message: errEvent.message,
             status: errEvent.status ?? null,
@@ -8491,4 +8972,4 @@ fast-json-patch/module/duplex.mjs:
    * MIT license
    *)
 */
-//# sourceMappingURL=chunk-KUO67E2W.js.map
+//# sourceMappingURL=chunk-A3TIGA4G.js.map