@ai-matrx/chat 0.4.2 → 0.4.7

package/dist/ui/markdown-stream/internal-handlers/AgentCallChildTrace.js

@@ -0,0 +1,128 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { useAppDispatch, useAppSelector } from "../../../store/hooks.js";
+import { selectAgentCallTrace } from "../../../agents/redux/execution-system/active-requests/active-requests.selectors.js";
+import {
+  selectConversationMessages,
+  selectMessagesInterleavedRuns
+} from "../../../agents/redux/execution-system/messages/messages.selectors.js";
+import { loadAgentCallChildConversation } from "../../../agents/redux/execution-system/thunks/load-agent-call-child.thunk.js";
+import {
+  childConversationIdFromResult,
+  persistedAgentCallTrace
+} from "../../../agents/redux/execution-system/utils/agent-call-trace.js";
+import { useConversationTitle } from "../../../agents/hooks/useConversationTitle.js";
+import { EntityRef } from "../../../host/ui-slots.js";
+import ReasoningVisualization from "@ai-matrx/rich-content/display/blocks/thinking-reasoning/ReasoningVisualization";
+import { isCollaborationAgentCall } from "../../../tool-call-visualization/renderers/agent-call/collab.js";
+import { InlineThinkingSlot } from "./InlineThinkingSlot.js";
+const NO_LIVE_TRACE = () => null;
+const EMPTY_MESSAGES = [];
+const EMPTY_RUNS = [];
+const NO_MESSAGES = () => EMPTY_MESSAGES;
+const NO_RUNS = () => EMPTY_RUNS;
+function AgentCallChildTrace({
+  entry,
+  conversationId,
+  requestId,
+  ToolCardComponent
+}) {
+  const dispatch = useAppDispatch();
+  const liveSelector = useMemo(
+    () => requestId ? selectAgentCallTrace(requestId, entry.callId) : NO_LIVE_TRACE,
+    [requestId, entry.callId]
+  );
+  const streamed = useAppSelector(liveSelector);
+  const childId = streamed?.childConversationId ?? childConversationIdFromResult(entry.result);
+  const settled = entry.status === "completed" || entry.status === "error";
+  const live = settled && childId ? null : streamed;
+  const persistedId = !live && childId ? childId : null;
+  const [failed, setFailed] = useState(false);
+  useEffect(() => {
+    if (!persistedId) return;
+    dispatch(loadAgentCallChildConversation({ childConversationId: persistedId })).unwrap().then(() => setFailed(false)).catch(() => setFailed(true));
+  }, [dispatch, persistedId]);
+  const messages = useAppSelector(
+    persistedId ? selectConversationMessages(persistedId) : NO_MESSAGES
+  );
+  const assistantIds = messages.filter((m) => m.role === "assistant").map((m) => m.id);
+  const idsKey = assistantIds.join(",");
+  const runsSelector = useMemo(
+    () => persistedId && idsKey ? selectMessagesInterleavedRuns(persistedId, idsKey.split(",")) : NO_RUNS,
+    [persistedId, idsKey]
+  );
+  const runs = useAppSelector(runsSelector);
+  const persisted = persistedAgentCallTrace(runs);
+  const title = useConversationTitle(childId);
+  const showDoor = !!childId && !isCollaborationAgentCall(entry);
+  const hasItems = live ? live.items.length > 0 : persisted.length > 0;
+  if (!hasItems && !showDoor && !failed) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "ml-3 mt-1 flex flex-col gap-1 border-l border-border pl-3",
+      "data-agent-call-trace": entry.callId,
+      children: [
+        live ? live.items.map(
+          (item) => item.kind === "thinking" ? /* @__PURE__ */ jsx(
+            InlineThinkingSlot,
+            {
+              requestId: requestId ?? "",
+              chunkStartIndex: item.chunkStartIndex,
+              chunkEndIndex: item.chunkEndIndex,
+              renderReasoning: (content, isStreaming) => /* @__PURE__ */ jsx(
+                ReasoningVisualization,
+                {
+                  reasoningText: content,
+                  isStreaming
+                }
+              )
+            },
+            `thinking-${item.chunkStartIndex}`
+          ) : /* @__PURE__ */ jsx(
+            ToolCardComponent,
+            {
+              callId: item.callId,
+              requestId,
+              conversationId
+            },
+            `tool-${item.callId}`
+          )
+        ) : persisted.map(
+          (item, i) => item.kind === "thinking" ? /* @__PURE__ */ jsx(
+            ReasoningVisualization,
+            {
+              reasoningText: item.content
+            },
+            `thinking-${i}`
+          ) : /* @__PURE__ */ jsx(
+            ToolCardComponent,
+            {
+              callId: item.segment.callId,
+              segment: item.segment,
+              conversationId
+            },
+            `tool-${item.segment.callId}`
+          )
+        ),
+        failed && /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: "Sub-agent steps unavailable" }),
+        showDoor && /* @__PURE__ */ jsx(
+          EntityRef,
+          {
+            token: "conversation",
+            id: childId,
+            name: title ?? "Sub-agent conversation",
+            openInNewTab: true,
+            showIcon: false,
+            labelClassName: "text-xs",
+            className: "self-start"
+          }
+        )
+      ]
+    }
+  );
+}
+export {
+  AgentCallChildTrace
+};

package/dist/ui/markdown-stream/internal-handlers/InlineAssistantError.d.ts

@@ -0,0 +1,3 @@
+export declare function InlineAssistantError({ requestId }: {
+    requestId: string;
+}): import("react").JSX.Element | null;

package/dist/ui/markdown-stream/internal-handlers/InlineAssistantError.js

@@ -0,0 +1,26 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useAppSelector } from "../../../store/hooks.js";
+import { selectRequestError } from "../../../agents/redux/execution-system/active-requests/active-requests.selectors.js";
+import { AssistantError } from "../../../agents/components/run/AssistantError.js";
+function InlineAssistantError({ requestId }) {
+  const streamError = useAppSelector(selectRequestError(requestId));
+  if (!streamError) return null;
+  const friendly = streamError.user_message ?? streamError.message ?? "The response failed.";
+  const technical = streamError.message;
+  const detail = technical && technical !== friendly ? technical : void 0;
+  const code = streamError.code ?? (streamError.details && typeof streamError.details === "object" && "status_code" in streamError.details ? streamError.details.status_code : void 0);
+  return /* @__PURE__ */ jsx(
+    AssistantError,
+    {
+      message: friendly,
+      detail,
+      errorType: streamError.error_type,
+      code,
+      details: streamError.details
+    }
+  );
+}
+export {
+  InlineAssistantError
+};

package/dist/ui/markdown-stream/internal-handlers/InlineThinkingSlot.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+export interface InlineThinkingSlotProps {
+    requestId: string;
+    chunkStartIndex: number;
+    /** Absent while the run is still open (tokens may still arrive). */
+    chunkEndIndex?: number;
+    /**
+     * Renders the reasoning text through the caller's block pipeline
+     * (EnhancedChatMarkdown's `renderBlock`) so live and persisted thinking
+     * share one renderer. `isStreaming` is true while the run is open.
+     */
+    renderReasoning: (content: string, isStreaming: boolean) => React.ReactNode;
+}
+export declare const InlineThinkingSlot: React.FC<InlineThinkingSlotProps>;

package/dist/ui/markdown-stream/internal-handlers/InlineThinkingSlot.js

@@ -0,0 +1,23 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { useAppSelector } from "../../../store/hooks.js";
+import { selectReasoningRunText } from "../../../agents/redux/execution-system/active-requests/active-requests.selectors.js";
+import { InlineStatusIndicator } from "@ai-matrx/rich-content/display/chat-markdown/internal-handlers/InlineStatusIndicator";
+const InlineThinkingSlot = ({
+  requestId,
+  chunkStartIndex,
+  chunkEndIndex,
+  renderReasoning
+}) => {
+  const text = useAppSelector(
+    selectReasoningRunText(requestId, chunkStartIndex, chunkEndIndex)
+  );
+  const isOpen = chunkEndIndex === void 0;
+  if (!text.trim()) {
+    return isOpen ? /* @__PURE__ */ jsx(InlineStatusIndicator, { label: "Reasoning\u2026" }) : null;
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: renderReasoning(text, isOpen) });
+};
+export {
+  InlineThinkingSlot
+};

package/dist/ui/markdown-stream/internal-handlers/ToolHandlers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * ToolHandlers — inline tool-call cards for the markdown stream.
+ *
+ * ONE card component (`ToolCard`) and ONE batch component (`ToolBatch`) for
+ * both sources: the live stream (`requestId` → `ToolLifecycleEntry` from
+ * Redux) and a committed/reloaded turn (a persisted content segment →
+ * `persistedToolEntry`). One element type under one key is what keeps a card
+ * the same instance when a turn swaps from stream to record.
+ *
+ * Both route through the canonical shell at
+ * `@/features/tool-call-visualization`.
+ */
+import React from "react";
+import { type ContentSegmentDbTool } from "../../../agents/redux/execution-system/active-requests/active-requests.selectors.js";
+export interface ToolCardProps {
+    callId: string;
+    /**
+     * Owning conversation id. Required so this card can self-gate on the
+     * instance-level `hideToolResults` flag — when true, this component
+     * renders nothing. Centralizing the show/hide check here means a single
+     * setting silences every tool call on the surface with no scattered
+     * conditionals.
+     */
+    conversationId: string;
+    /** Live source: the request whose lifecycle carries this call. */
+    requestId?: string;
+    /** Persisted source: the committed tool_call part joined to its row. */
+    segment?: ContentSegmentDbTool;
+}
+export declare const ToolCard: React.FC<ToolCardProps>;
+export interface ToolBatchProps {
+    conversationId: string;
+    /** Live source. */
+    requestId?: string;
+    callIds?: string[];
+    /** Persisted source. */
+    segments?: ContentSegmentDbTool[];
+    browserRunOrder?: number;
+    browserBreakBefore?: boolean;
+    browserBreakAfter?: boolean;
+}
+export declare const ToolBatch: React.FC<ToolBatchProps>;

package/dist/ui/markdown-stream/internal-handlers/ToolHandlers.js

@@ -0,0 +1,109 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useAppSelector } from "../../../store/hooks.js";
+import { selectHideToolResults } from "../../../agents/redux/execution-system/instance-ui-state/instance-ui-state.selectors.js";
+import {
+  selectToolLifecycle,
+  selectToolLifecycleMap
+} from "../../../agents/redux/execution-system/active-requests/active-requests.selectors.js";
+import { ToolCallVisualization } from "../../../tool-call-visualization/components/ToolCallVisualization.js";
+import { ToolCallBatch } from "../../../tool-call-visualization/components/ToolCallBatch.js";
+import { persistedToolEntry } from "../../../tool-call-visualization/utils/cxToolCallToLifecycleEntry.js";
+import { AgentCallChildTrace } from "./AgentCallChildTrace.js";
+const _selectNoLifecycle = () => void 0;
+const ToolCard = ({
+  callId,
+  conversationId,
+  requestId,
+  segment
+}) => {
+  const hidden = useAppSelector(selectHideToolResults(conversationId));
+  const lifecycle = useAppSelector(
+    !segment && requestId ? selectToolLifecycle(requestId, callId) : _selectNoLifecycle
+  );
+  const entry = segment ? persistedToolEntry(segment) : lifecycle;
+  if (hidden) return null;
+  if (!entry) return null;
+  const card = /* @__PURE__ */ jsx(
+    ToolCallVisualization,
+    {
+      entries: [entry],
+      requestId: segment ? void 0 : requestId,
+      conversationId,
+      hasContent: true,
+      isPersisted: !!segment
+    }
+  );
+  if (entry.toolName !== "agent_call") return card;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    card,
+    /* @__PURE__ */ jsx(
+      AgentCallChildTrace,
+      {
+        entry,
+        conversationId,
+        requestId: segment ? void 0 : requestId,
+        ToolCardComponent: ToolCard
+      }
+    )
+  ] });
+};
+const _selectNoLifecycleMap = () => void 0;
+const ToolBatch = ({
+  conversationId,
+  requestId,
+  callIds,
+  segments,
+  browserRunOrder,
+  browserBreakBefore,
+  browserBreakAfter
+}) => {
+  const hidden = useAppSelector(selectHideToolResults(conversationId));
+  const lifecycleMap = useAppSelector(
+    !segments && requestId ? selectToolLifecycleMap(requestId) : _selectNoLifecycleMap
+  );
+  const ids = segments ? segments.map((s) => s.callId) : callIds ?? [];
+  const entries = [];
+  if (segments) {
+    for (const s of segments) entries.push(persistedToolEntry(s));
+  } else if (lifecycleMap) {
+    for (const id of ids) {
+      const e = lifecycleMap[id];
+      if (e) entries.push(e);
+    }
+  }
+  if (hidden) return null;
+  if (entries.length === 0) return null;
+  return /* @__PURE__ */ jsx(
+    ToolCallBatch,
+    {
+      entries,
+      conversationId,
+      isPersisted: !!segments,
+      browserRunOrder,
+      browserBreakBefore,
+      browserBreakAfter,
+      children: segments ? segments.map((segment) => /* @__PURE__ */ jsx(
+        ToolCard,
+        {
+          callId: segment.callId,
+          segment,
+          conversationId
+        },
+        segment.callId
+      )) : ids.map((callId) => /* @__PURE__ */ jsx(
+        ToolCard,
+        {
+          callId,
+          requestId,
+          conversationId
+        },
+        callId
+      ))
+    }
+  );
+};
+export {
+  ToolBatch,
+  ToolCard
+};

package/dist/ui/markdown-stream/useBoundAgentOutputSchema.d.ts

@@ -0,0 +1,2 @@
+/** Reads a bound contract through Redux, then the canonical cached by-id read. */
+export declare function useBoundAgentOutputSchema(conversationId?: string): unknown | null;

package/dist/ui/markdown-stream/useBoundAgentOutputSchema.js

@@ -0,0 +1,33 @@
+"use client";
+import { useEffect, useState } from "react";
+import { useAppSelector } from "../../store/hooks.js";
+import { selectAgentById } from "../../agents/redux/agent-definition/selectors.js";
+import { hasField } from "@ai-matrx/agents/field-flags";
+import { selectAgentIdFromInstance } from "../../agents/redux/execution-system/conversations/conversations.selectors.js";
+import { fetchAgentOutputSchemas } from "../../mandates/output-contract.js";
+function useBoundAgentOutputSchema(conversationId) {
+  const agentId = useAppSelector(
+    conversationId ? selectAgentIdFromInstance(conversationId) : () => void 0
+  );
+  const agent = useAppSelector(
+    agentId ? (state) => selectAgentById(state, agentId) : () => void 0
+  );
+  const loadedSchema = agent && hasField(agent._loadedFields, "outputSchema") ? agent.outputSchema : void 0;
+  const [fetched, setFetched] = useState(null);
+  useEffect(() => {
+    if (!agentId || loadedSchema !== void 0) return;
+    let active = true;
+    void fetchAgentOutputSchemas([agentId]).then((schemas) => {
+      if (active) setFetched({ agentId, schema: schemas[agentId] ?? null });
+    });
+    return () => {
+      active = false;
+    };
+  }, [agentId, loadedSchema]);
+  if (loadedSchema !== void 0) return loadedSchema;
+  if (fetched && fetched.agentId === agentId) return fetched.schema;
+  return null;
+}
+export {
+  useBoundAgentOutputSchema
+};

package/dist/window-panels/windows/agents/AgentAssistantMarkdownDebugWindow.js

@@ -2,7 +2,6 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useMemo, useState, useEffect } from "react";
 import { WindowPanel } from "../../../host/ui-slots.js";
-import { RichContent } from "../../../host/ui-slots.js";
 import { Button } from "@ai-matrx/design-system/controls";
 import {
   Select,
@@ -18,6 +17,7 @@ import {
 } from "../../../agents/redux/agent-assistant-markdown-draft.slice.js";
 import { NonEditableContextMenu } from "../../../host/ui-slots.js";
 import { CHAT_WINDOWS } from "../../../host/windows.js";
+import { RichContent } from "@ai-matrx/rich-content/levels/RichContent";
 function AgentAssistantMarkdownDebugWindow({
   isOpen,
   onClose

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-matrx/chat",
-  "version": "0.4.2",
+  "version": "0.4.7",
   "description": "THE one AI Matrx person-to-agent chat system: the full chat (running agents, conversations, tool calls, streaming, context, surfaces, voice) as per-module subpaths @ai-matrx/chat/<domain>/<module> over a host contract (/host, /host/react) whose only required value is a db; plus the kernel compatibility entries (., /external-store, /matrx, /react, /tools, styles.css, tokens.css) until P28.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -226,14 +226,14 @@
     "server-only": "^0.0.1",
     "uuid": "^14.0.2",
     "zod": "^4.6.5",
-    "@ai-matrx/agents": "latest",
     "@ai-matrx/alchemy": "latest",
     "@ai-matrx/associations": "latest",
     "@ai-matrx/browser-audio": "latest",
     "@ai-matrx/canvas": "latest",
+    "@ai-matrx/agents": "latest",
     "@ai-matrx/content-ir": "latest",
-    "@ai-matrx/data": "latest",
     "@ai-matrx/content-ir-react": "latest",
+    "@ai-matrx/data": "latest",
     "@ai-matrx/design-system": "latest",
     "@ai-matrx/diff": "latest",
     "@ai-matrx/icons": "latest",
@@ -244,6 +244,7 @@
     "@ai-matrx/records": "latest",
     "@ai-matrx/records-ui": "latest",
     "@ai-matrx/rich-content": "latest",
+    "@ai-matrx/rich-editor": "latest",
     "@ai-matrx/tap-target": "latest"
   },
   "devDependencies": {
@@ -303,11 +304,12 @@
     }
   },
   "scripts": {
-    "build": "pnpm clean && tsup && node ./scripts/copy-css.mjs && node ./scripts/tsc-own.mjs -p tsconfig.build.json && node ./scripts/finish-build.mjs",
+    "build": "pnpm --filter @ai-matrx/rich-editor build && pnpm clean && tsup && node ./scripts/copy-css.mjs && node ./scripts/tsc-own.mjs -p tsconfig.build.json && node ./scripts/finish-build.mjs",
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
-    "check:package": "pnpm build && node ../scripts/check-exports-agreement.mjs && pnpm check:canonical-pickers && publint && pnpm verify:tarball && pnpm verify:modules-tarball && pnpm check:front-door:self-test && pnpm check:front-door:canary && pnpm check:host-boundary && pnpm check:no-builder-tier && pnpm check:one-holder && pnpm check:host-doors",
+    "check:package": "pnpm build && node ../scripts/check-exports-agreement.mjs && pnpm check:canonical-pickers && publint && pnpm verify:tarball && pnpm verify:modules-tarball && pnpm check:front-door:self-test && pnpm check:front-door:canary && pnpm check:host-boundary && pnpm check:no-builder-tier && pnpm check:one-holder && pnpm check:host-doors && pnpm check:no-package-slots",
     "check:host-boundary": "node ./scripts/check-host-boundary.mjs && node ./scripts/check-host-boundary.mjs --self-test",
     "check:host-doors": "node ./scripts/check-host-source-doors.mjs && node ./scripts/check-host-source-doors.mjs --self-test",
+    "check:no-package-slots": "node ./scripts/check-no-package-slots.mjs && node ./scripts/check-no-package-slots.mjs --self-test",
     "check:one-holder": "node ./scripts/check-chat-one-holder.mjs && node ./scripts/check-chat-one-holder.mjs --self-test",
     "check:no-builder-tier": "node ./scripts/check-chat-has-no-builder-tier.mjs && node ./scripts/check-chat-has-no-builder-tier.mjs --self-test",
     "typecheck": "node ./node_modules/typescript/bin/tsc -p tsconfig.json --noEmit && node ./scripts/tsc-own.mjs -p tsconfig.modules.json",