@athenaintel/react 0.18.0 → 0.20.0

package/dist/runtime/useAthenaStatewireRuntime.js

@@ -0,0 +1,180 @@
+import { Tools, useAui } from "@assistant-ui/react";
+import { DEEP_AGENT_DEFAULT_MESSAGE_WINDOW } from "../packages/agent-runtime/src/generated/runconfig-contract.js";
+import { useContext, useRef, useMemo } from "react";
+import "@assistant-ui/tap";
+import "statewire";
+import { isStatewireChannelTeardown } from "../packages/agent-runtime/src/errors.js";
+import "../packages/agent-runtime/src/statewire-suspended.js";
+import "@tanstack/react-query";
+import "../packages/agent-runtime/src/statewire-state.js";
+import "../packages/agent-runtime/src/messages.js";
+import "@assistant-ui/react-statewire";
+import "@assistant-ui/store";
+import "@assistant-ui/react-statewire/local-storage";
+import "../packages/agent-runtime/src/statewire-attach-observer.js";
+import "../packages/agent-runtime/src/thread-status.js";
+import { useDeepAgentRuntime, logUnhandledStatewireError } from "../packages/agent-runtime/src/use-deep-agent-runtime.js";
+import "@assistant-ui/core";
+import { AthenaAuthContext } from "../auth/AthenaAuthContext.js";
+import { collectStatewireClientTools, statewireClientToolWireEntries } from "../chat/statewire-client-tools.js";
+import { athenaDiagnostics } from "../diagnostics/athena-diagnostics.js";
+import { resolveStatewireAuthHeaders } from "./statewire-auth-headers.js";
+import { statewireSessionKey } from "./statewire-session-key.js";
+import { resolveAgentProp, buildStatewireRunConfig } from "./statewire-run-config.js";
+import { DEFAULT_STATEWIRE_MODEL } from "./statewire-run-config.js";
+const ATHENA_SDK_MESSAGE_WINDOW = {
+  size: DEEP_AGENT_DEFAULT_MESSAGE_WINDOW
+};
+const EMPTY_TOOLKIT = {};
+const EMPTY_TOOL_IDS = [];
+function useStatewireClientTools(frontendToolkit) {
+  return useMemo(
+    () => collectStatewireClientTools(frontendToolkit ?? EMPTY_TOOLKIT),
+    [frontendToolkit]
+  );
+}
+function useAthenaStatewireRuntime(config) {
+  var _a;
+  const {
+    syncUrl,
+    threadId,
+    isNewChat = false,
+    apiKey,
+    token,
+    getToken,
+    model,
+    agent,
+    channel,
+    tools = EMPTY_TOOL_IDS,
+    frontendToolIds = EMPTY_TOOL_IDS,
+    frontendToolkit = EMPTY_TOOLKIT,
+    workbench,
+    knowledgeBase,
+    systemPrompt,
+    appId,
+    extraRunConfig,
+    snapshotCache,
+    messageWindow = ATHENA_SDK_MESSAGE_WINDOW,
+    toolOutputs,
+    onError,
+    onConnectionChange,
+    onRawConnectionChange,
+    onRunningChange
+  } = config;
+  resolveAgentProp({ agent });
+  const clientTools = useStatewireClientTools(frontendToolkit);
+  const authContext = useContext(AthenaAuthContext);
+  const principal = ((_a = authContext == null ? void 0 : authContext.user) == null ? void 0 : _a.userId) ?? "";
+  const attachSpanRef = useRef(null);
+  const attachThreadRef = useRef(null);
+  if (attachThreadRef.current !== threadId) {
+    attachThreadRef.current = threadId;
+    attachSpanRef.current = athenaDiagnostics.span(
+      `statewire.attach:${threadId}`,
+      "statewire.attach.start",
+      { thread_id: threadId, is_new_chat: isNewChat }
+    );
+  }
+  const auiTools = useMemo(() => Tools({ toolkit: frontendToolkit }), [frontendToolkit]);
+  const useSdkClient = (thread) => useAui({ thread, tools: auiTools });
+  return useDeepAgentRuntime({
+    surface: "AthenaSDK",
+    threadId,
+    baseUrl: syncUrl,
+    // Option closures are re-read per render by the core, so credential
+    // rotation (new `token`/`getToken`/`apiKey` props) reaches the next
+    // request without remounting the thread. The transport's `staleAuth`
+    // (true right after a refused credential) is forwarded as `force`.
+    headers: (ctx) => resolveStatewireAuthHeaders({ apiKey, token, getToken }, ctx),
+    isNewChat,
+    // Queued entries render in the SDK's queue panel, so only the steer lane
+    // projects into the message tail.
+    laneProjection: "steer-only",
+    // Durable session: a reload resumes the lane and resends whatever the
+    // server has not marked durable. Scoped by host AND principal — a thread
+    // id is only meaningful against the backend that minted it, and a stored
+    // lane must never resend against another signed-in user. (Consumers
+    // server-render this SDK; the core's availability probe keeps those
+    // sessions process-local, as before the seam existed.)
+    session: {
+      kind: "local-storage",
+      key: (id) => statewireSessionKey({ syncUrl, principal, threadId: id })
+    },
+    snapshotCache,
+    // Windowed hello (see `ATHENA_SDK_MESSAGE_WINDOW`): the tail of the
+    // transcript instead of every message; the chat UI's history edge pages
+    // older ranges in and fetches cut tool outputs into `toolOutputs`.
+    messageWindow,
+    toolOutputs,
+    capabilities: { edit: true, reload: true, continue: true },
+    useClient: useSdkClient,
+    onStateChange: () => {
+      const endSpan = attachSpanRef.current;
+      if (endSpan) {
+        attachSpanRef.current = null;
+        endSpan("statewire.snapshot", { data: { thread_id: threadId } });
+      }
+    },
+    onConnectionChange: (connection) => {
+      athenaDiagnostics.gauge("statewire.connection", (connection == null ? void 0 : connection.status) ?? null);
+      if ((connection == null ? void 0 : connection.status) === "stopped") {
+        athenaDiagnostics.emit("statewire.connection", {
+          level: "warn",
+          data: {
+            status: connection.status,
+            reason: connection.reason,
+            message: connection.message
+          }
+        });
+      }
+      onConnectionChange == null ? void 0 : onConnectionChange(connection);
+    },
+    onRawConnectionChange,
+    onRunningChange,
+    // The runConfig getter is pulled at command-send time through the core's
+    // per-render ref, so it reads the latest props — consumers commonly pass
+    // fresh array literals per render, which must not thrash the registration
+    // (no `key`: the provider registers once per client).
+    runConfig: {
+      get: () => buildStatewireRunConfig({
+        model,
+        agent,
+        channel,
+        tools,
+        frontendToolIds,
+        workbench,
+        knowledgeBase,
+        systemPrompt,
+        appId,
+        extraRunConfig,
+        clientTools: statewireClientToolWireEntries(clientTools)
+      })
+    },
+    onError: (error) => {
+      if (!isStatewireChannelTeardown(error)) {
+        athenaDiagnostics.error(
+          "statewire.error",
+          error,
+          {
+            code: "statewire_rejected",
+            message: "The statewire host rejected a command",
+            hint: "Inspect error.detail — agora rejections carry a structured {code, message}."
+          },
+          { thread_id: threadId }
+        );
+      }
+      if (onError) {
+        onError(error);
+        return;
+      }
+      logUnhandledStatewireError("AthenaSDK", error);
+    }
+  });
+}
+export {
+  ATHENA_SDK_MESSAGE_WINDOW,
+  DEFAULT_STATEWIRE_MODEL,
+  useAthenaStatewireRuntime,
+  useStatewireClientTools
+};
+//# sourceMappingURL=useAthenaStatewireRuntime.js.map

package/dist/runtime/useAthenaStatewireRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAthenaStatewireRuntime.js","sources":["../../src/runtime/useAthenaStatewireRuntime.ts"],"sourcesContent":["import type { AssistantClient, Toolkit } from '@assistant-ui/react';\nimport { Tools, useAui } from '@assistant-ui/react';\nimport {\n  DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n  type DeepAgentMessageWindowDeclaration,\n  type DeepAgentThreadElement,\n  type DeepAgentThreadSnapshotCache,\n  type DeepAgentToolOutputStore,\n  isStatewireChannelTeardown,\n  logUnhandledStatewireError,\n  type RegisteredClientTool,\n  useDeepAgentRuntime,\n  type UseDeepAgentThreadOptions,\n} from '@athenaintel/agent-runtime';\nimport { useContext, useMemo, useRef } from 'react';\nimport { AthenaAuthContext } from '../auth/AthenaAuthContext';\nimport {\n  collectStatewireClientTools,\n  statewireClientToolWireEntries,\n} from '../chat/statewire-client-tools';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport {\n  type AthenaStatewireTokenGetter,\n  resolveStatewireAuthHeaders,\n} from './statewire-auth-headers';\nimport { statewireSessionKey } from './statewire-session-key';\n\ntype AthenaDiagnosticsSpanStarter = typeof athenaDiagnostics.span;\nimport {\n  buildStatewireRunConfig,\n  DEFAULT_STATEWIRE_MODEL,\n  resolveAgentProp,\n} from './statewire-run-config';\n\nexport { DEFAULT_STATEWIRE_MODEL };\n\n/**\n * The message window every SDK attach declares (`x-athena-deep-agent-window`):\n * the hello carries the transcript's tail plus the `messagesWindow` lane\n * instead of every message — megabytes on long threads, over the 1 MiB frame\n * limit of stock websocket clients. Older pages load from the\n * `StatewireHistoryEdge` row the chat UI mounts above the messages, and cut\n * tool outputs are fetched back for the cards that show them.\n */\nexport const ATHENA_SDK_MESSAGE_WINDOW: DeepAgentMessageWindowDeclaration = {\n  size: DEEP_AGENT_DEFAULT_MESSAGE_WINDOW,\n};\n\nexport interface AthenaStatewireRuntimeConfig {\n  /** Base URL of the statewire sync host (the `…/v2/threads` mount). */\n  syncUrl: string;\n  /** Thread ID the statewire session attaches to. */\n  threadId: string;\n  /** True only for a never-started local chat. Existing (or pre-assigned)\n   *  threads load until their server snapshot arrives. */\n  isNewChat?: boolean;\n  /** API key for authentication. Used when no auth token is provided. */\n  apiKey?: string;\n  /** Auth token. Takes priority over apiKey. */\n  token?: string | null;\n  /** Resolve the latest token immediately before a request (for expiring\n   *  clients). Called with `{ force: true }` right after the host refused the\n   *  previous credential (the transport's `staleAuth`), so a caching getter\n   *  mints a fresh token instead of returning the refused one. */\n  getToken?: AthenaStatewireTokenGetter;\n  /**\n   * Per-provider LRU of each thread's last wire state. A switch back to a\n   * remembered thread mounts with that snapshot and projects ready on the\n   * first frame instead of a loading treatment; the attach snapshot then\n   * replaces it. Owned above the per-thread mount so it survives switches.\n   */\n  snapshotCache?: DeepAgentThreadSnapshotCache;\n  /**\n   * The message window declared on the attach (see\n   * {@link ATHENA_SDK_MESSAGE_WINDOW}, the default). `false` keeps the full\n   * snapshot for a host that renders no history loader.\n   */\n  messageWindow?: DeepAgentMessageWindowDeclaration | false;\n  /**\n   * Full tool outputs fetched back for a windowed wire's cut tool messages;\n   * the thread re-converts when one lands. `AthenaProvider` owns one per\n   * provider and hands the same store to `StatewireHistoryEdge`.\n   */\n  toolOutputs?: DeepAgentToolOutputStore;\n  /** LLM model identifier. Defaults to the deep-agent default model. */\n  model?: string;\n  /** Agent selector: only `collab_agent:<asset_id>` refs are accepted (the run\n   *  executes AS that published collab agent). Any other non-empty value\n   *  throws — see `resolveAgentProp`. */\n  agent?: string;\n  /** Collab-agent channel id selecting that channel's overrides. */\n  channel?: string;\n  /** Backend toolkit IDs to enable. */\n  tools?: string[];\n  /** Frontend tool IDs to include in enabled_tools. */\n  frontendToolIds?: string[];\n  /** Frontend tools registered on the assistant client. Tools with a local\n   *  `execute` are also declared as `client_tools` and executed through the\n   *  statewire client-tool bridge. */\n  frontendToolkit?: Toolkit;\n  /** Asset IDs to include in the workbench. */\n  workbench?: string[];\n  /** Knowledge base IDs for RAG context. */\n  knowledgeBase?: string[];\n  /** System prompt override. */\n  systemPrompt?: string;\n  /** Client app identifier for session filtering. Sent as app_id in runConfig.custom. */\n  appId?: string;\n  /** Additional fields merged into runConfig.custom. */\n  extraRunConfig?: Record<string, unknown>;\n  /** Called on statewire transport errors (send rejections, stream failures). */\n  onError?: (error: Error) => void;\n  /** Projected connection status changes (deduped; null on unmount). */\n  onConnectionChange?: UseDeepAgentThreadOptions['onConnectionChange'];\n  /** Raw connection observer — carries the transport's reconnect handle. */\n  onRawConnectionChange?: UseDeepAgentThreadOptions['onRawConnectionChange'];\n  /** Notified when a run starts/stops. */\n  onRunningChange?: UseDeepAgentThreadOptions['onRunningChange'];\n}\n\nconst EMPTY_TOOLKIT: Toolkit = {};\nconst EMPTY_TOOL_IDS: string[] = [];\n\n/** The client tools derived from the runtime's frontend toolkit — exposed so\n *  the provider can mount the client-tool bridge with the same set. */\nexport function useStatewireClientTools(\n  frontendToolkit: Toolkit | undefined,\n): RegisteredClientTool[] {\n  return useMemo(\n    () => collectStatewireClientTools(frontendToolkit ?? EMPTY_TOOLKIT),\n    [frontendToolkit],\n  );\n}\n\n/**\n * Statewire runtime for the Athena SDK — a thin shim over the shared\n * `@athenaintel/agent-runtime` `useDeepAgentRuntime`: it attaches to the\n * agora-hosted deep-agent thread at `${syncUrl}/${threadId}` and returns the\n * `AssistantClient` to mount via `AuiProvider` — the same integration shape as\n * the Olympus, Chrome extension, Office, and mobile statewire hosts.\n *\n * Auth: a token (resolved live through `getToken` when provided) rides\n * `Authorization: Bearer`, and an API key falls back to `X-API-KEY` — both\n * accepted by the statewire host.\n */\nexport function useAthenaStatewireRuntime(\n  config: AthenaStatewireRuntimeConfig,\n): AssistantClient {\n  const {\n    syncUrl,\n    threadId,\n    isNewChat = false,\n    apiKey,\n    token,\n    getToken,\n    model,\n    agent,\n    channel,\n    tools = EMPTY_TOOL_IDS,\n    frontendToolIds = EMPTY_TOOL_IDS,\n    frontendToolkit = EMPTY_TOOLKIT,\n    workbench,\n    knowledgeBase,\n    systemPrompt,\n    appId,\n    extraRunConfig,\n    snapshotCache,\n    messageWindow = ATHENA_SDK_MESSAGE_WINDOW,\n    toolOutputs,\n    onError,\n    onConnectionChange,\n    onRawConnectionChange,\n    onRunningChange,\n  } = config;\n\n  // Fail loud at mount, not at first send: the statewire host always runs the\n  // Athena deep agent, so an `agent` outside the collab_agent namespace can\n  // never apply. Throwing here (render time) is what makes a misconfigured\n  // integration visible instead of quietly answering as the wrong agent.\n  resolveAgentProp({ agent });\n\n  const clientTools = useStatewireClientTools(frontendToolkit);\n\n  // The persisted command lane is keyed by WHO is signed in as well as by host\n  // and thread (see `statewireSessionKey`).\n  const authContext = useContext(AthenaAuthContext);\n  const principal = authContext?.user?.userId ?? '';\n\n  // Attach → first server snapshot span, keyed per thread attach.\n  const attachSpanRef = useRef<ReturnType<AthenaDiagnosticsSpanStarter> | null>(null);\n  const attachThreadRef = useRef<string | null>(null);\n  if (attachThreadRef.current !== threadId) {\n    attachThreadRef.current = threadId;\n    attachSpanRef.current = athenaDiagnostics.span(\n      `statewire.attach:${threadId}`,\n      'statewire.attach.start',\n      { thread_id: threadId, is_new_chat: isNewChat },\n    );\n  }\n\n  const auiTools = useMemo(() => Tools({ toolkit: frontendToolkit }), [frontendToolkit]);\n  // Web client for the shared runtime core (a `use*` name so the\n  // rules-of-hooks lint sees the `useAui` call inside a custom hook; the core\n  // invokes it unconditionally every render).\n  const useSdkClient = (thread: DeepAgentThreadElement) => useAui({ thread, tools: auiTools });\n\n  return useDeepAgentRuntime({\n    surface: 'AthenaSDK',\n    threadId,\n    baseUrl: syncUrl,\n    // Option closures are re-read per render by the core, so credential\n    // rotation (new `token`/`getToken`/`apiKey` props) reaches the next\n    // request without remounting the thread. The transport's `staleAuth`\n    // (true right after a refused credential) is forwarded as `force`.\n    headers: (ctx) => resolveStatewireAuthHeaders({ apiKey, token, getToken }, ctx),\n    isNewChat,\n    // Queued entries render in the SDK's queue panel, so only the steer lane\n    // projects into the message tail.\n    laneProjection: 'steer-only',\n    // Durable session: a reload resumes the lane and resends whatever the\n    // server has not marked durable. Scoped by host AND principal — a thread\n    // id is only meaningful against the backend that minted it, and a stored\n    // lane must never resend against another signed-in user. (Consumers\n    // server-render this SDK; the core's availability probe keeps those\n    // sessions process-local, as before the seam existed.)\n    session: {\n      kind: 'local-storage',\n      key: (id) => statewireSessionKey({ syncUrl, principal, threadId: id }),\n    },\n    snapshotCache,\n    // Windowed hello (see `ATHENA_SDK_MESSAGE_WINDOW`): the tail of the\n    // transcript instead of every message; the chat UI's history edge pages\n    // older ranges in and fetches cut tool outputs into `toolOutputs`.\n    messageWindow,\n    toolOutputs,\n    capabilities: { edit: true, reload: true, continue: true },\n    useClient: useSdkClient,\n    onStateChange: () => {\n      // First snapshot for this attach ends the attach span (time-to-history).\n      const endSpan = attachSpanRef.current;\n      if (endSpan) {\n        attachSpanRef.current = null;\n        endSpan('statewire.snapshot', { data: { thread_id: threadId } });\n      }\n    },\n    onConnectionChange: (connection) => {\n      athenaDiagnostics.gauge('statewire.connection', connection?.status ?? null);\n      if (connection?.status === 'stopped') {\n        athenaDiagnostics.emit('statewire.connection', {\n          level: 'warn',\n          data: {\n            status: connection.status,\n            reason: connection.reason,\n            message: connection.message,\n          },\n        });\n      }\n      onConnectionChange?.(connection);\n    },\n    onRawConnectionChange,\n    onRunningChange,\n    // The runConfig getter is pulled at command-send time through the core's\n    // per-render ref, so it reads the latest props — consumers commonly pass\n    // fresh array literals per render, which must not thrash the registration\n    // (no `key`: the provider registers once per client).\n    runConfig: {\n      get: () =>\n        buildStatewireRunConfig({\n          model,\n          agent,\n          channel,\n          tools,\n          frontendToolIds,\n          workbench,\n          knowledgeBase,\n          systemPrompt,\n          appId,\n          extraRunConfig,\n          clientTools: statewireClientToolWireEntries(clientTools),\n        }),\n    },\n    onError: (error) => {\n      if (!isStatewireChannelTeardown(error)) {\n        athenaDiagnostics.error(\n          'statewire.error',\n          error,\n          {\n            code: 'statewire_rejected',\n            message: 'The statewire host rejected a command',\n            hint: 'Inspect error.detail — agora rejections carry a structured {code, message}.',\n          },\n          { thread_id: threadId },\n        );\n      }\n      if (onError) {\n        onError(error);\n        return;\n      }\n      logUnhandledStatewireError('AthenaSDK', error);\n    },\n  });\n}\n"],"names":[],"mappings":"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"}