@tangle-network/agent-app 0.43.13 → 0.43.14

package/dist/assistant/index.d.ts

@@ -1,12 +1,12 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
 import { ToolDetailRenderers, ChatUiMessage } from '../web-react/index.js';
+import '@tangle-network/agent-interface';
 import '../agent-activity-C8ZG0F0M.js';
 import '../flow-types-Cb_AblZs.js';
 import '../sandbox-terminal-BIIC__CP.js';
 import '../model-catalog-BEAEVDaa.js';
 import '../harness/index.js';
-import '@tangle-network/agent-interface';
 
 /**
  * Wire + UI types for the in-app assistant panel. The wire shapes mirror the

package/dist/assistant/index.js

@@ -3,7 +3,7 @@ import {
   ChatMessages,
   ModelPicker,
   ProviderLogo
-} from "../chunk-4X7OOVII.js";
+} from "../chunk-VMY4TKMN.js";
 import "../chunk-65P3HJY3.js";
 import "../chunk-2QI7XV2T.js";
 import "../chunk-E7QYOOON.js";

package/dist/{chunk-4X7OOVII.js → chunk-VMY4TKMN.js}

@@ -364,6 +364,145 @@ function BrandMark({ size = 24, className }) {
   return /* @__PURE__ */ jsx3(Suspense, { fallback: /* @__PURE__ */ jsx3(MarkSpacer, { size, className }), children: /* @__PURE__ */ jsx3(LazyKnot, { size, className }) });
 }
 
+// src/web-react/chat-interactions.ts
+import {
+  InteractionRequestSchema
+} from "@tangle-network/agent-interface";
+var INTERACTION_EVENT = "interaction";
+var INTERACTION_CANCEL_EVENT = "interaction.cancel";
+var INTERACTION_RESOLVED_EVENT = "interaction.resolved";
+var RENDERABLE_INTERACTION_KINDS = /* @__PURE__ */ new Set(["question", "plan"]);
+function isRenderableInteractionKind(kind) {
+  return RENDERABLE_INTERACTION_KINDS.has(kind);
+}
+function isSafeInteractionFieldKey(key) {
+  return /^[A-Za-z0-9_-]+$/.test(key) && key !== "__proto__" && key !== "constructor" && key !== "prototype";
+}
+function isTerminalInteractionStatus(status) {
+  return status !== "pending";
+}
+function canTransitionInteractionStatus(from, to) {
+  return from === "pending" && to !== from;
+}
+function cancelStatusFor(reason) {
+  return reason === "timeout" ? "expired" : "cancelled";
+}
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, stableValue(nested)])
+  );
+}
+function normalizedInteractionText(value) {
+  return (value ?? "").replace(/\s+/g, " ").trim();
+}
+function questionInteractionContentSignature(interaction) {
+  if (interaction.kind !== "question") return null;
+  return JSON.stringify(stableValue({
+    kind: interaction.kind,
+    title: normalizedInteractionText(interaction.title),
+    body: normalizedInteractionText(interaction.body),
+    fields: interaction.fields
+  }));
+}
+function dedupeQuestionInteractionsByContent(interactions) {
+  const seen = /* @__PURE__ */ new Set();
+  return interactions.filter((interaction) => {
+    const signature = questionInteractionContentSignature(interaction);
+    if (!signature) return true;
+    if (seen.has(signature)) return false;
+    seen.add(signature);
+    return true;
+  });
+}
+function parseInteractionRequest(data) {
+  const request = data?.request;
+  if (!request || typeof request !== "object") {
+    return { succeeded: false, error: "interaction event carried no request object" };
+  }
+  const validation = InteractionRequestSchema.safeParse(request);
+  if (!validation.success) {
+    return { succeeded: false, error: `malformed interaction request: ${validation.error.message}` };
+  }
+  return { succeeded: true, value: request };
+}
+function parseInteractionCancel(data) {
+  const id = typeof data?.id === "string" && data.id ? data.id : null;
+  if (!id) return { succeeded: false, error: "interaction.cancel event carried no id" };
+  const reason = typeof data?.reason === "string" && data.reason ? data.reason : void 0;
+  return { succeeded: true, value: { id, ...reason ? { reason } : {} } };
+}
+function fieldAcceptsFreeText(field) {
+  if (field.type === "text") return true;
+  if (field.type === "select") return field.allowCustom === true;
+  return false;
+}
+function composerAnswerDeliveries(pending) {
+  const deliveries = [];
+  for (const interaction of pending) {
+    if (interaction.kind !== "question") continue;
+    const field = interaction.fields.find(fieldAcceptsFreeText) ?? interaction.fields[0];
+    if (!field) continue;
+    deliveries.push({ interactionId: interaction.id, field });
+  }
+  return deliveries;
+}
+function composerAnswerData(field, text) {
+  return { [field.name]: field.type === "select" ? [text] : text };
+}
+function interactionPartKey(id) {
+  return `interaction:${id}`;
+}
+function noticePartKey(id) {
+  return `notice:${id}`;
+}
+function noticePart(noticeKind, id, text) {
+  return { type: "notice", id, noticeKind, text };
+}
+function interactionFromWireRequest(request) {
+  return {
+    id: request.id,
+    kind: request.kind,
+    title: request.title,
+    ...request.body ? { body: request.body } : {},
+    fields: request.answerSpec.fields,
+    status: "pending"
+  };
+}
+function interactionToPersistedPart(request, status, cancelReason) {
+  return {
+    type: "interaction",
+    id: request.id,
+    kind: request.kind,
+    title: request.title,
+    ...request.body ? { body: request.body } : {},
+    answerSpec: { fields: request.answerSpec.fields },
+    status,
+    ...cancelReason ? { cancelReason } : {}
+  };
+}
+function persistedPartToInteraction(part) {
+  if (String(part.type ?? "") !== "interaction") return null;
+  const id = typeof part.id === "string" && part.id ? part.id : null;
+  const kind = typeof part.kind === "string" && part.kind ? part.kind : null;
+  const title = typeof part.title === "string" ? part.title : "";
+  const answerSpec = part.answerSpec;
+  const fields = Array.isArray(answerSpec?.fields) ? answerSpec.fields : null;
+  const status = part.status;
+  const validStatus = status && ["pending", "answered", "declined", "cancelled", "expired"].includes(status);
+  if (!id || !kind || !fields || !validStatus) return null;
+  return {
+    id,
+    kind,
+    title,
+    ...typeof part.body === "string" && part.body ? { body: part.body } : {},
+    fields,
+    status,
+    ...typeof part.cancelReason === "string" && part.cancelReason ? { cancelReason: part.cancelReason } : {}
+  };
+}
+
 // src/web-react/chat-stream.ts
 function dispatchChatStreamLine(line, cb) {
   let receivedContent = false;
@@ -429,6 +568,16 @@ function dispatchChatStreamLine(line, cb) {
     case "metadata":
       cb.onMetadata?.(evt.data ?? {});
       break;
+    case "interaction": {
+      const parsed2 = parseInteractionRequest(evt.data);
+      if (parsed2.succeeded) {
+        cb.onInteraction?.(interactionFromWireRequest(parsed2.value));
+        receivedContent = true;
+      } else {
+        console.error("[chat-stream] dropping malformed interaction line:", parsed2.error);
+      }
+      break;
+    }
     case "error":
       cb.onErrorEvent?.(String(evt.details ?? evt.error ?? "Unknown stream error"));
       break;
@@ -1914,6 +2063,27 @@ export {
   ModelPicker,
   DEFAULT_EFFORT_LEVELS,
   EffortPicker,
+  INTERACTION_EVENT,
+  INTERACTION_CANCEL_EVENT,
+  INTERACTION_RESOLVED_EVENT,
+  isRenderableInteractionKind,
+  isSafeInteractionFieldKey,
+  isTerminalInteractionStatus,
+  canTransitionInteractionStatus,
+  cancelStatusFor,
+  questionInteractionContentSignature,
+  dedupeQuestionInteractionsByContent,
+  parseInteractionRequest,
+  parseInteractionCancel,
+  fieldAcceptsFreeText,
+  composerAnswerDeliveries,
+  composerAnswerData,
+  interactionPartKey,
+  noticePartKey,
+  noticePart,
+  interactionFromWireRequest,
+  interactionToPersistedPart,
+  persistedPartToInteraction,
   dispatchChatStreamLine,
   consumeChatStream,
   streamChatTurn,
@@ -1936,4 +2106,4 @@ export {
   useThinkingSeconds,
   ChatMessages
 };
-//# sourceMappingURL=chunk-4X7OOVII.js.map
+//# sourceMappingURL=chunk-VMY4TKMN.js.map