@distri/core 0.3.3 → 0.3.4

package/dist/index.js

@@ -55,8 +55,14 @@ module.exports = __toCommonJS(index_exports);
 function isArrayParts(result) {
   return Array.isArray(result) && result[0].part_type;
 }
-function createSuccessfulToolResult(toolCallId, toolName, result) {
-  const parts = isArrayParts(result) ? result : [{
+function createSuccessfulToolResult(toolCallId, toolName, result, explicitPartsMetadata) {
+  console.log("[createSuccessfulToolResult] toolName:", toolName);
+  console.log("[createSuccessfulToolResult] isArrayParts:", isArrayParts(result));
+  console.log("[createSuccessfulToolResult] result type:", typeof result, Array.isArray(result) ? `array[${result.length}]` : "");
+  if (isArrayParts(result)) {
+    console.log("[createSuccessfulToolResult] parts:", result.map((p) => ({ part_type: p.part_type, hasMetadata: !!p.__metadata })));
+  }
+  const rawParts = isArrayParts(result) ? result : [{
     part_type: "data",
     data: {
       result,
@@ -64,10 +70,22 @@ function createSuccessfulToolResult(toolCallId, toolName, result) {
       error: void 0
     }
   }];
+  const parts_metadata = { ...explicitPartsMetadata };
+  const parts = rawParts.map((part, index) => {
+    if ("__metadata" in part && part.__metadata) {
+      parts_metadata[index] = { ...parts_metadata[index], ...part.__metadata };
+    }
+    if (part.part_type === "image" && !parts_metadata[index]) {
+      parts_metadata[index] = { save: false };
+    }
+    const { __metadata, ...cleanPart } = part;
+    return cleanPart;
+  });
   return {
     tool_call_id: toolCallId,
     tool_name: toolName,
-    parts
+    parts,
+    parts_metadata: Object.keys(parts_metadata).length > 0 ? parts_metadata : void 0
   };
 }
 function createFailedToolResult(toolCallId, toolName, error, result) {
@@ -543,11 +561,22 @@ var A2AClient = class {
 // src/encoder.ts
 function convertA2AMessageToDistri(a2aMessage) {
   const role = a2aMessage.role === "agent" ? "assistant" : "user";
+  let agent_id;
+  let agent_name;
+  if (a2aMessage.metadata) {
+    const metadata = a2aMessage.metadata;
+    if (metadata.agent) {
+      agent_id = metadata.agent.agent_id;
+      agent_name = metadata.agent.agent_name;
+    }
+  }
   return {
     id: a2aMessage.messageId,
     role,
     parts: a2aMessage.parts.map(convertA2APartToDistri),
-    created_at: a2aMessage.createdAt
+    created_at: a2aMessage.createdAt,
+    agent_id,
+    agent_name
   };
 }
 function convertA2AStatusUpdateToDistri(statusUpdate) {
@@ -570,8 +599,8 @@ function convertA2AStatusUpdateToDistri(statusUpdate) {
       const runErrorResult = {
         type: "run_error",
         data: {
-          message: statusUpdate.error,
-          code: statusUpdate.code
+          message: metadata.message || statusUpdate.status?.message || "Unknown error",
+          code: metadata.code
         }
       };
       return runErrorResult;
@@ -741,6 +770,19 @@ function convertA2AStatusUpdateToDistri(statusUpdate) {
       };
       return browserSessionStarted;
     }
+    case "todos_updated": {
+      const todos = parseTodosFromFormatted(metadata.formatted_todos || "");
+      const todosUpdated = {
+        type: "todos_updated",
+        data: {
+          formatted_todos: metadata.formatted_todos || "",
+          action: metadata.action || "write_todos",
+          todo_count: metadata.todo_count || 0,
+          todos
+        }
+      };
+      return todosUpdated;
+    }
     default: {
       console.warn(`Unhandled status update metadata type: ${metadata.type}`, metadata);
       const defaultResult = {
@@ -792,7 +834,7 @@ function convertA2APartToDistri(a2aPart) {
         const fileUrl = { type: "url", mime_type: a2aPart.file.mimeType || "application/octet-stream", url: a2aPart.file.uri || "" };
         return { part_type: "image", data: fileUrl };
       } else {
-        const fileBytes = { type: "bytes", mime_type: a2aPart.file.mimeType || "application/octet-stream", data: a2aPart.file.bytes || "" };
+        const fileBytes = { type: "bytes", mime_type: a2aPart.file.mimeType || "application/octet-stream", bytes: a2aPart.file.bytes || "" };
         return { part_type: "image", data: fileBytes };
       }
     case "data":
@@ -831,7 +873,8 @@ function convertDistriMessageToA2A(distriMessage, context) {
     parts: distriMessage.parts.map(convertDistriPartToA2A),
     kind: "message",
     contextId: context.thread_id,
-    taskId: context.task_id || context.run_id || void 0
+    taskId: context.task_id || context.run_id || void 0,
+    metadata: distriMessage.metadata
   };
 }
 function convertDistriPartToA2A(distriPart) {
@@ -845,7 +888,7 @@ function convertDistriPartToA2A(distriPart) {
         const fileUri = { mimeType: distriPart.data.mime_type, uri: distriPart.data.url };
         result = { kind: "file", file: fileUri };
       } else {
-        const fileBytes = { mimeType: distriPart.data.mime_type, bytes: distriPart.data.data };
+        const fileBytes = { mimeType: distriPart.data.mime_type, bytes: distriPart.data.bytes };
         result = { kind: "file", file: fileBytes };
       }
       break;
@@ -910,6 +953,32 @@ function extractToolCallsFromDistriMessage(message) {
 function extractToolResultsFromDistriMessage(message) {
   return message.parts.filter((part) => part.part_type === "tool_result").map((part) => part.data);
 }
+function parseTodosFromFormatted(formatted) {
+  if (!formatted || formatted === "\u25A1 No todos") {
+    return [];
+  }
+  const lines = formatted.split("\n").filter((line) => line.trim());
+  return lines.map((line, index) => {
+    const trimmed = line.trim();
+    let status = "open";
+    let content = trimmed;
+    if (trimmed.startsWith("\u25A0")) {
+      status = "done";
+      content = trimmed.slice(1).trim();
+    } else if (trimmed.startsWith("\u25D0")) {
+      status = "in_progress";
+      content = trimmed.slice(1).trim();
+    } else if (trimmed.startsWith("\u25A1")) {
+      status = "open";
+      content = trimmed.slice(1).trim();
+    }
+    return {
+      id: `todo_${index}`,
+      content,
+      status
+    };
+  });
+}
 
 // src/distri-client.ts
 var _DistriClient = class _DistriClient {
@@ -1456,7 +1525,12 @@ var _DistriClient = class _DistriClient {
       }
     }
     if (error instanceof Error) {
-      return error.message;
+      const msg = error.message;
+      const sseMatch = msg.match(/SSE event contained an error:\s*(.+?)\s*\(Code:/);
+      if (sseMatch) return sseMatch[1];
+      const rpcMatch = msg.match(/RPC Error:\s*(.+?)\s*\(Code:/);
+      if (rpcMatch) return rpcMatch[1];
+      return msg;
     }
     return String(error);
   }
@@ -1520,11 +1594,19 @@ var _DistriClient = class _DistriClient {
     }
   }
   /**
-   * Get agents sorted by thread count (most active first)
+   * Get agents sorted by thread count (most active first).
+   * Includes all registered agents, even those with 0 threads.
+   * Optionally filter by name with search parameter.
    */
-  async getAgentsByUsage() {
+  async getAgentsByUsage(options) {
     try {
-      const response = await this.fetch("/threads/agents");
+      const params = new URLSearchParams();
+      if (options?.search) {
+        params.set("search", options.search);
+      }
+      const query = params.toString();
+      const url = query ? `/threads/agents?${query}` : "/threads/agents";
+      const response = await this.fetch(url);
       if (!response.ok) {
         throw new ApiError(`Failed to fetch agents by usage: ${response.statusText}`, response.status);
       }
@@ -1589,6 +1671,138 @@ var _DistriClient = class _DistriClient {
     const messages = await this.getThreadMessages(threadId);
     return messages.map(convertA2AMessageToDistri);
   }
+  // ========== Message Read Status Methods ==========
+  /**
+   * Mark a message as read
+   */
+  async markMessageRead(threadId, messageId) {
+    try {
+      const response = await this.fetch(
+        `/threads/${encodeURIComponent(threadId)}/messages/${encodeURIComponent(messageId)}/read`,
+        { method: "POST" }
+      );
+      if (!response.ok) {
+        throw new ApiError(`Failed to mark message as read: ${response.statusText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof ApiError) throw error;
+      throw new DistriError(`Failed to mark message ${messageId} as read`, "MARK_READ_ERROR", error);
+    }
+  }
+  /**
+   * Get read status for a specific message
+   */
+  async getMessageReadStatus(threadId, messageId) {
+    try {
+      const response = await this.fetch(
+        `/threads/${encodeURIComponent(threadId)}/messages/${encodeURIComponent(messageId)}/read`
+      );
+      if (response.status === 404) {
+        return null;
+      }
+      if (!response.ok) {
+        throw new ApiError(`Failed to get message read status: ${response.statusText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof ApiError) throw error;
+      throw new DistriError(`Failed to get read status for message ${messageId}`, "FETCH_ERROR", error);
+    }
+  }
+  /**
+   * Get read status for all messages in a thread
+   */
+  async getThreadReadStatus(threadId) {
+    try {
+      const response = await this.fetch(
+        `/threads/${encodeURIComponent(threadId)}/read-status`
+      );
+      if (!response.ok) {
+        throw new ApiError(`Failed to get thread read status: ${response.statusText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof ApiError) throw error;
+      throw new DistriError(`Failed to get read status for thread ${threadId}`, "FETCH_ERROR", error);
+    }
+  }
+  // ========== Message Voting Methods ==========
+  /**
+   * Vote on a message (upvote or downvote)
+   * Downvotes require a comment explaining the issue
+   */
+  async voteMessage(threadId, messageId, request) {
+    try {
+      const response = await this.fetch(
+        `/threads/${encodeURIComponent(threadId)}/messages/${encodeURIComponent(messageId)}/vote`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(request)
+        }
+      );
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new ApiError(errorData.error || `Failed to vote on message: ${response.statusText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof ApiError) throw error;
+      throw new DistriError(`Failed to vote on message ${messageId}`, "VOTE_ERROR", error);
+    }
+  }
+  /**
+   * Remove vote from a message
+   */
+  async removeVote(threadId, messageId) {
+    try {
+      const response = await this.fetch(
+        `/threads/${encodeURIComponent(threadId)}/messages/${encodeURIComponent(messageId)}/vote`,
+        { method: "DELETE" }
+      );
+      if (!response.ok && response.status !== 204) {
+        throw new ApiError(`Failed to remove vote: ${response.statusText}`, response.status);
+      }
+    } catch (error) {
+      if (error instanceof ApiError) throw error;
+      throw new DistriError(`Failed to remove vote from message ${messageId}`, "VOTE_ERROR", error);
+    }
+  }
+  /**
+   * Get vote summary for a message (counts + current user's vote)
+   */
+  async getMessageVoteSummary(threadId, messageId) {
+    try {
+      const response = await this.fetch(
+        `/threads/${encodeURIComponent(threadId)}/messages/${encodeURIComponent(messageId)}/vote`
+      );
+      if (!response.ok) {
+        throw new ApiError(`Failed to get vote summary: ${response.statusText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof ApiError) throw error;
+      throw new DistriError(`Failed to get vote summary for message ${messageId}`, "FETCH_ERROR", error);
+    }
+  }
+  /**
+   * Get all votes for a message (admin/analytics use)
+   */
+  async getMessageVotes(threadId, messageId) {
+    try {
+      const response = await this.fetch(
+        `/threads/${encodeURIComponent(threadId)}/messages/${encodeURIComponent(messageId)}/votes`
+      );
+      if (!response.ok) {
+        throw new ApiError(`Failed to get message votes: ${response.statusText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof ApiError) throw error;
+      throw new DistriError(`Failed to get votes for message ${messageId}`, "FETCH_ERROR", error);
+    }
+  }
   /**
    * Send a DistriMessage to a thread
    */
@@ -1614,7 +1828,12 @@ var _DistriClient = class _DistriClient {
         },
         body: JSON.stringify({
           tool_call_id: result.tool_call_id,
-          tool_response: result
+          tool_response: {
+            tool_call_id: result.tool_call_id,
+            tool_name: result.tool_name,
+            parts: result.parts,
+            parts_metadata: result.parts_metadata
+          }
         })
       });
       if (!response.ok) {
@@ -1878,9 +2097,17 @@ var _DistriClient = class _DistriClient {
     };
   }
   /**
-   * Helper method to create message send parameters
-   */
-  static initMessageParams(message, configuration, metadata) {
+   * Helper method to create message send parameters.
+   *
+   * Pass `dynamicMetadata` to inject `dynamic_sections` and/or `dynamic_values`
+   * into the metadata so the server can apply them to prompt templates.
+   */
+  static initMessageParams(message, configuration, metadata, dynamicMetadata) {
+    const mergedMetadata = {
+      ...metadata,
+      ...dynamicMetadata?.dynamic_sections ? { dynamic_sections: dynamicMetadata.dynamic_sections } : {},
+      ...dynamicMetadata?.dynamic_values ? { dynamic_values: dynamicMetadata.dynamic_values } : {}
+    };
     return {
       message,
       configuration: {
@@ -1889,18 +2116,26 @@ var _DistriClient = class _DistriClient {
         // Default to non-blocking for streaming
         ...configuration
       },
-      metadata
+      metadata: Object.keys(mergedMetadata).length > 0 ? mergedMetadata : metadata
     };
   }
   /**
-   * Create MessageSendParams from a DistriMessage using InvokeContext
+   * Create MessageSendParams from a DistriMessage using InvokeContext.
+   *
+   * Pass `dynamicMetadata` to inject `dynamic_sections` and/or `dynamic_values`
+   * into the metadata so the server can apply them to prompt templates.
    */
-  static initDistriMessageParams(message, context) {
+  static initDistriMessageParams(message, context, dynamicMetadata) {
     const a2aMessage = convertDistriMessageToA2A(message, context);
     const contextMetadata = context.getMetadata?.() || {};
+    const mergedMetadata = {
+      ...contextMetadata,
+      ...dynamicMetadata?.dynamic_sections ? { dynamic_sections: dynamicMetadata.dynamic_sections } : {},
+      ...dynamicMetadata?.dynamic_values ? { dynamic_values: dynamicMetadata.dynamic_values } : {}
+    };
     return {
       message: a2aMessage,
-      metadata: contextMetadata
+      metadata: Object.keys(mergedMetadata).length > 0 ? mergedMetadata : contextMetadata
     };
   }
 };
@@ -2006,28 +2241,40 @@ var Agent = class _Agent {
     const enhancedParams = this.enhanceParamsWithTools(params, tools);
     const a2aStream = this.client.sendMessageStream(this.agentDefinition.id, enhancedParams);
     const self = this;
-    return async function* () {
-      for await (const event of a2aStream) {
-        const converted = decodeA2AStreamEvent(event);
-        if (converted && converted.type === "inline_hook_requested") {
-          const hookReq = converted.data;
-          const handler = self.hookHandlers.get(hookReq.hook) || self.defaultHookHandler;
-          if (handler) {
-            try {
-              const mutation = await handler(hookReq);
-              await self.client.completeInlineHook(hookReq.hook_id, mutation);
-            } catch (err) {
+    return (async function* () {
+      try {
+        for await (const event of a2aStream) {
+          const converted = decodeA2AStreamEvent(event);
+          if (converted && converted.type === "inline_hook_requested") {
+            const hookReq = converted.data;
+            const handler = self.hookHandlers.get(hookReq.hook) || self.defaultHookHandler;
+            if (handler) {
+              try {
+                const mutation = await handler(hookReq);
+                await self.client.completeInlineHook(hookReq.hook_id, mutation);
+              } catch (err) {
+                await self.client.completeInlineHook(hookReq.hook_id, { dynamic_values: {} });
+              }
+            } else {
               await self.client.completeInlineHook(hookReq.hook_id, { dynamic_values: {} });
             }
-          } else {
-            await self.client.completeInlineHook(hookReq.hook_id, { dynamic_values: {} });
+            yield converted;
+          } else if (converted) {
+            yield converted;
           }
-          yield converted;
-        } else if (converted) {
-          yield converted;
         }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const runError = {
+          type: "run_error",
+          data: {
+            message,
+            code: "STREAM_ERROR"
+          }
+        };
+        yield runError;
       }
-    }();
+    })();
   }
   /**
    * Validate that required external tools are registered before invoking.
@@ -2055,12 +2302,16 @@ var Agent = class _Agent {
     };
   }
   /**
-   * Enhance message params with tool definitions
+   * Enhance message params with tool definitions and dynamic metadata.
+   *
+   * When `dynamic_sections` or `dynamic_values` are present in `params.metadata`,
+   * they are forwarded so the server injects them into the prompt template.
    */
   enhanceParamsWithTools(params, tools) {
     this.assertExternalTools(tools);
+    const existingMeta = params.metadata ?? {};
     const metadata = {
-      ...params.metadata,
+      ...existingMeta,
       external_tools: tools?.map((tool) => ({
         name: tool.name,
         description: tool.description,