@agents24/react 0.1.0 → 0.2.1

package/dist/index.js

@@ -11,8 +11,34 @@ function isAbortLike(error) {
 }
 
 // src/model.ts
+import {
+  compressionFromContextWindow,
+  mergeContextWindowUpdate,
+  normalizeContextCompression
+} from "@agents24/client/protocol";
+function chatAttachmentIds(attachments) {
+  return (attachments || []).flatMap((attachment) => typeof attachment.id === "string" && attachment.id.trim() ? [attachment.id.trim()] : []);
+}
+var chatNodeSkipReason = (value) => {
+  const normalized = text(value);
+  return normalized === "missing_required_input" || normalized === "upstream_input_unavailable" || normalized === "empty_optional_source" ? normalized : null;
+};
+function getThreadActivity(thread) {
+  const activeRun = thread.active_run || null;
+  const status = String(activeRun?.status || thread.last_run_status || "").trim().toLowerCase() || null;
+  return {
+    status,
+    runId: activeRun?.run_id || thread.last_run_id || null,
+    isSpinning: Boolean(activeRun),
+    isPaused: status === "paused",
+    isFailed: status === "failed",
+    isCompleted: status === "completed",
+    isCancelled: status === "cancelled" || status === "canceled"
+  };
+}
 var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
 var text = (value) => typeof value === "string" && value.trim() ? value : null;
+var finiteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
 var statusToToolState = (value) => {
   const normalized = String(value || "").toLowerCase();
   if (normalized === "failed" || normalized === "error") return "output-error";
@@ -20,42 +46,167 @@ var statusToToolState = (value) => {
   if (["complete", "completed", "done", "success"].includes(normalized)) return "output-available";
   return normalized === "streaming" ? "input-streaming" : "input-available";
 };
+function failureView(value) {
+  const candidate = record(value);
+  return candidate?.schema_version === "agents24.failure.v1" && text(candidate.failure_id) && text(candidate.code) && text(candidate.message) && typeof candidate.retryable === "boolean" && record(candidate.details) ? candidate : null;
+}
 var allowedActions = {
   tool_review: ["approve", "reject"],
   mcp_auth: ["connect", "skip"],
   user_approval: ["approve", "reject"],
-  app_data_permission: ["approve", "reject"]
+  app_data_permission: ["approve", "reject"],
+  user_input: ["respond"]
 };
-function partsFromResponseBlocks(blocks, fallbackText = "") {
+function hitlQuestions(presentation) {
+  return (Array.isArray(presentation.questions) ? presentation.questions : []).flatMap((value) => {
+    const question = record(value);
+    if (!question || !Array.isArray(question.options)) return [];
+    const options = question.options.flatMap((rawOption) => {
+      const option = record(rawOption);
+      return option && text(option.id) && text(option.label) ? [{ id: String(option.id), label: String(option.label) }] : [];
+    });
+    return text(question.id) && text(question.header) && text(question.question) && options.length >= 2 ? [{
+      id: String(question.id),
+      header: String(question.header),
+      question: String(question.question),
+      options,
+      multiSelect: question.multi_select === true
+    }] : [];
+  });
+}
+function hitlResolution(value) {
+  const resolution = record(value);
+  if (!resolution) return null;
+  const answers = (Array.isArray(resolution.answers) ? resolution.answers : []).flatMap((value2) => {
+    const answer = record(value2);
+    if (!answer || !text(answer.question_id) || !Array.isArray(answer.selected_option_ids)) return [];
+    return [{
+      questionId: String(answer.question_id),
+      selectedOptionIds: answer.selected_option_ids.map(String),
+      ...text(answer.custom_text) ? { customText: String(answer.custom_text) } : {}
+    }];
+  });
+  return { ...resolution, ...answers.length ? { answers } : {} };
+}
+function partMetadata(block, id) {
+  return {
+    id,
+    runId: text(block.runId) || text(block.run_id),
+    sequence: finiteNumber(block.seq),
+    timestamp: text(block.ts),
+    raw: block
+  };
+}
+function toolPresentation(tool) {
+  const nested = record(tool.presentation) || {};
+  const childRunValue = record(tool.childRun) || record(tool.child_run);
+  const childRun = childRunValue && (text(childRunValue.runId || childRunValue.run_id) || text(childRunValue.agentName || childRunValue.agent_name) || text(childRunValue.status)) ? {
+    runId: text(childRunValue.runId) || text(childRunValue.run_id),
+    agentId: text(childRunValue.agentId) || text(childRunValue.agent_id),
+    agentName: text(childRunValue.agentName) || text(childRunValue.agent_name),
+    status: text(childRunValue.status),
+    error: text(childRunValue.error)
+  } : null;
+  const childTools = (Array.isArray(tool.childTools) ? tool.childTools : Array.isArray(tool.child_tools) ? tool.child_tools : []).flatMap((value) => {
+    const child = record(value);
+    if (!child || !text(child.id) || !text(child.title)) return [];
+    return [{
+      id: String(child.id),
+      runId: text(child.runId) || text(child.run_id),
+      toolCallId: text(child.toolCallId) || text(child.tool_call_id),
+      toolName: String(child.toolName || child.tool_name || child.title),
+      title: String(child.title),
+      status: String(child.status || ""),
+      detail: text(child.detail),
+      sequence: finiteNumber(child.seq),
+      timestamp: text(child.ts)
+    }];
+  });
+  return {
+    ...nested,
+    title: text(tool.title) || text(nested.title),
+    activity: text(tool.activity) || text(nested.activity),
+    detail: text(tool.detail) || text(nested.detail),
+    category: text(tool.category) || text(nested.category),
+    groupKey: text(tool.groupKey) || text(tool.group_key) || text(nested.groupKey) || text(nested.group_key),
+    groupLabel: text(tool.groupLabel) || text(tool.group_label) || text(nested.groupLabel) || text(nested.group_label),
+    path: text(tool.path),
+    threadId: text(tool.threadId) || text(tool.thread_id),
+    isExploration: tool.isExploration === true || tool.is_exploration === true,
+    childRun,
+    childTools,
+    activeChildToolId: text(tool.activeChildToolId) || text(tool.active_child_tool_id)
+  };
+}
+function partsFromResponseBlocks(blocks, fallbackText = "", fallbackPartId = "assistant-text") {
   const input = Array.isArray(blocks) ? blocks : [];
   const parts = input.flatMap((item, index) => {
     const block = record(item);
     if (!block) return [];
     const kind = String(block.kind || "data");
     const id = String(block.id || `${kind}-${index}`);
+    const metadata = partMetadata(block, id);
     if (kind === "assistant_text") {
       const value = text(block.text);
-      return value ? [{ id, type: "text", kind: "text", text: value, raw: block }] : [];
+      return value ? [{ ...metadata, type: "text", kind: "text", text: value }] : [];
+    }
+    if (kind === "context_compression") {
+      const compression = normalizeContextCompression(block.compression);
+      if (!compression?.active) return [];
+      const status = compression.status === "started" || compression.status === "completed" || compression.status === "failed" ? compression.status : block.status === "complete" ? "completed" : block.status === "error" ? "failed" : "started";
+      return [{
+        ...metadata,
+        type: "context-compression",
+        kind: "context-compression",
+        status,
+        compression: { ...compression, status }
+      }];
+    }
+    if (kind === "node_activity") {
+      const node = record(block.node);
+      const activityId = text(node?.activityId) || text(node?.activity_id) || id;
+      const statusValue = String(node?.status || "").toLowerCase();
+      const status = ["completed", "failed", "cancelled", "skipped"].includes(statusValue) ? statusValue : "running";
+      const label = text(node?.label) || "Working";
+      const nodeKind = text(node?.kind) || "node";
+      return [{
+        ...metadata,
+        type: "node-activity",
+        kind: "node-activity",
+        activityId,
+        traceStepId: text(node?.traceStepId) || text(node?.trace_step_id) || null,
+        label,
+        nodeKind,
+        status,
+        defaultChatVisible: node?.defaultChatVisible === true,
+        reason: chatNodeSkipReason(node?.reason),
+        failure: failureView(node?.failure)
+      }];
     }
     if (kind === "tool" || kind === "tool_call" || kind === "tool_result") {
       const tool = record(block.tool) || block;
-      const toolName = String(tool.action || tool.title || "tool");
+      const toolName = String(tool.toolName || tool.tool_name || tool.action || tool.title || "tool");
       return [{
-        id,
+        ...metadata,
         type: `tool-${toolName}`,
         kind: "tool",
         toolName,
-        toolCallId: text(tool.toolCallId),
+        toolKey: text(tool.toolKey) || text(tool.tool_key),
+        action: text(tool.action),
+        displayName: text(tool.displayName) || text(tool.display_name),
+        summary: text(tool.summary),
+        toolCallId: text(tool.toolCallId) || text(tool.tool_call_id),
+        sourceKind: text(tool.sourceKind) || text(tool.source_kind),
         state: statusToToolState(block.status),
         input: tool.input,
         output: tool.output,
         errorText: text(tool.error || block.error),
-        presentation: record(tool.presentation),
-        raw: block
+        failure: failureView(tool.failure),
+        presentation: toolPresentation(tool)
       }];
     }
-    if (kind === "reasoning_note") return [{ id, type: "reasoning", kind: "reasoning", label: text(block.label), text: text(block.description), status: text(block.status), raw: block }];
-    if (kind === "ui_blocks") return [{ id, type: "ui-blocks", kind: "ui-blocks", state: statusToToolState(block.status), toolCallId: text(block.toolCallId), contractVersion: text(block.contractVersion), bundle: record(block.bundle), errorText: text(block.error), raw: block }];
+    if (kind === "reasoning_note") return [{ ...metadata, type: "reasoning", kind: "reasoning", label: text(block.label), text: text(block.description), status: text(block.status) }];
+    if (kind === "ui_blocks") return [{ ...metadata, type: "ui-blocks", kind: "ui-blocks", state: statusToToolState(block.status), toolCallId: text(block.toolCallId), contractVersion: text(block.contractVersion), bundle: record(block.bundle), errorText: text(block.error) }];
     if (kind === "hitl_request") {
       const hitl = record(block.hitl) || {};
       const hitlKind = String(block.hitlKind || hitl.kind || "");
@@ -64,7 +215,7 @@ function partsFromResponseBlocks(blocks, fallbackText = "") {
       const expected = allowedActions[hitlKind];
       if (actions.length !== expected.length || actions.some((action, actionIndex) => action !== expected[actionIndex])) return [];
       return [{
-        id,
+        ...metadata,
         type: "hitl",
         kind: "hitl",
         interruptId: String(block.interruptId || hitl.interrupt_id || ""),
@@ -73,63 +224,93 @@ function partsFromResponseBlocks(blocks, fallbackText = "") {
         allowedActions: actions,
         status: String(block.status || "pending"),
         presentation: record(hitl.presentation) || hitl,
-        resolution: record(block.resolution),
-        raw: block
+        questions: hitlQuestions(record(hitl.presentation) || {}),
+        resolution: hitlResolution(block.resolution)
       }];
     }
-    if (kind === "error") return [{ id, type: "error", kind: "error", errorText: String(record(block.error)?.message || block.text || "The run failed."), raw: block }];
-    if (kind === "source") return [{ id, type: "source", kind: "source", title: String(block.title || "Source"), url: text(block.url), description: text(block.description), raw: block }];
-    if (kind === "citation") return [{ id, type: "citation", kind: "citation", sourceId: text(block.sourceId), label: text(block.label), url: text(block.url), raw: block }];
+    if (kind === "error") {
+      const failure = failureView(block.failure) || failureView(block.error);
+      return [{
+        ...metadata,
+        type: "error",
+        kind: "error",
+        errorText: failure?.message || String(block.text || "The run failed."),
+        failure
+      }];
+    }
+    if (kind === "source") return [{ ...metadata, type: "source", kind: "source", title: String(block.title || "Source"), url: text(block.url), description: text(block.description) }];
+    if (kind === "citation") return [{ ...metadata, type: "citation", kind: "citation", sourceId: text(block.sourceId), label: text(block.label), url: text(block.url) }];
     if (kind === "attachment") {
       const attachment = record(block.attachment) || {};
-      return [{ id, type: "attachment", kind: "attachment", attachment: { ...attachment, id: text(attachment.id) || void 0, filename: text(attachment.name) || "Attachment", mediaType: text(attachment.mime_type) || void 0 }, raw: block }];
+      return [{ ...metadata, type: "attachment", kind: "attachment", attachment: { ...attachment, id: text(attachment.id) || void 0, filename: text(attachment.name) || "Attachment", mediaType: text(attachment.mime_type) || void 0 } }];
     }
-    return [{ id, type: "data", kind: "data", name: kind, data: block, raw: block }];
+    return [{ ...metadata, type: "data", kind: "data", name: kind, data: block }];
   });
   if (!parts.some((part) => part.kind === "text") && fallbackText.trim()) {
-    parts.push({ id: "assistant-text", type: "text", kind: "text", text: fallbackText.trim() });
+    parts.push({ id: fallbackPartId, type: "text", kind: "text", text: fallbackText.trim() });
   }
   return parts;
 }
 function assistantProjectionFromEvent(event) {
   const payload = record(event.payload) || {};
   const content = text(payload.assistant_output_text) || "";
-  const fromBlocks = partsFromResponseBlocks(payload.response_blocks, content);
-  if (fromBlocks.length) return { content, parts: fromBlocks };
-  if (event.event === "reasoning.update") return {
+  const fromBlocks = partsFromResponseBlocks(
+    payload.response_blocks,
     content,
-    parts: [{ id: `reasoning-${event.seq}`, type: "reasoning", kind: "reasoning", label: text(payload.label), text: text(payload.description), status: text(payload.status), raw: payload }]
+    `${event.run_id}:assistant-text`
+  );
+  if (fromBlocks.length) return {
+    content: content || fromBlocks.filter((part) => part.kind === "text").map((part) => part.text).join(""),
+    parts: fromBlocks
   };
-  if (event.event === "ui_blocks.updated") return {
-    content,
-    parts: [{ id: `ui-blocks-${event.seq}`, type: "ui-blocks", kind: "ui-blocks", state: "input-available", bundle: record(payload.bundle), raw: payload }]
+  const fromPatch = partsFromResponseBlocks(
+    payload.response_block === void 0 ? void 0 : [payload.response_block]
+  );
+  if (fromPatch.length) return { content, parts: fromPatch };
+  return { content, parts: [] };
+}
+function modelTurnPartFromEvent(event) {
+  const eventName = String(event.event || "");
+  const payload = record(event.payload) || {};
+  const source = eventName === "run.snapshot" ? record(payload.active_model_turn) : payload;
+  if (!source || eventName !== "model.turn.started" && eventName !== "run.snapshot" || source.status !== "running" || !text(source.model_turn_id)) return null;
+  const modelTurnId = String(source.model_turn_id);
+  const iteration = finiteNumber(source.iteration);
+  return {
+    id: `model-turn:${modelTurnId}`,
+    type: "model-turn",
+    kind: "model-turn",
+    modelTurnId,
+    turnKind: source.kind === "agent" ? "agent" : "model",
+    status: "running",
+    runId: event.run_id || null,
+    sequence: finiteNumber(event.seq),
+    timestamp: text(event.ts),
+    ...iteration === null ? {} : { iteration },
+    raw: source
   };
-  if (event.event === "runtime.error") return {
-    content,
-    parts: [{ id: `error-${event.seq}`, type: "error", kind: "error", errorText: String(record(payload.error)?.message || "The run failed."), raw: payload }]
+}
+function contextCompressionPartFromEvent(event, existingParts = []) {
+  if (String(event.event || "") !== "context.compression.updated") return null;
+  const payload = record(event.payload) || {};
+  const compression = normalizeContextCompression(payload.context_compression);
+  if (!compression?.active) return null;
+  const status = compression.status === "completed" || compression.status === "failed" ? compression.status : "started";
+  const activePart = [...existingParts].reverse().find(
+    (part) => part.kind === "context-compression" && part.status === "started"
+  );
+  const sequence = finiteNumber(event.seq);
+  const id = status === "started" ? `context-compression:${event.run_id || "run"}:${sequence ?? "active"}` : activePart?.id || `context-compression:${event.run_id || "run"}:${sequence ?? "terminal"}`;
+  return {
+    id,
+    type: "context-compression",
+    kind: "context-compression",
+    runId: event.run_id || null,
+    sequence,
+    timestamp: text(event.ts),
+    status,
+    compression
   };
-  if ((event.event === "source.added" || event.event === "citation.added") && record(payload.source)) {
-    return { content, parts: partsFromResponseBlocks([payload.source]) };
-  }
-  if (event.event === "tool.started") {
-    const toolName = String(payload.display_name || "Tool");
-    return {
-      content,
-      parts: [{ id: String(payload.tool_call_id || `tool-${event.seq}`), type: `tool-${toolName}`, kind: "tool", toolName, toolCallId: text(payload.tool_call_id), state: "input-available", presentation: { title: toolName }, raw: payload }]
-    };
-  }
-  if (event.event === "hitl.requested") {
-    const hitl = record(payload.hitl) || {};
-    const kind = String(hitl.kind || "");
-    const actions = Array.isArray(hitl.allowed_actions) ? hitl.allowed_actions.map(String) : [];
-    if (kind in allowedActions && actions.length === allowedActions[kind].length && actions.every((action, index) => action === allowedActions[kind][index])) {
-      return {
-        content,
-        parts: [{ id: `hitl-${event.seq}`, type: "hitl", kind: "hitl", interruptId: String(hitl.interrupt_id || ""), hitlKind: kind, message: String(hitl.message || ""), allowedActions: actions, status: "pending", presentation: record(hitl.presentation) || hitl, raw: payload }]
-      };
-    }
-  }
-  return { content, parts: [] };
 }
 function threadDetailToMessages(detail) {
   return (detail.turns || []).flatMap((item, index) => {
@@ -138,7 +319,25 @@ function threadDetailToMessages(detail) {
     const assistantText = text(turn.assistant_output_text) || "";
     const runId = text(turn.run_id);
     const createdAt = text(turn.created_at) || (/* @__PURE__ */ new Date(0)).toISOString();
-    const attachments = Array.isArray(turn.attachments) ? turn.attachments.flatMap((attachment) => record(attachment) ? [record(attachment)] : []) : [];
+    const rawFeedback = record(turn.feedback);
+    const feedback = rawFeedback && (rawFeedback.rating === "like" || rawFeedback.rating === "dislike") && text(rawFeedback.created_at) && text(rawFeedback.updated_at) ? {
+      rating: rawFeedback.rating === "like" ? "like" : "dislike",
+      reason: [
+        "incorrect",
+        "irrelevant",
+        "incomplete",
+        "unsafe",
+        "citation_issue",
+        "other"
+      ].includes(String(rawFeedback.reason || "")) ? rawFeedback.reason : null,
+      comment: text(rawFeedback.comment),
+      created_at: String(rawFeedback.created_at),
+      updated_at: String(rawFeedback.updated_at)
+    } : null;
+    const attachments = Array.isArray(turn.attachments) ? turn.attachments.flatMap((attachment) => {
+      const value = record(attachment);
+      return value ? [attachmentResultToChatAttachment(value)] : [];
+    }) : [];
     const output = [];
     if (userText || attachments.length) output.push({
       id: String(turn.id || `${runId || index}-user`),
@@ -149,21 +348,45 @@ function threadDetailToMessages(detail) {
       attachments,
       messageIndex: typeof turn.turn_index === "number" ? turn.turn_index : index
     });
-    if (assistantText || Array.isArray(turn.response_blocks)) output.push({
-      id: `${runId || turn.id || index}-assistant`,
-      role: "assistant",
-      runId,
-      content: assistantText,
-      createdAt: text(turn.completed_at) || createdAt,
-      isFinal: !["queued", "running", "paused", "cancelling"].includes(String(turn.status || "").toLowerCase()),
-      parts: partsFromResponseBlocks(turn.response_blocks, assistantText),
-      messageIndex: typeof turn.turn_index === "number" ? turn.turn_index : index
-    });
+    if (assistantText || Array.isArray(turn.response_blocks)) {
+      const assistantParts = partsFromResponseBlocks(
+        turn.response_blocks,
+        assistantText,
+        `${runId || turn.id || index}-assistant-text`
+      );
+      output.push({
+        id: `${runId || turn.id || index}-assistant`,
+        role: "assistant",
+        runId,
+        content: assistantText,
+        createdAt: text(turn.completed_at) || createdAt,
+        isFinal: !["queued", "running", "paused", "cancelling"].includes(String(turn.status || "").toLowerCase()),
+        feedback,
+        parts: assistantParts,
+        messageIndex: typeof turn.turn_index === "number" ? turn.turn_index : index
+      });
+    }
     return output;
   });
 }
+function latestThreadContext(detail) {
+  let contextWindow = null;
+  for (const turn of detail.turns || []) {
+    contextWindow = mergeContextWindowUpdate(contextWindow, turn.context_window);
+  }
+  return {
+    contextWindow,
+    contextCompression: compressionFromContextWindow(contextWindow)
+  };
+}
 function attachmentResultToChatAttachment(result) {
-  return { ...result, id: result.id, filename: result.filename, mediaType: result.mime_type, status: result.status };
+  return {
+    ...result,
+    id: result.id,
+    filename: result.filename,
+    mediaType: result.mime_type,
+    status: result.processing_status
+  };
 }
 
 // src/provider.tsx
@@ -193,6 +416,11 @@ function useAgentClient() {
 }
 
 // src/state.ts
+import {
+  compressionFromContextWindow as compressionFromContextWindow2,
+  mergeContextWindowUpdate as mergeContextWindowUpdate2,
+  normalizeContextCompression as normalizeContextCompression2
+} from "@agents24/client/protocol";
 var initialAgentChatState = {
   threads: [],
   activeThreadId: null,
@@ -200,9 +428,62 @@ var initialAgentChatState = {
   activeRunId: null,
   cursor: null,
   streamingMessageId: null,
+  contextWindow: null,
+  contextCompression: null,
+  contextCompressionRevision: 0,
   runState: "idle",
-  error: null
+  error: null,
+  operationError: null,
+  backgroundError: null
 };
+function captureAgentChatThreadSelection(state) {
+  return {
+    activeRunId: state.activeRunId,
+    activeThreadId: state.activeThreadId,
+    cursor: state.cursor,
+    messages: state.messages,
+    runState: state.runState,
+    streamingMessageId: state.streamingMessageId,
+    contextWindow: state.contextWindow,
+    contextCompression: state.contextCompression,
+    contextCompressionRevision: state.contextCompressionRevision
+  };
+}
+function restoreAgentChatThreadSelection(state, snapshot) {
+  return {
+    ...state,
+    ...snapshot,
+    runState: snapshot.activeRunId ? "reconnecting" : snapshot.runState
+  };
+}
+function withAgentChatOperationError(state, operation, cause) {
+  return {
+    ...state,
+    operationError: { kind: "operation", operation, cause }
+  };
+}
+function clearAgentChatOperationError(state, operation) {
+  if (!state.operationError || operation && state.operationError.operation !== operation) {
+    return state;
+  }
+  return { ...state, operationError: null };
+}
+function withAgentChatBackgroundError(state, cause) {
+  return {
+    ...state,
+    backgroundError: { kind: "background", source: "thread_events", cause }
+  };
+}
+function clearAgentChatBackgroundError(state) {
+  return state.backgroundError ? { ...state, backgroundError: null } : state;
+}
+function reconcileRefreshedThreads(current, incoming, activeThreadId) {
+  if (!activeThreadId || incoming.some((thread) => thread.id === activeThreadId)) {
+    return incoming;
+  }
+  const active = current.find((thread) => thread.id === activeThreadId);
+  return active?.isHydrated ? [active, ...incoming] : incoming;
+}
 function appendStableStreamingTurn(messages, userMessage, assistantMessage) {
   const next = [...messages];
   if (!next.some((message) => message.id === userMessage.id)) next.push(userMessage);
@@ -222,6 +503,43 @@ function upsertStableAssistantMessage(messages, input) {
   else next[index] = input.update(next[index]);
   return next;
 }
+function appendAssistantDelta(parts, delta, fallbackPartId) {
+  const next = [...parts];
+  const trailing = next[next.length - 1];
+  if (trailing?.kind === "text") {
+    next[next.length - 1] = { ...trailing, text: `${trailing.text}${delta}` };
+    return next;
+  }
+  next.push({ id: fallbackPartId, type: "text", kind: "text", text: delta });
+  return next;
+}
+function upsertResponseBlockParts(parts, incoming) {
+  const next = [...parts];
+  for (const part of incoming) {
+    const index = next.findIndex((current) => current.id === part.id);
+    if (index === -1) next.push(part);
+    else next[index] = part;
+  }
+  return next;
+}
+function reconcileModelTurnParts(parts, event) {
+  const eventName = String(event.event || "");
+  const payload = event.payload || {};
+  const terminal = eventName === "run.completed" || eventName === "run.failed" || eventName === "run.cancelled";
+  const modelTurnId = typeof payload.model_turn_id === "string" ? payload.model_turn_id : null;
+  let next = parts;
+  if (eventName === "run.snapshot" || terminal) {
+    next = next.filter((part) => part.kind !== "model-turn");
+  } else if (eventName === "assistant.delta" && typeof payload.content === "string" && payload.content) {
+    next = next.filter((part) => part.kind !== "model-turn" || part.turnKind !== "agent");
+  } else if (eventName.startsWith("tool.") || eventName === "node.status.updated") {
+    next = next.filter((part) => part.kind !== "model-turn" || part.turnKind !== "agent");
+  } else if ((eventName === "model.turn.failed" || eventName === "model.turn.completed" && payload.outcome !== "tool_calls") && modelTurnId) {
+    next = next.filter((part) => part.kind !== "model-turn" || part.modelTurnId !== modelTurnId);
+  }
+  const active = modelTurnPartFromEvent(event);
+  return active ? upsertResponseBlockParts(next, [active]) : next;
+}
 function applyRuntimeEvent(state, event) {
   const projection = assistantProjectionFromEvent(event);
   const eventName = String(event.event || "");
@@ -229,41 +547,84 @@ function applyRuntimeEvent(state, event) {
   const messageId = state.streamingMessageId || `${runId || "run"}-assistant`;
   const terminal = eventName === "run.completed" || eventName === "run.failed" || eventName === "run.cancelled";
   const paused = eventName === "run.paused" || projection.parts.some((part) => part.kind === "hitl" && part.status === "pending");
-  const existing = state.messages.find((message) => message.id === messageId || Boolean(runId && message.runId === runId));
+  const cancelling = eventName === "run.cancelling" || String(event.payload?.status || "") === "cancelling";
+  const existing = state.messages.find((message) => message.role === "assistant" && (message.id === messageId || Boolean(runId && message.runId === runId)));
   const payload = event.payload || {};
+  const eventThreadId = typeof payload.thread_id === "string" && payload.thread_id.trim() ? payload.thread_id.trim() : null;
+  const contextApplies = (!state.activeThreadId || !eventThreadId || eventThreadId === state.activeThreadId) && (!state.activeRunId || !runId || runId === state.activeRunId);
+  const contextWindow = contextApplies ? mergeContextWindowUpdate2(state.contextWindow, payload.context_window) : state.contextWindow;
+  const explicitCompression = contextApplies ? normalizeContextCompression2(payload.context_compression) : null;
+  const contextCompression = contextApplies ? explicitCompression || compressionFromContextWindow2(contextWindow) || state.contextCompression : state.contextCompression;
+  const hasLiveCompressionUpdate = Boolean(
+    contextApplies && (explicitCompression?.active || compressionFromContextWindow2(
+      mergeContextWindowUpdate2(null, payload.context_window)
+    )?.active)
+  );
   const delta = eventName === "assistant.delta" && typeof payload.content === "string" ? payload.content : "";
-  const content = delta ? `${existing?.content || ""}${delta}` : projection.content || existing?.content || "";
-  const deltaParts = delta ? [{ id: `${runId || "run"}-assistant-text`, type: "text", kind: "text", text: content }] : [];
-  const incomingParts = projection.parts.length ? projection.parts : deltaParts;
-  const parts = incomingParts.length ? [...(existing?.parts || []).filter((part) => !incomingParts.some((incoming) => incoming.id === part.id || incoming.kind === "text" && part.kind === "text")), ...incomingParts] : existing?.parts || [];
+  const hasCanonicalResponseBlocks = Array.isArray(payload.response_blocks);
+  const content = hasCanonicalResponseBlocks ? projection.content : delta ? `${existing?.content || ""}${delta}` : projection.content || existing?.content || "";
+  const projectedParts = hasCanonicalResponseBlocks ? projection.parts : delta ? appendAssistantDelta(
+    existing?.parts || [],
+    delta,
+    `${runId || "run"}-assistant-text-${event.seq}`
+  ) : projection.parts.length ? upsertResponseBlockParts(existing?.parts || [], projection.parts) : existing?.parts || [];
+  const lifecycleParts = reconcileModelTurnParts(projectedParts, event);
+  const compressionPart = contextApplies && explicitCompression?.active ? contextCompressionPartFromEvent(event, lifecycleParts) : null;
+  const parts = compressionPart ? upsertResponseBlockParts(lifecycleParts, [compressionPart]) : lifecycleParts;
+  const activeThreadId = eventThreadId || state.activeThreadId;
+  const messages = upsertStableAssistantMessage(state.messages, {
+    messageId,
+    runId,
+    create: () => ({
+      id: messageId,
+      role: "assistant",
+      runId,
+      content,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      isFinal: terminal,
+      parts
+    }),
+    update: (message) => ({
+      ...message,
+      runId: runId ?? message.runId,
+      content,
+      parts,
+      isFinal: terminal || message.isFinal
+    })
+  });
+  const threads = activeThreadId ? state.threads.some((thread) => thread.id === activeThreadId) ? state.threads.map((thread) => thread.id === activeThreadId ? {
+    ...thread,
+    messages,
+    isHydrated: true,
+    last_run_id: runId ?? thread.last_run_id,
+    contextWindow,
+    contextCompression
+  } : thread) : [{
+    id: activeThreadId,
+    title: null,
+    messages,
+    isHydrated: true,
+    last_run_id: runId,
+    contextWindow,
+    contextCompression
+  }, ...state.threads] : state.threads;
   return {
     ...state,
+    activeThreadId,
     activeRunId: terminal ? null : runId,
     cursor: typeof event.seq === "number" ? event.seq : state.cursor,
-    messages: upsertStableAssistantMessage(state.messages, {
-      messageId,
-      runId,
-      create: () => ({
-        id: messageId,
-        role: "assistant",
-        runId,
-        content,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        isFinal: terminal,
-        parts
-      }),
-      update: (message) => ({
-        ...message,
-        runId: runId ?? message.runId,
-        content,
-        parts,
-        isFinal: terminal || message.isFinal
-      })
-    }),
-    runState: paused ? "paused" : terminal ? eventName === "run.completed" ? "completed" : "failed" : "streaming",
+    messages,
+    threads,
+    contextWindow,
+    contextCompression,
+    contextCompressionRevision: hasLiveCompressionUpdate ? state.contextCompressionRevision + 1 : state.contextCompressionRevision,
+    runState: paused ? "paused" : cancelling ? "cancelling" : terminal ? eventName === "run.completed" ? "completed" : eventName === "run.cancelled" ? "cancelled" : "failed" : "streaming",
     streamingMessageId: terminal || paused ? null : messageId
   };
 }
+function applyRuntimeEvents(state, events) {
+  return events.reduce(applyRuntimeEvent, state);
+}
 function applyThreadSummaryEvent(threads, event) {
   if (event.event === "snapshot_required") return threads;
   if (event.event === "thread.deleted") return threads.filter((thread) => thread.id !== event.thread_id);
@@ -278,15 +639,74 @@ function applyThreadSummaryEvent(threads, event) {
 
 // src/use-agent-chat.ts
 import * as React2 from "react";
+
+// src/runtime-event-buffer.ts
+function runtimeEventFrameScheduler() {
+  const runtime = globalThis;
+  if (typeof runtime.requestAnimationFrame !== "function") return void 0;
+  return (callback) => {
+    const handle = runtime.requestAnimationFrame?.(callback);
+    return () => {
+      if (handle !== void 0) runtime.cancelAnimationFrame?.(handle);
+    };
+  };
+}
+function createRuntimeEventFrameBuffer(apply, scheduleFrame) {
+  let pending = [];
+  let cancelFrame = null;
+  const flush = () => {
+    cancelFrame?.();
+    cancelFrame = null;
+    if (!pending.length) return;
+    const events = pending;
+    pending = [];
+    apply(events);
+  };
+  return {
+    dispose() {
+      cancelFrame?.();
+      cancelFrame = null;
+      pending = [];
+    },
+    flush,
+    push(event) {
+      if (event.event !== "assistant.delta" || !scheduleFrame) {
+        pending.push(event);
+        flush();
+        return;
+      }
+      pending.push(event);
+      if (cancelFrame) return;
+      cancelFrame = scheduleFrame(() => {
+        cancelFrame = null;
+        if (!pending.length) return;
+        const events = pending;
+        pending = [];
+        apply(events);
+      });
+    }
+  };
+}
+
+// src/initial-thread.ts
+function resolveInitialActiveThreadId(options, storedThreadId) {
+  return Object.prototype.hasOwnProperty.call(options, "activeThreadId") ? options.activeThreadId ?? null : storedThreadId;
+}
+function shouldHydrateSelectedThread(selectedThreadId, activeThreadId, activeThreadIsHydrated) {
+  return Boolean(selectedThreadId) && (selectedThreadId !== activeThreadId || !activeThreadIsHydrated);
+}
+function isCurrentThreadOpenRequest(input) {
+  return !input.signalAborted && input.requestGeneration === input.currentGeneration && input.requestedThreadId === input.activeThreadId;
+}
+
+// src/use-agent-chat.ts
 function summaryToStored(thread) {
   return { ...thread, id: String(thread.id), messages: [], isHydrated: false };
 }
 function activeRunIdFromThread(thread) {
   if (!thread) return null;
-  const active = thread.active_run;
-  const status = String(active?.status || thread.last_run_status || "").toLowerCase();
-  if (!["queued", "running", "cancelling"].includes(status)) return null;
-  return String(active?.run_id || thread.last_run_id || "") || null;
+  const activity = getThreadActivity(thread);
+  return activity.isSpinning ? activity.runId : null;
 }
 function useAgentChat(options = {}) {
   const runtime = useAgents24Runtime();
@@ -295,7 +715,10 @@ function useAgentChat(options = {}) {
   const threadPageSize = options.threadPageSize ?? 50;
   const [state, setState] = React2.useState(() => ({
     ...initialAgentChatState,
-    activeThreadId: options.activeThreadId ?? runtime.storage?.loadActiveThreadId?.() ?? null,
+    activeThreadId: resolveInitialActiveThreadId(
+      options,
+      runtime.storage?.loadActiveThreadId?.() ?? null
+    ),
     threads: runtime.storage?.loadThreads() ?? []
   }));
   const [isLoadingThreads, setIsLoadingThreads] = React2.useState(false);
@@ -305,6 +728,9 @@ function useAgentChat(options = {}) {
   const [isLoadingOlder, setIsLoadingOlder] = React2.useState(false);
   const [isSubmitting, setIsSubmitting] = React2.useState(false);
   const streamControllerRef = React2.useRef(null);
+  const threadOpenControllerRef = React2.useRef(null);
+  const threadOpenGenerationRef = React2.useRef(0);
+  const refreshThreadsPromiseRef = React2.useRef(null);
   const attachRunRef = React2.useRef(async () => void 0);
   const stateRef = React2.useRef(state);
   stateRef.current = state;
@@ -320,33 +746,87 @@ function useAgentChat(options = {}) {
       return next;
     });
   }, [persist]);
+  const eventBuffer = React2.useMemo(
+    () => createRuntimeEventFrameBuffer(
+      (events) => update((current) => applyRuntimeEvents(current, events)),
+      runtimeEventFrameScheduler()
+    ),
+    [update]
+  );
+  const clearOperationError = React2.useCallback((operation) => {
+    update((current) => clearAgentChatOperationError(current, operation));
+  }, [update]);
+  const clearBackgroundError = React2.useCallback(() => {
+    update(clearAgentChatBackgroundError);
+  }, [update]);
+  const failOperation = React2.useCallback((operation, cause) => {
+    update((current) => withAgentChatOperationError(current, operation, cause));
+  }, [update]);
+  const invalidateThreadOpen = React2.useCallback(() => {
+    threadOpenGenerationRef.current += 1;
+    threadOpenControllerRef.current?.abort("Thread selection changed.");
+    threadOpenControllerRef.current = null;
+    setIsLoadingHistory(false);
+  }, []);
   const detach = React2.useCallback(() => {
+    eventBuffer.flush();
     streamControllerRef.current?.abort();
     streamControllerRef.current = null;
     update((current) => ({ ...current, streamingMessageId: null, runState: current.activeRunId ? "reconnecting" : "idle" }));
-  }, [update]);
-  React2.useEffect(() => () => streamControllerRef.current?.abort(), []);
-  const refreshThreads = React2.useCallback(async () => {
+  }, [eventBuffer, update]);
+  React2.useEffect(() => () => {
+    eventBuffer.dispose();
+    streamControllerRef.current?.abort();
+    threadOpenControllerRef.current?.abort();
+  }, [eventBuffer]);
+  const refreshThreads = React2.useCallback(() => {
+    if (refreshThreadsPromiseRef.current) return refreshThreadsPromiseRef.current;
+    clearOperationError();
     setIsLoadingThreads(true);
-    try {
-      const result = await client.threads.list({ limit: threadPageSize });
-      setThreadTotal(result.total);
-      update((current) => {
-        const byId = new Map(current.threads.map((thread) => [thread.id, thread]));
-        const nextThreads = result.items.map((item) => {
-          const existing = byId.get(item.id);
-          return { ...existing, ...summaryToStored(item), messages: existing?.messages || [], isHydrated: existing?.isHydrated };
+    const request = (async () => {
+      try {
+        const result = await client.threads.list({ limit: threadPageSize });
+        setThreadTotal(result.total);
+        update((current) => {
+          const byId = new Map(current.threads.map((thread) => [thread.id, thread]));
+          const nextThreads = result.items.map((item) => {
+            const existing = byId.get(item.id);
+            return { ...existing, ...summaryToStored(item), messages: existing?.messages || [], isHydrated: existing?.isHydrated };
+          });
+          return {
+            ...current,
+            threads: reconcileRefreshedThreads(
+              current.threads,
+              nextThreads,
+              current.activeThreadId
+            )
+          };
         });
-        return { ...current, threads: nextThreads };
-      });
-    } finally {
-      setIsLoadingThreads(false);
-    }
-  }, [client, threadPageSize, update]);
+      } catch (error) {
+        if (!isAbortLike(error)) {
+          failOperation("refresh_threads", error);
+          throw error;
+        }
+      } finally {
+        setIsLoadingThreads(false);
+      }
+    })();
+    refreshThreadsPromiseRef.current = request;
+    void request.then(
+      () => {
+        if (refreshThreadsPromiseRef.current === request) refreshThreadsPromiseRef.current = null;
+      },
+      () => {
+        if (refreshThreadsPromiseRef.current === request) refreshThreadsPromiseRef.current = null;
+      }
+    );
+    return request;
+  }, [clearOperationError, client, failOperation, threadPageSize, update]);
   const loadMoreThreads = React2.useCallback(async () => {
     if (isLoadingMoreThreads) return;
     const skip = stateRef.current.threads.length;
     if (threadTotal !== void 0 && skip >= threadTotal) return;
+    clearOperationError();
     setIsLoadingMoreThreads(true);
     try {
       const result = await client.threads.list({ skip, limit: threadPageSize });
@@ -364,64 +844,126 @@ function useAgentChat(options = {}) {
         }
         return { ...current, threads: [...byId.values()] };
       });
+    } catch (error) {
+      if (!isAbortLike(error)) {
+        failOperation("load_more_threads", error);
+        throw error;
+      }
     } finally {
       setIsLoadingMoreThreads(false);
     }
-  }, [client, isLoadingMoreThreads, threadPageSize, threadTotal, update]);
+  }, [clearOperationError, client, failOperation, isLoadingMoreThreads, threadPageSize, threadTotal, update]);
   const openThread = React2.useCallback(async (threadId) => {
+    const previousSelection = captureAgentChatThreadSelection(stateRef.current);
+    threadOpenControllerRef.current?.abort("A newer thread was selected.");
+    const requestController = runtime.createAbortController();
+    threadOpenControllerRef.current = requestController;
+    const requestGeneration = threadOpenGenerationRef.current + 1;
+    threadOpenGenerationRef.current = requestGeneration;
     detach();
-    update((current) => ({ ...current, activeThreadId: threadId, error: null, messages: current.threads.find((thread) => thread.id === threadId)?.messages || [] }));
+    clearOperationError();
+    update((current) => ({
+      ...current,
+      activeThreadId: threadId,
+      activeRunId: null,
+      cursor: null,
+      error: null,
+      messages: current.threads.find((thread) => thread.id === threadId)?.messages || [],
+      contextWindow: current.threads.find((thread) => thread.id === threadId)?.contextWindow || null,
+      contextCompression: current.threads.find((thread) => thread.id === threadId)?.contextCompression || null,
+      contextCompressionRevision: 0,
+      runState: "idle",
+      streamingMessageId: null
+    }));
     setIsLoadingHistory(true);
     try {
-      const detail = await client.threads.get({ threadId, limit: pageSize, includeRunEvents: true });
+      const detail = await client.threads.get({
+        threadId,
+        limit: pageSize,
+        signal: requestController.signal
+      });
+      if (!isCurrentThreadOpenRequest({
+        activeThreadId: stateRef.current.activeThreadId,
+        currentGeneration: threadOpenGenerationRef.current,
+        requestGeneration,
+        requestedThreadId: threadId,
+        signalAborted: requestController.signal.aborted
+      })) return;
       const messages = threadDetailToMessages(detail);
+      const context = latestThreadContext(detail);
       const stored = {
         ...detail,
         messages,
         isHydrated: true,
         hasOlderTurns: Boolean(detail.paging?.has_more),
-        nextBeforeTurnIndex: detail.paging?.next_before_turn_index ?? null
+        nextBeforeTurnIndex: detail.paging?.next_before_turn_index ?? null,
+        ...context
       };
-      update((current) => ({
+      update((current) => isCurrentThreadOpenRequest({
+        activeThreadId: current.activeThreadId,
+        currentGeneration: threadOpenGenerationRef.current,
+        requestGeneration,
+        requestedThreadId: threadId,
+        signalAborted: requestController.signal.aborted
+      }) ? {
         ...current,
         activeThreadId: threadId,
         messages,
+        ...context,
+        contextCompressionRevision: 0,
         activeRunId: activeRunIdFromThread(stored),
         threads: current.threads.some((thread) => thread.id === threadId) ? current.threads.map((thread) => thread.id === threadId ? stored : thread) : [stored, ...current.threads]
-      }));
+      } : current);
       const activeRunId = activeRunIdFromThread(stored);
-      if (activeRunId) await attachRunRef.current(activeRunId);
+      if (activeRunId && isCurrentThreadOpenRequest({
+        activeThreadId: stateRef.current.activeThreadId,
+        currentGeneration: threadOpenGenerationRef.current,
+        requestGeneration,
+        requestedThreadId: threadId,
+        signalAborted: requestController.signal.aborted
+      })) await attachRunRef.current(activeRunId).catch(() => void 0);
+    } catch (error) {
+      if (!isAbortLike(error) && requestGeneration === threadOpenGenerationRef.current) {
+        failOperation("open_thread", error);
+        update((current) => restoreAgentChatThreadSelection(current, previousSelection));
+        if (previousSelection.activeRunId) {
+          void attachRunRef.current(previousSelection.activeRunId, previousSelection.cursor ?? void 0).catch(() => void 0);
+        }
+        throw error;
+      }
     } finally {
-      setIsLoadingHistory(false);
+      if (requestGeneration === threadOpenGenerationRef.current) {
+        if (threadOpenControllerRef.current === requestController) threadOpenControllerRef.current = null;
+        setIsLoadingHistory(false);
+      }
     }
-  }, [client, detach, pageSize, update]);
+  }, [clearOperationError, client, detach, failOperation, pageSize, runtime, update]);
   const consumeEvent = React2.useCallback((event) => {
-    update((current) => {
-      const next = applyRuntimeEvent(current, event);
-      if (!next.activeThreadId) return next;
-      return {
-        ...next,
-        threads: next.threads.map((thread) => thread.id === next.activeThreadId ? { ...thread, messages: next.messages, isHydrated: true, last_run_id: next.activeRunId } : thread)
-      };
-    });
-  }, [update]);
+    eventBuffer.push(event);
+  }, [eventBuffer]);
   const attachRun = React2.useCallback(async (runId, cursor) => {
     streamControllerRef.current?.abort();
     const controller = runtime.createAbortController();
     streamControllerRef.current = controller;
+    clearOperationError();
     update((current) => ({ ...current, activeRunId: runId, runState: "reconnecting", error: null }));
     try {
       const result = await client.runs.attach({ runId, cursor, signal: controller.signal }, consumeEvent);
       update((current) => ({ ...current, activeRunId: result.detached ? runId : current.activeRunId, cursor: result.cursor ?? current.cursor, runState: result.detached ? "reconnecting" : current.runState }));
     } catch (error) {
-      if (!isAbortLike(error)) update((current) => ({ ...current, error, runState: "failed", streamingMessageId: null }));
+      if (!isAbortLike(error)) {
+        update((current) => ({ ...current, runState: "failed", streamingMessageId: null }));
+        failOperation("attach_run", error);
+        throw error;
+      }
     } finally {
       if (streamControllerRef.current === controller) streamControllerRef.current = null;
     }
-  }, [client, consumeEvent, runtime, update]);
+  }, [clearOperationError, client, consumeEvent, failOperation, runtime, update]);
   attachRunRef.current = attachRun;
   const submit = React2.useCallback(async (input) => {
     if (!input.text.trim() && !input.attachmentIds?.length) return;
+    invalidateThreadOpen();
     detach();
     const controller = runtime.createAbortController();
     streamControllerRef.current = controller;
@@ -430,76 +972,208 @@ function useAgentChat(options = {}) {
     const idempotencyKey = runtime.createId();
     const userMessage = { id: userId, role: "user", content: input.text.trim(), createdAt: (/* @__PURE__ */ new Date()).toISOString(), parts: input.text.trim() ? [{ id: `${userId}-text`, type: "text", kind: "text", text: input.text.trim() }] : [], attachments: input.attachments };
     const assistantMessage = { id: assistantId, role: "assistant", content: "", createdAt: (/* @__PURE__ */ new Date()).toISOString(), isFinal: false, parts: [] };
+    clearOperationError();
     update((current) => ({ ...current, messages: appendStableStreamingTurn(current.messages, userMessage, assistantMessage), streamingMessageId: assistantId, runState: "streaming", error: null }));
     setIsSubmitting(true);
     try {
       const result = await client.chat.stream({ input: input.text.trim(), threadId: stateRef.current.activeThreadId || void 0, attachmentIds: input.attachmentIds, requestedModelId: input.requestedModelId, idempotencyKey, signal: controller.signal }, consumeEvent);
       update((current) => ({ ...current, activeThreadId: result.threadId || current.activeThreadId, activeRunId: result.detached ? result.runId : current.activeRunId, cursor: result.cursor, runState: result.detached ? "reconnecting" : current.runState }));
-      if (result.threadId) await refreshThreads();
+      if (result.threadId) await refreshThreads().catch(() => void 0);
     } catch (error) {
-      if (!isAbortLike(error)) update((current) => ({ ...current, error, runState: "failed", streamingMessageId: null }));
+      if (!isAbortLike(error)) {
+        update((current) => ({ ...current, runState: "failed", streamingMessageId: null }));
+        failOperation("submit", error);
+        throw error;
+      }
     } finally {
       setIsSubmitting(false);
       if (streamControllerRef.current === controller) streamControllerRef.current = null;
     }
-  }, [client, consumeEvent, detach, refreshThreads, runtime, update]);
+  }, [clearOperationError, client, consumeEvent, detach, failOperation, invalidateThreadOpen, refreshThreads, runtime, update]);
   const startNewThread = React2.useCallback(() => {
+    invalidateThreadOpen();
     detach();
     update((current) => ({ ...initialAgentChatState, threads: current.threads }));
-  }, [detach, update]);
+  }, [detach, invalidateThreadOpen, update]);
   const deleteThread = React2.useCallback(async (threadId) => {
-    await client.threads.delete({ threadId, idempotencyKey: runtime.createId() });
-    update((current) => ({ ...current, activeThreadId: current.activeThreadId === threadId ? null : current.activeThreadId, messages: current.activeThreadId === threadId ? [] : current.messages, threads: current.threads.filter((thread) => thread.id !== threadId) }));
-  }, [client, runtime, update]);
+    if (stateRef.current.activeThreadId === threadId) invalidateThreadOpen();
+    clearOperationError();
+    try {
+      await client.threads.delete({ threadId, idempotencyKey: runtime.createId() });
+      update((current) => ({
+        ...current,
+        activeThreadId: current.activeThreadId === threadId ? null : current.activeThreadId,
+        messages: current.activeThreadId === threadId ? [] : current.messages,
+        contextWindow: current.activeThreadId === threadId ? null : current.contextWindow,
+        contextCompression: current.activeThreadId === threadId ? null : current.contextCompression,
+        contextCompressionRevision: current.activeThreadId === threadId ? 0 : current.contextCompressionRevision,
+        threads: current.threads.filter((thread) => thread.id !== threadId)
+      }));
+    } catch (error) {
+      if (!isAbortLike(error)) {
+        failOperation("delete_thread", error);
+        throw error;
+      }
+    }
+  }, [clearOperationError, client, failOperation, invalidateThreadOpen, runtime, update]);
   const cancelRun = React2.useCallback(async () => {
     const runId = stateRef.current.activeRunId;
-    if (!runId) return;
-    await client.runs.cancel({ runId, idempotencyKey: runtime.createId() });
-    detach();
-    update((current) => ({ ...current, activeRunId: null, runState: "completed", streamingMessageId: null }));
-  }, [client, detach, runtime, update]);
-  const resumeHitl = React2.useCallback(async (part, action, comment) => {
+    if (!runId || stateRef.current.runState === "cancelling") return;
+    const previousRunState = stateRef.current.runState;
+    clearOperationError();
+    update((current) => current.activeRunId === runId ? { ...current, runState: "cancelling" } : current);
+    try {
+      const result = await client.runs.cancel({ runId, idempotencyKey: runtime.createId() });
+      if (result.status === "cancelled") {
+        detach();
+        update((current) => ({
+          ...current,
+          activeRunId: null,
+          runState: "cancelled",
+          streamingMessageId: null
+        }));
+      } else if (result.status === "cancelling") {
+        update((current) => ({
+          ...current,
+          activeRunId: runId,
+          runState: "cancelling"
+        }));
+      } else {
+        detach();
+        update((current) => ({
+          ...current,
+          activeRunId: null,
+          runState: result.status === "completed" ? "completed" : "failed",
+          streamingMessageId: null
+        }));
+      }
+    } catch (error) {
+      if (!isAbortLike(error)) {
+        update((current) => current.activeRunId === runId ? { ...current, runState: previousRunState } : current);
+        failOperation("cancel_run", error);
+        throw error;
+      }
+    }
+  }, [clearOperationError, client, detach, failOperation, runtime, update]);
+  const resumeHitl = React2.useCallback(async (part, response) => {
     const runId = stateRef.current.activeRunId || stateRef.current.messages.find((message) => message.parts.includes(part))?.runId;
-    if (!runId) throw new Error("No paused run is available to resume.");
-    const result = await client.hitl.resume({ runId, interruptId: part.interruptId, action, comment, idempotencyKey: runtime.createId() });
-    await attachRun(result.run_id || runId);
-  }, [attachRun, client, runtime]);
+    clearOperationError();
+    if (!runId) {
+      const error = new Error("No paused run is available to resume.");
+      failOperation("resume_hitl", error);
+      throw error;
+    }
+    try {
+      const result = await client.hitl.resume({
+        runId,
+        interruptId: part.interruptId,
+        ...response,
+        idempotencyKey: runtime.createId()
+      });
+      await attachRun(result.run_id || runId);
+    } catch (error) {
+      if (!isAbortLike(error)) failOperation("resume_hitl", error);
+      throw error;
+    }
+  }, [attachRun, clearOperationError, client, failOperation, runtime]);
+  const setFeedback = React2.useCallback(async (message, input) => {
+    const runId = message.runId;
+    if (!runId || message.role !== "assistant" || message.isFinal === false) {
+      const error = new Error("Only persisted final responses can receive feedback.");
+      failOperation("set_feedback", error);
+      throw error;
+    }
+    const previous = message.feedback ?? null;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const optimistic = input.rating ? {
+      rating: input.rating,
+      reason: input.rating === "dislike" ? input.reason ?? null : null,
+      comment: input.rating === "dislike" ? input.comment?.trim() || null : null,
+      created_at: previous?.created_at || timestamp,
+      updated_at: timestamp
+    } : null;
+    const replaceFeedback = (current, feedback) => {
+      const messages = current.messages.map(
+        (item) => item.id === message.id ? { ...item, feedback } : item
+      );
+      return {
+        ...current,
+        messages,
+        threads: current.threads.map((thread) => ({
+          ...thread,
+          messages: thread.messages.map(
+            (item) => item.id === message.id ? { ...item, feedback } : item
+          )
+        }))
+      };
+    };
+    clearOperationError();
+    update((current) => replaceFeedback(current, optimistic));
+    try {
+      const result = await client.runs.setFeedback({ runId, ...input });
+      update((current) => replaceFeedback(current, result.feedback));
+    } catch (error) {
+      update(
+        (current) => withAgentChatOperationError(
+          replaceFeedback(current, previous),
+          "set_feedback",
+          error
+        )
+      );
+      throw error;
+    }
+  }, [clearOperationError, client, failOperation, update]);
   const loadOlder = React2.useCallback(async () => {
     const thread = stateRef.current.threads.find((item) => item.id === stateRef.current.activeThreadId);
     if (!thread?.nextBeforeTurnIndex) return;
+    clearOperationError();
     setIsLoadingOlder(true);
     try {
-      const detail = await client.threads.get({ threadId: thread.id, limit: pageSize, beforeTurnIndex: thread.nextBeforeTurnIndex, includeRunEvents: true });
+      const detail = await client.threads.get({ threadId: thread.id, limit: pageSize, beforeTurnIndex: thread.nextBeforeTurnIndex });
       const older = threadDetailToMessages(detail);
       update((current) => ({ ...current, messages: [...older, ...current.messages.filter((message) => !older.some((item) => item.id === message.id))], threads: current.threads.map((item) => item.id === thread.id ? { ...item, hasOlderTurns: Boolean(detail.paging?.has_more), nextBeforeTurnIndex: detail.paging?.next_before_turn_index ?? null } : item) }));
+    } catch (error) {
+      if (!isAbortLike(error)) {
+        failOperation("load_older_turns", error);
+        throw error;
+      }
     } finally {
       setIsLoadingOlder(false);
     }
-  }, [client, pageSize, update]);
+  }, [clearOperationError, client, failOperation, pageSize, update]);
   const regenerate = React2.useCallback(async (message) => {
     const index = stateRef.current.messages.findIndex((item) => item.id === message.id);
     const user = stateRef.current.messages.slice(0, index).reverse().find((item) => item.role === "user");
-    if (user) await submit({ text: user.content, attachments: user.attachments });
+    if (user) await submit({
+      text: user.content,
+      attachmentIds: chatAttachmentIds(user.attachments),
+      attachments: user.attachments
+    });
   }, [submit]);
-  React2.useEffect(() => {
-    void refreshThreads();
-  }, [refreshThreads]);
   React2.useEffect(() => {
     const controller = runtime.createAbortController();
+    clearBackgroundError();
     void client.threads.events({ signal: controller.signal }, async (event) => {
       if (event.event === "snapshot_required") {
+        clearBackgroundError();
         await refreshThreads();
         return;
       }
-      update((current) => ({ ...current, threads: applyThreadSummaryEvent(current.threads, event) }));
+      update((current) => ({
+        ...clearAgentChatBackgroundError(current),
+        threads: applyThreadSummaryEvent(current.threads, event)
+      }));
     }).catch((error) => {
-      if (!isAbortLike(error)) update((current) => ({ ...current, error }));
+      if (!isAbortLike(error)) update((current) => withAgentChatBackgroundError(current, error));
     });
     return () => controller.abort();
-  }, [client, refreshThreads, runtime, update]);
+  }, [clearBackgroundError, client, refreshThreads, runtime.createAbortController, update]);
   React2.useEffect(() => {
     const threadId = options.activeThreadId;
-    if (threadId && threadId !== stateRef.current.activeThreadId) void openThread(threadId);
+    const activeThread2 = stateRef.current.threads.find((thread) => thread.id === stateRef.current.activeThreadId);
+    if (shouldHydrateSelectedThread(threadId, stateRef.current.activeThreadId, Boolean(activeThread2?.isHydrated))) {
+      void openThread(threadId).catch(() => void 0);
+    }
   }, [openThread, options.activeThreadId]);
   const activeThread = state.threads.find((thread) => thread.id === state.activeThreadId) || null;
   const hasMoreThreads = threadTotal === void 0 ? state.threads.length >= threadPageSize : state.threads.length < threadTotal;
@@ -515,6 +1189,8 @@ function useAgentChat(options = {}) {
     isSubmitting,
     attachRun,
     cancelRun,
+    clearBackgroundError,
+    clearOperationError,
     deleteThread,
     detach,
     loadOlder,
@@ -523,6 +1199,7 @@ function useAgentChat(options = {}) {
     refreshThreads,
     regenerate,
     resumeHitl,
+    setFeedback,
     startNewThread,
     submit
   };
@@ -594,7 +1271,7 @@ function useAgentThread(threadId, options = {}) {
         setIsLoading(false);
       }
     }
-  }, [client, createAbortController, options.beforeTurnIndex, options.includeRunEvents, options.limit, threadId]);
+  }, [client, createAbortController, options.beforeTurnIndex, options.limit, threadId]);
   React3.useEffect(() => {
     void load();
     return () => controllerRef.current?.abort();
@@ -639,17 +1316,24 @@ function useAgentAttachments() {
   const { client, createId } = useAgents24Runtime();
   const [uploads, setUploads] = React3.useState({});
   const [isUploading, setIsUploading] = React3.useState(false);
-  const upload = React3.useCallback(async (input) => {
+  const uploadBatch = React3.useCallback(async (input) => {
     setIsUploading(true);
     try {
-      const result = await client.attachments.upload({ upload: input, threadId: input.threadId, idempotencyKey: createId(), signal: input.signal });
-      setUploads((current) => ({ ...current, [result.id]: result }));
-      return attachmentResultToChatAttachment(result);
+      const results = await client.attachments.uploadBatch({ uploads: input.uploads, threadId: input.threadId, idempotencyKey: createId(), signal: input.signal });
+      setUploads((current) => Object.fromEntries([
+        ...Object.entries(current),
+        ...results.map((result) => [result.id, result])
+      ]));
+      return results.map(attachmentResultToChatAttachment);
     } finally {
       setIsUploading(false);
     }
   }, [client, createId]);
-  return { isUploading, upload, uploads };
+  const createContentAccess = React3.useCallback(
+    (input) => client.attachments.createContentAccess(input),
+    [client]
+  );
+  return { createContentAccess, isUploading, uploadBatch, uploads };
 }
 function useAgentHitl() {
   const { client, createId } = useAgents24Runtime();
@@ -685,13 +1369,24 @@ export {
   Agents24Provider,
   appendStableStreamingTurn,
   applyRuntimeEvent,
+  applyRuntimeEvents,
   applyThreadSummaryEvent,
   assistantProjectionFromEvent,
   attachmentResultToChatAttachment,
+  captureAgentChatThreadSelection,
+  chatAttachmentIds,
+  clearAgentChatBackgroundError,
+  clearAgentChatOperationError,
+  contextCompressionPartFromEvent,
   createPortableId,
+  getThreadActivity,
   initialAgentChatState,
   isAbortLike,
+  latestThreadContext,
+  modelTurnPartFromEvent,
   partsFromResponseBlocks,
+  reconcileRefreshedThreads,
+  restoreAgentChatThreadSelection,
   threadDetailToMessages,
   upsertStableAssistantMessage,
   useAgentAttachments,
@@ -702,6 +1397,8 @@ export {
   useAgentRun,
   useAgentThread,
   useAgentThreads,
-  useAgents24Runtime
+  useAgents24Runtime,
+  withAgentChatBackgroundError,
+  withAgentChatOperationError
 };
 //# sourceMappingURL=index.js.map