@axiom-lattice/client-sdk 4.4.2 → 4.5.0

package/dist/index.mjs

@@ -2175,6 +2175,36 @@ var AbstractClient = class {
         return response.data.records;
       }
     };
+    /**
+     * MCP Apps namespace for resolving UI resources and proxying allow-listed
+     * JSON-RPC calls to the owning MCP server.
+     */
+    this.mcpApps = {
+      /**
+       * Resolve a UI resource for an MCP App ref.
+       * @param ref - Parsed UI ref from the `mcp_app` content fence.
+       * @returns The resolved resource plus its ready-to-use CSP policy string.
+       */
+      getResource: async (ref) => {
+        return await this.makeRequest(
+          "/api/mcp-apps/resource",
+          { method: "POST", body: { ref } }
+        );
+      },
+      /**
+       * Proxy an allow-listed JSON-RPC method for an MCP App ref.
+       * @param ref - Parsed UI ref from the `mcp_app` content fence.
+       * @param method - JSON-RPC method (`tools/call`, `tools/list`, `resources/read`).
+       * @param params - JSON-RPC params forwarded to the backend.
+       * @returns The raw backend result.
+       */
+      rpc: async (ref, method, params) => {
+        return await this.makeRequest("/api/mcp-apps/rpc", {
+          method: "POST",
+          body: { ref, method, params }
+        });
+      }
+    };
     /**
      * @deprecated Use {@link open} / `/api/keys`; kept as a compatibility alias.
      */
@@ -5036,6 +5066,109 @@ var WorkspaceClient = class {
 
 // src/ChunkMessageMerger.ts
 import { parse } from "best-effort-json-parser";
+
+// src/toolResultNormalizer.ts
+var isObj = (v) => typeof v === "object" && v !== null;
+var TEXT_BLOCK_TYPES = /* @__PURE__ */ new Set(["text"]);
+var ARTIFACT_SENTINEL_TYPES = /* @__PURE__ */ new Set(["mcp_structured_content", "mcp_meta"]);
+function asBlocks(value) {
+  if (Array.isArray(value))
+    return value;
+  if (value === void 0 || value === null)
+    return [];
+  return [value];
+}
+function looksLikeResource(block) {
+  return typeof block.uri === "string" && ("mimeType" in block || "blob" in block || "text" in block);
+}
+function textOf(block, allowUntyped) {
+  if (typeof block === "string")
+    return block;
+  if (!isObj(block) || typeof block.text !== "string")
+    return null;
+  if (block.type === "text")
+    return block.text;
+  if (allowUntyped && block.type === void 0 && !looksLikeResource(block))
+    return block.text;
+  return null;
+}
+function joinText(blocks, allowUntyped) {
+  return blocks.map((block) => textOf(block, allowUntyped)).filter((t) => typeof t === "string" && t.length > 0).join("\n\n");
+}
+function structuredFromContent(content) {
+  for (const block of asBlocks(content)) {
+    if (isObj(block) && block.structuredContent !== void 0) {
+      return block.structuredContent;
+    }
+  }
+  return void 0;
+}
+function structuredFromArtifact(artifact) {
+  for (const item of asBlocks(artifact)) {
+    if (isObj(item) && item.type === "mcp_structured_content" && "data" in item) {
+      return item.data;
+    }
+  }
+  return void 0;
+}
+function metaFromContent(content) {
+  for (const block of asBlocks(content)) {
+    if (isObj(block) && isObj(block.meta))
+      return block.meta;
+  }
+  return void 0;
+}
+function metaFromArtifact(artifact) {
+  for (const item of asBlocks(artifact)) {
+    if (isObj(item) && item.type === "mcp_meta" && isObj(item.data))
+      return item.data;
+  }
+  return void 0;
+}
+function isNonTextBlock(block) {
+  return isObj(block) && typeof block.type === "string" && !TEXT_BLOCK_TYPES.has(block.type);
+}
+function toUiBlock(block) {
+  if (isNonTextBlock(block)) {
+    if (block.type === "resource" && !("resource" in block) && typeof block.uri === "string") {
+      return { type: "resource", resource: block };
+    }
+    return block;
+  }
+  if (isObj(block) && block.type === void 0 && looksLikeResource(block)) {
+    return { type: "resource", resource: block };
+  }
+  return null;
+}
+function normalizeToolResult(message) {
+  const contentBlocks = asBlocks(message.content).map(toUiBlock).filter(
+    (b) => b !== null && !ARTIFACT_SENTINEL_TYPES.has(b.type)
+  );
+  let structuredContent = structuredFromContent(message.content);
+  if (structuredContent === void 0) {
+    structuredContent = structuredFromArtifact(message.artifact);
+  }
+  let meta = metaFromContent(message.content);
+  if (meta === void 0)
+    meta = metaFromArtifact(message.artifact);
+  const artifactBlocks = asBlocks(message.artifact).map(toUiBlock).filter(
+    (b) => b !== null && !ARTIFACT_SENTINEL_TYPES.has(b.type)
+  );
+  const allBlocks = [...contentBlocks, ...artifactBlocks];
+  let text = joinText(asBlocks(message.content), true);
+  if (text.length === 0)
+    text = joinText(asBlocks(message.artifact), false);
+  const ui = {};
+  if (structuredContent !== void 0)
+    ui.structuredContent = structuredContent;
+  if (meta !== void 0)
+    ui.meta = meta;
+  if (allBlocks.length > 0)
+    ui.contentBlocks = allBlocks;
+  return Object.keys(ui).length > 0 ? { text, ui } : { text };
+}
+
+// src/ChunkMessageMerger.ts
 function createSimpleMessageMerger() {
   let messages = [];
   const messageMap = /* @__PURE__ */ new Map();
@@ -5131,14 +5264,9 @@ function createSimpleMessageMerger() {
       return;
     const role = normalizeRole(chunk.type);
     let message = ensureMessage(chunk.data.id, role);
-    const isInArray = message.role !== "tool";
-    if (chunk.data.content) {
+    if (chunk.data.content && message.role !== "tool") {
       const newContent = (message.content || "") + chunk.data.content;
-      if (isInArray) {
-        message = replaceMessage(chunk.data.id, { content: newContent }) || message;
-      } else {
-        message.content = newContent;
-      }
+      message = replaceMessage(chunk.data.id, { content: newContent }) || message;
     }
     if (message.role === "ai" && chunk.data.tool_calls && chunk.data.tool_calls.length > 0) {
       for (const toolCall of chunk.data.tool_calls) {
@@ -5179,10 +5307,20 @@ function createSimpleMessageMerger() {
         return;
       const messageIndex = messageMap.get(messageId);
       if (messageIndex !== void 0) {
+        const { text, ui } = normalizeToolResult({
+          content: chunk.data.content,
+          artifact: chunk.data.artifact
+        });
         const aiMessage = messages[messageIndex];
         const updatedToolCalls = aiMessage.tool_calls?.map((tc) => {
           if (tc.id === chunk.data.tool_call_id) {
-            return { ...tc, response: chunk.data.content, status: "success", original_tool_message_id };
+            return {
+              ...tc,
+              response: text,
+              status: "success",
+              original_tool_message_id,
+              ...ui ? { ui } : {}
+            };
           }
           return tc;
         });
@@ -5246,6 +5384,7 @@ export {
   WorkspaceClient,
   WorkspaceMembersClient,
   WorkspaceRoomsClient,
-  createSimpleMessageMerger
+  createSimpleMessageMerger,
+  normalizeToolResult
 };
 //# sourceMappingURL=index.mjs.map