@opengeni/react 3.7.0-canary.0 → 3.7.0-canary.1

package/dist/chunk-5PQJOCX5.js

@@ -0,0 +1,902 @@
+import {
+  useDebouncedCallback,
+  useMutationRunner,
+  usePageLiveActivity,
+  usePolledValue,
+  useSessionEventTrigger
+} from "./chunk-KZ73RL76.js";
+import {
+  useEmbeddedFileAttachments,
+  useEmbeddedGoal,
+  useEmbeddedSession,
+  useEmbeddedSessionLineage,
+  useEmbeddedSessionMcpApprovalPolicy
+} from "./chunk-NEXLLTP4.js";
+
+// src/embedded-session-client.ts
+var requiredMethods = [
+  "getSession",
+  "listEvents",
+  "streamEvents",
+  "getComposerDraft",
+  "saveComposerDraft",
+  "submitComposerDraft",
+  "sendMessage",
+  "steerMessage",
+  "getQueue",
+  "moveQueueItem",
+  "editQueueItem",
+  "steerQueueItem",
+  "deleteQueueItem",
+  "pauseSession",
+  "resumeSession",
+  "sendApprovalDecision"
+];
+function createEmbeddedSessionClient(base, options = {}) {
+  const overrides = options.overrides ?? {};
+  const client = {};
+  for (const key of requiredMethods) {
+    const override = overrides[key];
+    const method = override ?? base[key];
+    if (typeof method !== "function") {
+      throw new TypeError(`Embedded session client method is required: ${key}`);
+    }
+    client[key] = method.bind(override === void 0 ? base : overrides);
+  }
+  const inferenceOverride = overrides.setWorkspaceInferenceState;
+  const inferenceBase = base.setWorkspaceInferenceState;
+  const inferenceMethod = inferenceOverride ?? inferenceBase;
+  if (typeof inferenceMethod === "function") {
+    client.setWorkspaceInferenceState = inferenceMethod.bind(
+      inferenceOverride === void 0 ? base : overrides
+    );
+  }
+  const mapDraft = options.mapComposerDraft;
+  if (!mapDraft) return client;
+  const getComposerDraft = client.getComposerDraft;
+  client.getComposerDraft = async (workspaceId, sessionId) => mapDraft(await getComposerDraft(workspaceId, sessionId), {
+    operation: "read",
+    workspaceId,
+    sessionId
+  });
+  const saveComposerDraft = client.saveComposerDraft;
+  client.saveComposerDraft = async (workspaceId, sessionId, request) => mapDraft(await saveComposerDraft(workspaceId, sessionId, request), {
+    operation: "save",
+    workspaceId,
+    sessionId
+  });
+  const submitComposerDraft = client.submitComposerDraft;
+  client.submitComposerDraft = async (workspaceId, sessionId, request) => {
+    const response = await submitComposerDraft(workspaceId, sessionId, request);
+    return {
+      ...response,
+      draft: mapDraft(response.draft, {
+        operation: "submit",
+        workspaceId,
+        sessionId
+      })
+    };
+  };
+  return client;
+}
+
+// src/hooks/use-file-attachments.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+var isImage = (file) => file.type.startsWith("image/");
+var fallbackAttachmentId = 0;
+function createAttachmentId() {
+  const cryptoSource = globalThis.crypto;
+  if (typeof cryptoSource?.randomUUID === "function") return cryptoSource.randomUUID();
+  fallbackAttachmentId += 1;
+  return `attachment:${Date.now().toString(36)}:${fallbackAttachmentId.toString(36)}`;
+}
+function secureContextRequiredErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "secure_context_required" ? error.code : void 0;
+}
+function useFileAttachments(options = {}) {
+  const { client, workspaceId } = useEmbeddedFileAttachments(options);
+  const pasteFilter = options.pasteFilter ?? isImage;
+  const [attachments, setAttachments] = useState([]);
+  const attachmentsRef = useRef(attachments);
+  attachmentsRef.current = attachments;
+  const sources = useRef(/* @__PURE__ */ new Map());
+  const previewUrls = useRef(/* @__PURE__ */ new Map());
+  const previewRetainers = useRef(/* @__PURE__ */ new Map());
+  const pendingPreviewRevocations = useRef(/* @__PURE__ */ new Set());
+  const revokePreview = useCallback((id) => {
+    const previewUrl = previewUrls.current.get(id);
+    if (!previewUrl) return;
+    if ((previewRetainers.current.get(id) ?? 0) > 0) {
+      pendingPreviewRevocations.current.add(id);
+      return;
+    }
+    previewUrls.current.delete(id);
+    pendingPreviewRevocations.current.delete(id);
+    URL.revokeObjectURL(previewUrl);
+  }, []);
+  const revokeAllPreviews = useCallback(() => {
+    for (const id of previewUrls.current.keys()) revokePreview(id);
+  }, [revokePreview]);
+  const retainPreview = useCallback(
+    (id) => {
+      if (!previewUrls.current.has(id)) return void 0;
+      previewRetainers.current.set(id, (previewRetainers.current.get(id) ?? 0) + 1);
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        const remaining = (previewRetainers.current.get(id) ?? 1) - 1;
+        if (remaining > 0) {
+          previewRetainers.current.set(id, remaining);
+          return;
+        }
+        previewRetainers.current.delete(id);
+        if (pendingPreviewRevocations.current.has(id)) revokePreview(id);
+      };
+    },
+    [revokePreview]
+  );
+  const committedAttachmentIds = useRef(/* @__PURE__ */ new Set());
+  useEffect(() => {
+    const currentIds = new Set(attachments.map((attachment) => attachment.id));
+    for (const id of committedAttachmentIds.current) {
+      if (!currentIds.has(id)) revokePreview(id);
+    }
+    committedAttachmentIds.current = currentIds;
+  }, [attachments, revokePreview]);
+  const scopeGeneration = useRef(0);
+  const previousScope = useRef({ client, workspaceId });
+  useEffect(() => {
+    const previous = previousScope.current;
+    if (previous.client === client && previous.workspaceId === workspaceId) return;
+    previousScope.current = { client, workspaceId };
+    scopeGeneration.current += 1;
+    sources.current.clear();
+    revokeAllPreviews();
+    setAttachments([]);
+  }, [client, revokeAllPreviews, workspaceId]);
+  useEffect(
+    () => () => {
+      scopeGeneration.current += 1;
+      sources.current.clear();
+      revokeAllPreviews();
+    },
+    [revokeAllPreviews]
+  );
+  const startUpload = useCallback(
+    (id, file) => {
+      const generation = scopeGeneration.current;
+      void client.uploadFile(workspaceId, {
+        filename: file.name || "file",
+        contentType: file.type || "application/octet-stream",
+        data: file
+      }).then((asset) => {
+        if (scopeGeneration.current !== generation) return;
+        sources.current.delete(id);
+        setAttachments(
+          (current) => current.map(
+            (attachment) => attachment.id === id ? {
+              ...attachment,
+              status: "ready",
+              file: asset,
+              name: asset.filename,
+              contentType: asset.contentType,
+              sizeBytes: asset.sizeBytes,
+              errorCode: void 0,
+              error: void 0
+            } : attachment
+          )
+        );
+      }).catch((error) => {
+        if (scopeGeneration.current !== generation) return;
+        setAttachments(
+          (current) => current.map(
+            (attachment) => attachment.id === id ? {
+              ...attachment,
+              status: "failed",
+              errorCode: secureContextRequiredErrorCode(error),
+              error: error instanceof Error ? error.message : String(error)
+            } : attachment
+          )
+        );
+      });
+    },
+    [client, workspaceId]
+  );
+  const addFiles = useCallback(
+    (files) => {
+      for (const file of files) {
+        const id = createAttachmentId();
+        sources.current.set(id, file);
+        const previewUrl = isImage(file) ? URL.createObjectURL(file) : void 0;
+        if (previewUrl) previewUrls.current.set(id, previewUrl);
+        setAttachments((current) => [
+          ...current,
+          {
+            id,
+            name: file.name || "image",
+            contentType: file.type || "application/octet-stream",
+            sizeBytes: file.size,
+            status: "uploading",
+            ...previewUrl ? { previewUrl } : {}
+          }
+        ]);
+        startUpload(id, file);
+      }
+    },
+    [startUpload]
+  );
+  const retry = useCallback(
+    (id) => {
+      const file = sources.current.get(id);
+      if (!file) {
+        return;
+      }
+      setAttachments(
+        (current) => current.map(
+          (attachment) => attachment.id === id ? { ...attachment, status: "uploading", errorCode: void 0, error: void 0 } : attachment
+        )
+      );
+      startUpload(id, file);
+    },
+    [startUpload]
+  );
+  const addFromPaste = useCallback(
+    (event) => {
+      const clipboardFiles = event.clipboardData?.files;
+      if (!clipboardFiles) {
+        return;
+      }
+      const files = [...clipboardFiles].filter(pasteFilter);
+      if (files.length > 0) {
+        addFiles(files);
+      }
+    },
+    [addFiles, pasteFilter]
+  );
+  const restoreReadyFiles = useCallback(
+    (files) => {
+      const incoming = /* @__PURE__ */ new Map();
+      for (const file of files) {
+        if (file.status === "ready" && file.workspaceId === workspaceId) {
+          incoming.set(file.id, file);
+        }
+      }
+      setAttachments((current) => {
+        const unresolved = current.filter((attachment) => attachment.status !== "ready");
+        const existingReady = new Map(
+          current.flatMap(
+            (attachment) => attachment.status === "ready" && attachment.file ? [[attachment.file.id, attachment]] : []
+          )
+        );
+        const restored = [...incoming.values()].map((file) => {
+          const existing = existingReady.get(file.id);
+          return existing ? {
+            ...existing,
+            name: file.filename,
+            contentType: file.contentType,
+            sizeBytes: file.sizeBytes,
+            status: "ready",
+            file,
+            errorCode: void 0,
+            error: void 0
+          } : {
+            id: `restored:${file.id}`,
+            name: file.filename,
+            contentType: file.contentType,
+            sizeBytes: file.sizeBytes,
+            status: "ready",
+            file
+            // No source File and no object URL: server metadata is the
+            // only authority restored across page/device boundaries.
+          };
+        });
+        return [...unresolved, ...restored];
+      });
+    },
+    [workspaceId]
+  );
+  const loadPreview = useCallback(
+    async (id, signal) => {
+      const generation = scopeGeneration.current;
+      const attachment = attachmentsRef.current.find((candidate) => candidate.id === id);
+      const createDownloadUrl = client.createFileDownloadUrl;
+      if (!attachment || attachment.status !== "ready" || !attachment.file || !attachment.contentType.startsWith("image/") || typeof createDownloadUrl !== "function" || signal?.aborted) {
+        return void 0;
+      }
+      const fileId = attachment.file.id;
+      const signed = await createDownloadUrl.call(client, workspaceId, fileId, { signal });
+      if (scopeGeneration.current !== generation || signal?.aborted) return void 0;
+      const current = attachmentsRef.current.find((candidate) => candidate.id === id);
+      if (current?.status !== "ready" || current.file?.id !== fileId) return void 0;
+      return signed.url;
+    },
+    [client, workspaceId]
+  );
+  const remove = useCallback(
+    (id) => {
+      sources.current.delete(id);
+      revokePreview(id);
+      setAttachments((current) => current.filter((attachment) => attachment.id !== id));
+    },
+    [revokePreview]
+  );
+  const removeReadyFiles = useCallback((fileIds) => {
+    const accepted = new Set(fileIds);
+    if (accepted.size === 0) return;
+    setAttachments(
+      (current) => current.filter((attachment) => {
+        return !(attachment.status === "ready" && attachment.file !== void 0 && accepted.has(attachment.file.id));
+      })
+    );
+  }, []);
+  const clear = useCallback(() => {
+    sources.current.clear();
+    revokeAllPreviews();
+    setAttachments([]);
+  }, [revokeAllPreviews]);
+  return {
+    attachments,
+    readyResources: attachments.flatMap(
+      (attachment) => attachment.status === "ready" && attachment.file ? [{ kind: "file", fileId: attachment.file.id }] : []
+    ),
+    uploading: attachments.some((attachment) => attachment.status === "uploading"),
+    hasUnresolved: attachments.some((attachment) => attachment.status !== "ready"),
+    addFiles,
+    addFromPaste,
+    restoreReadyFiles,
+    ...typeof client.createFileDownloadUrl === "function" ? { loadPreview } : {},
+    retry,
+    retainPreview,
+    remove,
+    removeReadyFiles,
+    clear
+  };
+}
+
+// src/hooks/use-goal.ts
+import { OpenGeniApiError } from "@opengeni/sdk";
+import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+function isGoalEvent(event) {
+  return event.type.startsWith("goal.");
+}
+function isGoalRefreshEvent(event) {
+  const type = event.type;
+  return isGoalEvent(event) || type.startsWith("turn.") || type.startsWith("session.") || type.startsWith("system.update.") || type.startsWith("workspace.inference.") || type.startsWith("user.");
+}
+function useGoal(sessionId, options = {}) {
+  const { client, workspaceId } = useEmbeddedGoal(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const sharedEvents = options.events;
+  const sharedFeed = sharedEvents !== void 0;
+  const pageLive = usePageLiveActivity();
+  const [goal, setGoal] = useState2(null);
+  const [loading, setLoading] = useState2(enabled);
+  const [error, setError] = useState2(null);
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
+  const generation = useRef2(0);
+  const targetKeyRef = useRef2(null);
+  const loadAbort = useRef2(null);
+  const retireLoads = useCallback2(() => {
+    generation.current += 1;
+    loadAbort.current?.abort();
+    loadAbort.current = null;
+  }, []);
+  const load = useCallback2(async () => {
+    if (!sessionId) {
+      return;
+    }
+    const ticket = ++generation.current;
+    loadAbort.current?.abort();
+    const controller = new AbortController();
+    loadAbort.current = controller;
+    try {
+      const fetched = await client.getGoal(workspaceId, sessionId, {
+        signal: controller.signal
+      });
+      if (ticket === generation.current) {
+        setGoal(fetched);
+        setError(null);
+        setLoading(false);
+      }
+    } catch (cause) {
+      if (ticket !== generation.current) {
+        return;
+      }
+      if (cause instanceof OpenGeniApiError && cause.status === 404) {
+        setGoal(null);
+        setError(null);
+      } else {
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+      }
+      setLoading(false);
+    } finally {
+      if (loadAbort.current === controller) loadAbort.current = null;
+    }
+  }, [client, workspaceId, sessionId]);
+  useEffect2(() => {
+    const targetKey = `${workspaceId} ${sessionId ?? ""}`;
+    if (targetKeyRef.current !== targetKey) {
+      targetKeyRef.current = targetKey;
+      setGoal(null);
+      setError(null);
+    }
+    if (!enabled || !pageLive) {
+      retireLoads();
+      setLoading(false);
+      return;
+    }
+    if (sharedFeed) {
+      setLoading(false);
+      return () => {
+        retireLoads();
+      };
+    }
+    setLoading(true);
+    const pollIntervalMs = options.pollIntervalMs;
+    if (pollIntervalMs === void 0 || pollIntervalMs <= 0) {
+      void load();
+      return () => {
+        retireLoads();
+      };
+    }
+    let cancelled = false;
+    let timer = null;
+    const schedule = () => {
+      if (cancelled) return;
+      timer = setTimeout(() => {
+        timer = null;
+        void load().finally(schedule);
+      }, pollIntervalMs);
+    };
+    void load().finally(schedule);
+    return () => {
+      cancelled = true;
+      if (timer !== null) clearTimeout(timer);
+      retireLoads();
+    };
+  }, [
+    load,
+    enabled,
+    pageLive,
+    workspaceId,
+    sessionId,
+    options.pollIntervalMs,
+    retireLoads,
+    sharedFeed
+  ]);
+  const scheduleRefresh = useDebouncedCallback(() => void load());
+  useSessionEventTrigger(client, workspaceId, sessionId, isGoalRefreshEvent, scheduleRefresh, {
+    enabled,
+    ...sharedEvents !== void 0 ? { events: sharedEvents } : {}
+  });
+  const pause = useCallback2(
+    async (rationale) => {
+      if (!sessionId) {
+        return null;
+      }
+      const result = await run(
+        () => client.updateGoal(workspaceId, sessionId, {
+          status: "paused",
+          ...rationale !== void 0 ? { rationale } : {}
+        })
+      );
+      if (result) {
+        setGoal(result);
+      }
+      return result;
+    },
+    [client, workspaceId, sessionId, run]
+  );
+  const resume = useCallback2(async () => {
+    if (!sessionId) {
+      return null;
+    }
+    const result = await run(() => client.updateGoal(workspaceId, sessionId, { status: "active" }));
+    if (result) {
+      setGoal(result);
+    }
+    return result;
+  }, [client, workspaceId, sessionId, run]);
+  const clearGoal = useCallback2(async () => {
+    if (!sessionId) {
+      return;
+    }
+    const ok = await run(async () => {
+      await client.deleteGoal(workspaceId, sessionId);
+      return true;
+    });
+    if (ok) {
+      retireLoads();
+      setGoal(null);
+      setError(null);
+    }
+  }, [client, workspaceId, sessionId, run, retireLoads]);
+  return {
+    goal,
+    isActive: goal?.status === "active",
+    isPaused: goal?.status === "paused",
+    isCompleted: goal?.status === "completed",
+    loading,
+    error,
+    refresh: load,
+    pause,
+    resume,
+    clearGoal,
+    deleteGoal: clearGoal,
+    updating: mutating,
+    mutationError,
+    clearMutationError
+  };
+}
+
+// src/hooks/use-session-control.ts
+import { useCallback as useCallback3, useLayoutEffect, useRef as useRef3 } from "react";
+function useSessionControl(sessionId, options = {}) {
+  const { client, workspaceId } = useEmbeddedSession(options);
+  const approvalTargetKey = `${workspaceId}\0${sessionId ?? ""}`;
+  const pendingApproval = useRef3(null);
+  useLayoutEffect(() => {
+    if (pendingApproval.current?.targetKey !== approvalTargetKey) {
+      pendingApproval.current = null;
+    }
+  }, [approvalTargetKey]);
+  const {
+    run: runControl,
+    mutating: controlling,
+    mutationError: controlError,
+    clearMutationError: clearControlError
+  } = useMutationRunner(approvalTargetKey);
+  const {
+    run: runApproval,
+    mutating: responding,
+    mutationError: approvalError,
+    clearMutationError: clearApprovalError
+  } = useMutationRunner(approvalTargetKey);
+  const pause = useCallback3(
+    async (reason) => {
+      if (!sessionId) {
+        return null;
+      }
+      return await runControl(
+        () => client.pauseSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
+      );
+    },
+    [client, workspaceId, sessionId, runControl]
+  );
+  const resume = useCallback3(
+    async (reason) => {
+      if (!sessionId) return null;
+      return await runControl(
+        () => client.resumeSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
+      );
+    },
+    [client, workspaceId, sessionId, runControl]
+  );
+  const decide = useCallback3(
+    async (approvalId, decision, message) => {
+      if (!sessionId) {
+        return null;
+      }
+      const decisionKey = JSON.stringify([approvalId, decision, message ?? null]);
+      if (pendingApproval.current?.decisionKey !== decisionKey) {
+        pendingApproval.current = {
+          targetKey: approvalTargetKey,
+          decisionKey,
+          clientEventId: crypto.randomUUID()
+        };
+      }
+      const clientEventId = pendingApproval.current.clientEventId;
+      const accepted = await runApproval(
+        () => client.sendApprovalDecision(workspaceId, sessionId, {
+          approvalId,
+          decision,
+          ...message !== void 0 ? { message } : {},
+          clientEventId
+        })
+      );
+      if (accepted !== null && pendingApproval.current?.targetKey === approvalTargetKey && pendingApproval.current.clientEventId === clientEventId) {
+        pendingApproval.current = null;
+      }
+      return accepted;
+    },
+    [approvalTargetKey, client, workspaceId, sessionId, runApproval]
+  );
+  const approve = useCallback3(
+    async (approvalId, message) => await decide(approvalId, "approve", message),
+    [decide]
+  );
+  const reject = useCallback3(
+    async (approvalId, message) => await decide(approvalId, "reject", message),
+    [decide]
+  );
+  const error = approvalError ?? controlError;
+  const clearError = useCallback3(() => {
+    clearControlError();
+    clearApprovalError();
+  }, [clearControlError, clearApprovalError]);
+  return {
+    pause,
+    resume,
+    controlling,
+    approve,
+    reject,
+    responding,
+    error,
+    clearError
+  };
+}
+
+// src/hooks/use-session-mcp-approval-policy.ts
+import { useCallback as useCallback4, useEffect as useEffect3, useLayoutEffect as useLayoutEffect2, useMemo, useRef as useRef4, useState as useState3 } from "react";
+function isSessionMcpApprovalPolicyEvent(event, serverId) {
+  if (event.type !== "session.mcp.approval_policy.updated") {
+    return false;
+  }
+  if (serverId === void 0) {
+    return true;
+  }
+  const payload = event.payload;
+  return payload?.serverId === serverId;
+}
+function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
+  const { client, workspaceId } = useEmbeddedSessionMcpApprovalPolicy(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId && serverId);
+  const [override, setOverride] = useState3(null);
+  const targetKey = `${workspaceId}\0${sessionId ?? ""}\0${serverId ?? ""}`;
+  const authoritativeGeneration = useRef4(0);
+  const mutationIdentity = useMemo(() => ({ client, targetKey }), [client, targetKey]);
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner(mutationIdentity);
+  useLayoutEffect2(() => {
+    authoritativeGeneration.current += 1;
+    setOverride(null);
+  }, [client, targetKey]);
+  const load = useCallback4(async () => {
+    const generation = authoritativeGeneration.current;
+    if (!sessionId || !serverId) {
+      return { targetKey, generation, server: null };
+    }
+    const session = await client.getSession(workspaceId, sessionId);
+    return {
+      targetKey,
+      generation,
+      server: session.mcpServers.find((server2) => server2.id === serverId) ?? null
+    };
+  }, [client, serverId, sessionId, targetKey, workspaceId]);
+  const {
+    data,
+    loading,
+    error: loadError,
+    refresh
+  } = usePolledValue(load, {
+    enabled,
+    pollIntervalMs: options.pollIntervalMs
+  });
+  useEffect3(() => {
+    if (data?.targetKey === targetKey && data.generation === authoritativeGeneration.current) {
+      setOverride(null);
+    }
+  }, [data, targetKey]);
+  const scheduleRefresh = useDebouncedCallback(() => void refresh());
+  const matchesPolicyEvent = useCallback4(
+    (event) => isSessionMcpApprovalPolicyEvent(event, serverId ?? void 0),
+    [serverId]
+  );
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    matchesPolicyEvent,
+    scheduleRefresh,
+    {
+      enabled,
+      ...options.events !== void 0 ? { events: options.events } : {}
+    },
+    async () => await refresh()
+  );
+  const update = useCallback4(
+    async (policy) => {
+      if (!sessionId || !serverId) {
+        return null;
+      }
+      const response = await run(
+        () => client.updateSessionMcpApprovalPolicy(workspaceId, sessionId, serverId, {
+          requireApproval: policy
+        })
+      );
+      if (response) {
+        authoritativeGeneration.current += 1;
+        setOverride(response.server);
+        void refresh();
+      }
+      return response;
+    },
+    [client, refresh, run, serverId, sessionId, workspaceId]
+  );
+  const server = override ?? data?.server ?? null;
+  return {
+    server,
+    policy: server?.requireApproval ?? null,
+    loading,
+    error: mutationError ?? loadError,
+    refresh: async () => {
+      await refresh();
+    },
+    update,
+    updating: mutating,
+    clearError: clearMutationError
+  };
+}
+
+// src/hooks/use-session-lineage.ts
+import { useCallback as useCallback5, useEffect as useEffect4, useRef as useRef5 } from "react";
+function isLineageRefreshEvent(event) {
+  if (event.type === "session.status.changed" || event.type === "session.created") {
+    return true;
+  }
+  if (event.type === "agent.toolCall.output") {
+    const payload = event.payload;
+    const name = typeof payload?.name === "string" ? payload.name : typeof payload?.toolName === "string" ? payload.toolName : "";
+    return name === "session_create" || name.endsWith("__session_create");
+  }
+  return false;
+}
+function isSessionCreateToolCallCreated(event) {
+  if (event.type !== "agent.toolCall.created") {
+    return false;
+  }
+  const payload = event.payload;
+  const name = typeof payload?.name === "string" ? payload.name : typeof payload?.toolName === "string" ? payload.toolName : "";
+  return name === "session_create" || name.endsWith("__session_create");
+}
+function useSessionLineage(sessionId, options = {}) {
+  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSessionLineage(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const nextReadGeneration = useRef5(0);
+  const beginRead = options.beginRead;
+  const load = useCallback5(
+    async (signal) => {
+      if (!sessionId) {
+        return {
+          lineage: { ancestors: [], children: [], truncated: false },
+          readGeneration: 0
+        };
+      }
+      let readGeneration = 0;
+      const lineage = await client.getSessionLineage(workspaceId, sessionId, {
+        signal,
+        onRequestStart: (sharedReadGeneration) => {
+          readGeneration = sharedReadGeneration ?? beginRead?.() ?? ++nextReadGeneration.current;
+        }
+      });
+      return {
+        lineage,
+        readGeneration
+      };
+    },
+    [beginRead, client, workspaceId, sessionId]
+  );
+  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled });
+  const refresh = state.refresh;
+  useEffect4(() => {
+    if (enabled && workspaceControlEvent) void refresh();
+  }, [enabled, refresh, workspaceControlEvent]);
+  useEffect4(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "lineage", refresh);
+  }, [enabled, refresh, registerSessionReconciler, sessionId]);
+  const refreshSoon = useDebouncedCallback(() => void refresh(), 150);
+  const delayedChildRefreshRef = useRef5(null);
+  useEffect4(() => {
+    return () => {
+      if (delayedChildRefreshRef.current !== null) {
+        clearTimeout(delayedChildRefreshRef.current);
+        delayedChildRefreshRef.current = null;
+      }
+    };
+  }, [sessionId, workspaceId]);
+  const refreshAfterChildCreate = useCallback5(() => {
+    void refresh();
+    if (delayedChildRefreshRef.current !== null) {
+      clearTimeout(delayedChildRefreshRef.current);
+    }
+    delayedChildRefreshRef.current = setTimeout(() => {
+      delayedChildRefreshRef.current = null;
+      void refresh();
+    }, 2500);
+  }, [refresh]);
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    isLineageRefreshEvent,
+    refreshSoon,
+    // SHARED-FEED ONLY: without a caller-provided events log the trigger would
+    // open its OWN streamEvents tail — a second live SSE connection next to the
+    // session route's useSessionEvents. A caller with no feed opts into polling
+    // (pollIntervalMs), never a duplicate stream.
+    { events: options.events, enabled: enabled && options.events !== void 0 }
+  );
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    isSessionCreateToolCallCreated,
+    refreshAfterChildCreate,
+    { events: options.events, enabled: enabled && options.events !== void 0 }
+  );
+  return {
+    lineage: state.data?.lineage ?? null,
+    loading: state.loading,
+    error: state.error,
+    readGeneration: state.data?.readGeneration ?? 0,
+    refresh
+  };
+}
+
+// src/approvals.ts
+function approvalsFromRequiresAction(payload) {
+  const approvals = payload && typeof payload === "object" ? payload.approvals : void 0;
+  if (!Array.isArray(approvals)) {
+    return [];
+  }
+  return approvals.map((approval, index) => {
+    const raw = approval && typeof approval === "object" ? approval : {};
+    const rawItem = raw.rawItem && typeof raw.rawItem === "object" ? raw.rawItem : {};
+    return {
+      // Mirror the runtime's canonical interruption identity before retaining
+      // the legacy top-level callId fallback for already-normalized payloads.
+      id: String(rawItem.callId ?? rawItem.id ?? raw.id ?? raw.callId ?? raw.name ?? index),
+      name: String(raw.name ?? raw.toolName ?? rawItem.name ?? "approval"),
+      arguments: raw.arguments ?? rawItem.arguments,
+      raw: approval
+    };
+  });
+}
+function projectPendingApprovals(events) {
+  let pending = [];
+  let owningTurnId = null;
+  for (const event of events) {
+    switch (event.type) {
+      case "session.requiresAction": {
+        pending = approvalsFromRequiresAction(event.payload);
+        owningTurnId = event.turnId ?? null;
+        break;
+      }
+      case "user.approvalDecision": {
+        const payload = event.payload && typeof event.payload === "object" ? event.payload : {};
+        if (typeof payload.approvalId === "string") {
+          pending = pending.filter((approval) => approval.id !== payload.approvalId);
+        }
+        break;
+      }
+      case "turn.completed":
+      case "turn.failed":
+      case "turn.cancelled": {
+        if (owningTurnId === null || event.turnId == null || event.turnId === owningTurnId) {
+          pending = [];
+          owningTurnId = null;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return pending;
+}
+
+export {
+  createEmbeddedSessionClient,
+  useFileAttachments,
+  isGoalEvent,
+  useGoal,
+  useSessionControl,
+  isSessionMcpApprovalPolicyEvent,
+  useSessionMcpApprovalPolicy,
+  isLineageRefreshEvent,
+  useSessionLineage,
+  approvalsFromRequiresAction,
+  projectPendingApprovals
+};
+//# sourceMappingURL=chunk-5PQJOCX5.js.map