@distri/core 0.2.4 → 0.2.7

package/dist/index.js

@@ -26,22 +26,25 @@ __export(index_exports, {
   Agent: () => Agent,
   ApiError: () => ApiError,
   ConnectionError: () => ConnectionError,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
   DistriClient: () => DistriClient,
   DistriError: () => DistriError,
-  convertA2AArtifactToDistri: () => convertA2AArtifactToDistri,
+  ExternalToolValidationError: () => ExternalToolValidationError,
   convertA2AMessageToDistri: () => convertA2AMessageToDistri,
   convertA2APartToDistri: () => convertA2APartToDistri,
   convertA2AStatusUpdateToDistri: () => convertA2AStatusUpdateToDistri,
   convertDistriMessageToA2A: () => convertDistriMessageToA2A,
   convertDistriPartToA2A: () => convertDistriPartToA2A,
+  createFailedToolResult: () => createFailedToolResult,
+  createSuccessfulToolResult: () => createSuccessfulToolResult,
   decodeA2AStreamEvent: () => decodeA2AStreamEvent,
   extractTextFromDistriMessage: () => extractTextFromDistriMessage,
   extractToolCallsFromDistriMessage: () => extractToolCallsFromDistriMessage,
+  extractToolResultData: () => extractToolResultData,
   extractToolResultsFromDistriMessage: () => extractToolResultsFromDistriMessage,
-  isDistriArtifact: () => isDistriArtifact,
+  isArrayParts: () => isArrayParts,
   isDistriEvent: () => isDistriEvent,
   isDistriMessage: () => isDistriMessage,
-  isDistriPlan: () => isDistriPlan,
   processA2AMessagesData: () => processA2AMessagesData,
   processA2AStreamData: () => processA2AStreamData,
   uuidv4: () => uuidv4
@@ -49,6 +52,90 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/types.ts
+function isArrayParts(result) {
+  return Array.isArray(result) && result[0].part_type;
+}
+function createSuccessfulToolResult(toolCallId, toolName, result) {
+  const parts = isArrayParts(result) ? result : [{
+    part_type: "data",
+    data: {
+      result,
+      success: true,
+      error: void 0
+    }
+  }];
+  return {
+    tool_call_id: toolCallId,
+    tool_name: toolName,
+    parts
+  };
+}
+function createFailedToolResult(toolCallId, toolName, error, result) {
+  return {
+    tool_call_id: toolCallId,
+    tool_name: toolName,
+    parts: [{
+      part_type: "data",
+      data: {
+        result: result ?? `Tool execution failed: ${error}`,
+        success: false,
+        error
+      }
+    }]
+  };
+}
+function isDataPart(part) {
+  return typeof part === "object" && part !== null && "part_type" in part && part.part_type === "data" && "data" in part;
+}
+function isToolResultData(data) {
+  return typeof data === "object" && data !== null && "success" in data && typeof data.success === "boolean";
+}
+function extractToolResultData(toolResult) {
+  if (!toolResult.parts || !Array.isArray(toolResult.parts) || toolResult.parts.length === 0) {
+    return null;
+  }
+  const firstPart = toolResult.parts[0];
+  if (isDataPart(firstPart)) {
+    const data = firstPart.data;
+    if (isToolResultData(data)) {
+      return {
+        result: data.result,
+        success: data.success,
+        error: data.error
+      };
+    }
+    if (typeof data === "string") {
+      try {
+        const parsed = JSON.parse(data);
+        if (isToolResultData(parsed)) {
+          return {
+            result: parsed.result,
+            success: parsed.success,
+            error: parsed.error
+          };
+        }
+        return {
+          result: parsed,
+          success: true,
+          error: void 0
+        };
+      } catch {
+        return {
+          result: data,
+          success: true,
+          error: void 0
+        };
+      }
+    }
+    return {
+      result: data,
+      success: true,
+      error: void 0
+    };
+  }
+  return null;
+}
+var DEFAULT_BASE_URL = "https://api.distri.dev";
 var DistriError = class extends Error {
   constructor(message, code, details) {
     super(message);
@@ -82,14 +169,8 @@ function isDistriMessage(event) {
 function isDistriEvent(event) {
   return "type" in event && "data" in event;
 }
-function isDistriPlan(event) {
-  return "steps" in event && Array.isArray(event.steps) && "reasoning" in event;
-}
-function isDistriArtifact(event) {
-  return "type" in event && "timestamp" in event && "id" in event;
-}
 
-// ../../node_modules/.pnpm/@a2a-js+sdk@https+++codeload.github.com+v3g42+a2a-js+tar.gz+51444c9/node_modules/@a2a-js/sdk/dist/chunk-CUGIRVQB.js
+// ../../../node_modules/.pnpm/@a2a-js+sdk@https+++codeload.github.com+v3g42+a2a-js+tar.gz+51444c9/node_modules/@a2a-js/sdk/dist/chunk-CUGIRVQB.js
 var A2AClient = class {
   /**
    * Constructs an A2AClient instance.
@@ -475,32 +556,56 @@ function convertA2AStatusUpdateToDistri(statusUpdate) {
   }
   const metadata = statusUpdate.metadata;
   switch (metadata.type) {
-    case "run_started":
-      return {
+    case "run_started": {
+      const runStartedResult = {
         type: "run_started",
-        data: {}
+        data: {
+          runId: statusUpdate.runId,
+          taskId: statusUpdate.taskId
+        }
       };
-    case "run_finished":
-      return {
+      return runStartedResult;
+    }
+    case "run_error": {
+      const runErrorResult = {
+        type: "run_error",
+        data: {
+          message: statusUpdate.error,
+          code: statusUpdate.code
+        }
+      };
+      return runErrorResult;
+    }
+    case "run_finished": {
+      const runFinishedResult = {
         type: "run_finished",
-        data: {}
+        data: {
+          runId: statusUpdate.runId,
+          taskId: statusUpdate.taskId
+        }
       };
-    case "plan_started":
-      return {
+      return runFinishedResult;
+    }
+    case "plan_started": {
+      const planStartedResult = {
         type: "plan_started",
         data: {
           initial_plan: metadata.initial_plan
         }
       };
-    case "plan_finished":
-      return {
+      return planStartedResult;
+    }
+    case "plan_finished": {
+      const planFinishedResult = {
         type: "plan_finished",
         data: {
           total_steps: metadata.total_steps
         }
       };
-    case "step_started":
-      return {
+      return planFinishedResult;
+    }
+    case "step_started": {
+      const stepStartedResult = {
         type: "step_started",
         data: {
           step_id: metadata.step_id,
@@ -508,8 +613,10 @@ function convertA2AStatusUpdateToDistri(statusUpdate) {
           step_index: metadata.step_index || 0
         }
       };
-    case "step_completed":
-      return {
+      return stepStartedResult;
+    }
+    case "step_completed": {
+      const stepCompletedResult = {
         type: "step_completed",
         data: {
           step_id: metadata.step_id,
@@ -517,142 +624,132 @@ function convertA2AStatusUpdateToDistri(statusUpdate) {
           step_index: metadata.step_index || 0
         }
       };
-    case "tool_execution_start":
-      return {
-        type: "tool_call_start",
+      return stepCompletedResult;
+    }
+    case "tool_execution_start": {
+      const toolStartResult = {
+        type: "tool_execution_start",
         data: {
           tool_call_id: metadata.tool_call_id,
           tool_call_name: metadata.tool_call_name || "Tool",
-          parent_message_id: statusUpdate.taskId,
-          is_external: true
+          parent_message_id: statusUpdate.taskId
         }
       };
-    case "tool_execution_end":
-      return {
-        type: "tool_call_end",
+      return toolStartResult;
+    }
+    case "tool_execution_end": {
+      const toolEndResult = {
+        type: "tool_execution_end",
         data: {
           tool_call_id: metadata.tool_call_id
         }
       };
-    case "text_message_start":
-      return {
+      return toolEndResult;
+    }
+    case "text_message_start": {
+      const textStartResult = {
         type: "text_message_start",
         data: {
           message_id: metadata.message_id,
+          step_id: metadata.step_id || "",
           role: metadata.role === "assistant" ? "assistant" : "user"
         }
       };
-    case "text_message_content":
-      return {
+      return textStartResult;
+    }
+    case "text_message_content": {
+      const textContentResult = {
         type: "text_message_content",
         data: {
           message_id: metadata.message_id,
+          step_id: metadata.step_id || "",
           delta: metadata.delta || ""
         }
       };
-    case "text_message_end":
-      return {
+      return textContentResult;
+    }
+    case "text_message_end": {
+      const textEndResult = {
         type: "text_message_end",
         data: {
-          message_id: metadata.message_id
+          message_id: metadata.message_id,
+          step_id: metadata.step_id || ""
         }
       };
-    default:
+      return textEndResult;
+    }
+    case "tool_calls": {
+      const toolCallsResult = {
+        type: "tool_calls",
+        data: {
+          tool_calls: metadata.tool_calls || []
+        }
+      };
+      return toolCallsResult;
+    }
+    case "tool_results": {
+      const toolResultsResult = {
+        type: "tool_results",
+        data: {
+          results: metadata.results || []
+        }
+      };
+      return toolResultsResult;
+    }
+    case "browser_screenshot": {
+      const browserScreenshotResult = {
+        type: "browser_screenshot",
+        data: {
+          image: metadata.image || "",
+          format: metadata.format,
+          filename: metadata.filename,
+          size: metadata.size,
+          timestamp_ms: metadata.timestamp_ms
+        }
+      };
+      return browserScreenshotResult;
+    }
+    case "inline_hook_requested": {
+      const hookRequested = {
+        type: "inline_hook_requested",
+        data: {
+          hook_id: metadata.request?.hook_id || metadata.hook_id || "",
+          hook: metadata.request?.hook || metadata.hook || "",
+          context: metadata.request?.context || metadata.context || {
+            agent_id: statusUpdate.agentId,
+            thread_id: statusUpdate.contextId,
+            task_id: statusUpdate.taskId,
+            run_id: statusUpdate.agentId
+          },
+          timeout_ms: metadata.request?.timeout_ms || metadata.timeout_ms,
+          fire_and_forget: metadata.request?.fire_and_forget ?? metadata.fire_and_forget,
+          message: metadata.request?.message || metadata.message,
+          plan: metadata.request?.plan || metadata.plan,
+          result: metadata.request?.result || metadata.result
+        }
+      };
+      return hookRequested;
+    }
+    default: {
       console.warn(`Unhandled status update metadata type: ${metadata.type}`, metadata);
-      return {
+      const defaultResult = {
         type: "run_started",
-        data: { metadata }
+        data: {
+          runId: statusUpdate.runId,
+          taskId: statusUpdate.taskId
+        }
       };
+      return defaultResult;
+    }
   }
 }
-function convertA2AArtifactToDistri(artifact) {
-  if (!artifact || !artifact.parts || !Array.isArray(artifact.parts)) {
-    return null;
-  }
-  const part = artifact.parts[0];
-  if (!part || part.kind !== "data" || !part.data) {
-    return null;
-  }
-  const data = part.data;
-  if (data.type === "llm_response") {
-    const hasContent = data.content && data.content.trim() !== "";
-    const hasToolCalls = data.tool_calls && Array.isArray(data.tool_calls) && data.tool_calls.length > 0;
-    const isExternal = data.is_external;
-    if (hasToolCalls) {
-      const executionResult2 = {
-        id: data.id || artifact.artifactId,
-        type: "llm_response",
-        timestamp: data.timestamp || data.created_at || Date.now(),
-        content: data.content?.trim() || "",
-        tool_calls: data.tool_calls,
-        step_id: data.step_id,
-        success: data.success,
-        rejected: data.rejected,
-        reason: data.reason,
-        is_external: isExternal
-      };
-      return executionResult2;
-    } else {
-      const parts = [];
-      if (hasContent) {
-        parts.push({ type: "text", text: data.content });
-      }
-      const distriMessage = {
-        id: artifact.artifactId,
-        role: "assistant",
-        parts,
-        created_at: data.timestamp || data.created_at || (/* @__PURE__ */ new Date()).toISOString()
-      };
-      return distriMessage;
-    }
-  }
-  if (data.type === "tool_results") {
-    const executionResult2 = {
-      id: data.id || artifact.artifactId,
-      type: "tool_results",
-      timestamp: data.timestamp || data.created_at || Date.now(),
-      results: data.results || [],
-      step_id: data.step_id,
-      success: data.success,
-      rejected: data.rejected,
-      reason: data.reason
-    };
-    return executionResult2;
-  }
-  if (data.type === "plan") {
-    const planResult = {
-      id: data.id || artifact.artifactId,
-      type: "plan",
-      timestamp: data.timestamp || data.created_at || Date.now(),
-      reasoning: data.reasoning || "",
-      steps: data.steps || []
-    };
-    return planResult;
-  }
-  const executionResult = {
-    id: artifact.artifactId,
-    type: "artifact",
-    timestamp: Date.now(),
-    data,
-    artifactId: artifact.artifactId,
-    name: artifact.name || "",
-    description: artifact.description || null
-  };
-  return executionResult;
-}
 function decodeA2AStreamEvent(event) {
-  if (event.artifactId && event.parts) {
-    return convertA2AArtifactToDistri(event);
-  }
   if (event.kind === "message") {
     return convertA2AMessageToDistri(event);
   }
   if (event.kind === "status-update") {
     return convertA2AStatusUpdateToDistri(event);
   }
-  if (event.kind === "artifact-update") {
-    return convertA2AArtifactToDistri(event);
-  }
   return null;
 }
 function processA2AStreamData(streamData) {
@@ -678,28 +775,26 @@ function processA2AMessagesData(data) {
 function convertA2APartToDistri(a2aPart) {
   switch (a2aPart.kind) {
     case "text":
-      return { type: "text", text: a2aPart.text };
+      return { part_type: "text", data: a2aPart.text };
     case "file":
       if ("uri" in a2aPart.file) {
-        return { type: "image_url", image: { mime_type: a2aPart.file.mimeType, url: a2aPart.file.uri } };
+        const fileUrl = { type: "url", mime_type: a2aPart.file.mimeType || "application/octet-stream", url: a2aPart.file.uri || "" };
+        return { part_type: "image", data: fileUrl };
       } else {
-        return { type: "image_bytes", image: { mime_type: a2aPart.file.mimeType, data: a2aPart.file.bytes } };
+        const fileBytes = { type: "bytes", mime_type: a2aPart.file.mimeType || "application/octet-stream", data: a2aPart.file.bytes || "" };
+        return { part_type: "image", data: fileBytes };
       }
     case "data":
       switch (a2aPart.data.part_type) {
         case "tool_call":
-          return { type: "tool_call", tool_call: a2aPart.data };
+          return { part_type: "tool_call", data: a2aPart.data };
         case "tool_result":
-          return { type: "tool_result", tool_result: a2aPart.data };
-        case "code_observation":
-          return { type: "code_observation", thought: a2aPart.data.thought, code: a2aPart.data.code };
-        case "plan":
-          return { type: "plan", plan: a2aPart.data.plan };
+          return { part_type: "tool_result", data: a2aPart.data };
         default:
-          return { type: "data", data: a2aPart.data };
+          return { part_type: "data", data: a2aPart.data };
       }
     default:
-      return { type: "text", text: JSON.stringify(a2aPart) };
+      return { part_type: "text", data: JSON.stringify(a2aPart) };
   }
 }
 function convertDistriMessageToA2A(distriMessage, context) {
@@ -724,52 +819,95 @@ function convertDistriMessageToA2A(distriMessage, context) {
     parts: distriMessage.parts.map(convertDistriPartToA2A),
     kind: "message",
     contextId: context.thread_id,
-    taskId: context.run_id
+    taskId: context.task_id || context.run_id || void 0
   };
 }
 function convertDistriPartToA2A(distriPart) {
-  switch (distriPart.type) {
+  let result;
+  switch (distriPart.part_type) {
     case "text":
-      return { kind: "text", text: distriPart.text };
-    case "image_url":
-      return { kind: "file", file: { mimeType: distriPart.image.mime_type, uri: distriPart.image.url } };
-    case "image_bytes":
-      return { kind: "file", file: { mimeType: distriPart.image.mime_type, bytes: distriPart.image.data } };
+      result = { kind: "text", text: distriPart.data };
+      break;
+    case "image":
+      if ("url" in distriPart.data) {
+        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 };
+        result = { kind: "file", file: fileBytes };
+      }
+      break;
     case "tool_call":
-      return { kind: "data", data: { part_type: "tool_call", tool_call: distriPart.tool_call } };
-    case "tool_result":
-      let val = {
+      result = {
         kind: "data",
         data: {
-          tool_call_id: distriPart.tool_result.tool_call_id,
-          tool_name: distriPart.tool_result.tool_name,
-          result: distriPart.tool_result.result,
-          part_type: "tool_result"
+          part_type: "tool_call",
+          data: distriPart.data
         }
       };
-      return val;
-    case "code_observation":
-      return { kind: "data", data: { ...distriPart, part_type: "code_observation" } };
-    case "plan":
-      return { kind: "data", data: { ...distriPart, part_type: "plan" } };
-    case "data":
-      return { kind: "data", ...distriPart.data };
+      break;
+    case "tool_result": {
+      const toolResult = distriPart.data;
+      const parts = toolResult.parts.map((part) => {
+        if ("type" in part && part.type === "data") {
+          return {
+            part_type: "data",
+            data: part.data
+          };
+        } else if ("part_type" in part) {
+          return part;
+        } else {
+          return {
+            part_type: "data",
+            data: part
+          };
+        }
+      });
+      result = {
+        kind: "data",
+        data: {
+          part_type: "tool_result",
+          data: {
+            tool_call_id: toolResult.tool_call_id,
+            tool_name: toolResult.tool_name,
+            parts
+          }
+        }
+      };
+      break;
+    }
+    case "data": {
+      const dataValue = distriPart.data;
+      if (dataValue === null || typeof dataValue !== "object" || Array.isArray(dataValue)) {
+        result = { kind: "data", data: { value: dataValue } };
+      } else {
+        const dataObj = dataValue;
+        result = { kind: "data", data: dataObj };
+      }
+      break;
+    }
   }
+  return result;
 }
 function extractTextFromDistriMessage(message) {
-  return message.parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+  return message.parts.filter((part) => part.part_type === "text").map((part) => part.data).join("\n");
 }
 function extractToolCallsFromDistriMessage(message) {
-  return message.parts.filter((part) => part.type === "tool_call").map((part) => part.tool_call);
+  return message.parts.filter((part) => part.part_type === "tool_call").map((part) => part.data);
 }
 function extractToolResultsFromDistriMessage(message) {
-  return message.parts.filter((part) => part.type === "tool_result").map((part) => part.tool_result);
+  return message.parts.filter((part) => part.part_type === "tool_result").map((part) => part.data);
 }
 
 // src/distri-client.ts
-var DistriClient = class {
+var _DistriClient = class _DistriClient {
   constructor(config) {
     this.agentClients = /* @__PURE__ */ new Map();
+    const headers = { ...config.headers };
+    this.accessToken = config.accessToken;
+    this.refreshToken = config.refreshToken;
+    this.tokenRefreshSkewMs = config.tokenRefreshSkewMs ?? 6e4;
+    this.onTokenRefresh = config.onTokenRefresh;
     this.config = {
       baseUrl: config.baseUrl.replace(/\/$/, ""),
       apiVersion: config.apiVersion || "v1",
@@ -777,10 +915,362 @@ var DistriClient = class {
       retryAttempts: config.retryAttempts || 3,
       retryDelay: config.retryDelay || 1e3,
       debug: config.debug || false,
-      headers: config.headers || {},
+      headers,
       interceptor: config.interceptor || ((init) => Promise.resolve(init))
     };
-    this.debug("DistriClient initialized with config:", this.config);
+    this.debug("DistriClient initialized with config:", {
+      baseUrl: this.config.baseUrl,
+      hasAccessToken: !!this.accessToken,
+      hasRefreshToken: !!this.refreshToken,
+      timeout: this.config.timeout
+    });
+  }
+  /**
+   * Create a client with default cloud configuration.
+   *
+   * @param overrides - Optional overrides for the default config
+   */
+  static create(overrides = {}) {
+    return new _DistriClient({
+      baseUrl: DEFAULT_BASE_URL,
+      ...overrides
+    });
+  }
+  /**
+   * Check if this client has authentication configured.
+   */
+  hasAuth() {
+    return !!this.accessToken || !!this.refreshToken;
+  }
+  /**
+   * Check if this client is configured for local development.
+   */
+  isLocal() {
+    return this.config.baseUrl.includes("localhost") || this.config.baseUrl.includes("127.0.0.1");
+  }
+  /**
+   * Session store: set a value (optionally with expiry)
+   */
+  async setSessionValue(sessionId, key, value, expiry) {
+    const body = { key, value };
+    if (expiry) {
+      body.expiry = typeof expiry === "string" ? expiry : expiry.toISOString();
+    }
+    const resp = await this.fetch(`/session/${encodeURIComponent(sessionId)}/values`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.config.headers
+      },
+      body: JSON.stringify(body)
+    });
+    if (!resp.ok && resp.status !== 204) {
+      const errorData = await resp.json().catch(() => ({}));
+      throw new ApiError(errorData.error || "Failed to set session value", resp.status);
+    }
+  }
+  /**
+   * Session store: get a single value
+   */
+  async getSessionValue(sessionId, key) {
+    const resp = await this.fetch(`/session/${encodeURIComponent(sessionId)}/values/${encodeURIComponent(key)}`, {
+      method: "GET",
+      headers: {
+        ...this.config.headers
+      }
+    });
+    if (!resp.ok) {
+      const errorData = await resp.json().catch(() => ({}));
+      throw new ApiError(errorData.error || "Failed to get session value", resp.status);
+    }
+    const data = await resp.json().catch(() => ({ value: null }));
+    return data?.value ?? null;
+  }
+  /**
+   * Session store: get all values in a session
+   */
+  async getSessionValues(sessionId) {
+    const resp = await this.fetch(`/session/${encodeURIComponent(sessionId)}/values`, {
+      method: "GET",
+      headers: {
+        ...this.config.headers
+      }
+    });
+    if (!resp.ok) {
+      const errorData = await resp.json().catch(() => ({}));
+      throw new ApiError(errorData.error || "Failed to get session values", resp.status);
+    }
+    const data = await resp.json().catch(() => ({ values: {} }));
+    return data?.values ?? {};
+  }
+  /**
+   * Session store: delete a single key
+   */
+  async deleteSessionValue(sessionId, key) {
+    const resp = await this.fetch(`/session/${encodeURIComponent(sessionId)}/values/${encodeURIComponent(key)}`, {
+      method: "DELETE",
+      headers: {
+        ...this.config.headers
+      }
+    });
+    if (!resp.ok && resp.status !== 204) {
+      const errorData = await resp.json().catch(() => ({}));
+      throw new ApiError(errorData.error || "Failed to delete session value", resp.status);
+    }
+  }
+  /**
+   * Session store: clear all keys in a session
+   */
+  async clearSession(sessionId) {
+    const resp = await this.fetch(`/session/${encodeURIComponent(sessionId)}`, {
+      method: "DELETE",
+      headers: {
+        ...this.config.headers
+      }
+    });
+    if (!resp.ok && resp.status !== 204) {
+      const errorData = await resp.json().catch(() => ({}));
+      throw new ApiError(errorData.error || "Failed to clear session", resp.status);
+    }
+  }
+  /**
+   * Set additional user message parts for the next agent iteration.
+   * These parts will be appended to the user message in the prompt.
+   * @param sessionId - The thread/session ID
+   * @param parts - Array of DistriPart objects to append to user message
+   */
+  async setAdditionalUserParts(sessionId, parts) {
+    await this.setSessionValue(sessionId, _DistriClient.ADDITIONAL_PARTS_KEY, parts);
+  }
+  /**
+   * Get the current additional user message parts.
+   * @param sessionId - The thread/session ID
+   * @returns Array of DistriPart objects or null if not set
+   */
+  async getAdditionalUserParts(sessionId) {
+    return this.getSessionValue(sessionId, _DistriClient.ADDITIONAL_PARTS_KEY);
+  }
+  /**
+   * Clear/delete the additional user message parts.
+   * @param sessionId - The thread/session ID
+   */
+  async clearAdditionalUserParts(sessionId) {
+    await this.deleteSessionValue(sessionId, _DistriClient.ADDITIONAL_PARTS_KEY);
+  }
+  /**
+   * Issue an access token + refresh token for temporary authentication.
+   * Requires an existing authenticated session (bearer token).
+   *
+   * @returns Token response with access/refresh token strings
+   * @throws ApiError if not authenticated or token issuance fails
+   *
+   * @example
+   * ```typescript
+   * const { access_token, refresh_token } = await client.issueToken();
+   * // Persist the refresh token and use access_token for requests
+   * ```
+   */
+  async issueToken() {
+    const response = await this.fetch("/token", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.config.headers
+      }
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new ApiError(errorData.error || "Failed to issue token", response.status);
+    }
+    const tokens = await response.json();
+    if (!tokens?.access_token || !tokens?.refresh_token || typeof tokens?.expires_at !== "number") {
+      throw new ApiError("Invalid token response", response.status);
+    }
+    this.applyTokens(tokens.access_token, tokens.refresh_token, false);
+    return tokens;
+  }
+  /**
+   * Get the current access/refresh tokens.
+   */
+  getTokens() {
+    return { accessToken: this.accessToken, refreshToken: this.refreshToken };
+  }
+  /**
+   * Update the access/refresh tokens in memory.
+   */
+  setTokens(tokens) {
+    if (tokens.accessToken !== void 0) {
+      this.accessToken = tokens.accessToken;
+    }
+    if (tokens.refreshToken !== void 0) {
+      this.refreshToken = tokens.refreshToken;
+    }
+  }
+  /**
+   * Start streaming speech-to-text transcription via WebSocket
+   */
+  async streamingTranscription(options = {}) {
+    const baseUrl = this.config.baseUrl;
+    const wsUrl = baseUrl.replace("http://", "ws://").replace("https://", "wss://") + "/voice/stream";
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      let isResolved = false;
+      ws.onopen = () => {
+        ws.send(JSON.stringify({ type: "start_session" }));
+        options.onStart?.();
+        if (!isResolved) {
+          isResolved = true;
+          resolve({
+            sendAudio: (audioData) => {
+              if (ws.readyState === WebSocket.OPEN) {
+                ws.send(audioData);
+              }
+            },
+            sendText: (text) => {
+              if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: "text_chunk", text }));
+              }
+            },
+            stop: () => {
+              if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: "end_session" }));
+              }
+            },
+            close: () => {
+              ws.close();
+            }
+          });
+        }
+      };
+      ws.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          switch (data.type) {
+            case "text_chunk":
+              options.onTranscript?.(data.text || "", data.is_final || false);
+              break;
+            case "session_started":
+              this.debug("Speech-to-text session started");
+              break;
+            case "session_ended":
+              this.debug("Speech-to-text session ended");
+              options.onEnd?.();
+              break;
+            case "error": {
+              const error = new Error(data.message || "WebSocket error");
+              this.debug("Speech-to-text error:", error);
+              options.onError?.(error);
+              break;
+            }
+            default:
+              this.debug("Unknown message type:", data.type);
+          }
+        } catch (error) {
+          const parseError = new Error("Failed to parse WebSocket message");
+          this.debug("Parse error:", parseError);
+          options.onError?.(parseError);
+        }
+      };
+      ws.onerror = (event) => {
+        const error = new Error("WebSocket connection error");
+        this.debug("WebSocket error:", event);
+        options.onError?.(error);
+        if (!isResolved) {
+          isResolved = true;
+          reject(error);
+        }
+      };
+      ws.onclose = (event) => {
+        this.debug("WebSocket closed:", event.code, event.reason);
+        options.onEnd?.();
+      };
+    });
+  }
+  /**
+   * Transcribe audio blob to text using speech-to-text API
+   */
+  async transcribe(audioBlob, config = {}) {
+    try {
+      const arrayBuffer = await audioBlob.arrayBuffer();
+      const uint8Array = new Uint8Array(arrayBuffer);
+      const base64String = btoa(String.fromCharCode(...uint8Array));
+      const requestBody = {
+        audio: base64String,
+        model: config.model || "whisper-1",
+        ...config.language && { language: config.language },
+        ...config.temperature !== void 0 && { temperature: config.temperature }
+      };
+      this.debug("Transcribing audio:", {
+        model: requestBody.model,
+        language: config.language,
+        audioSize: audioBlob.size
+      });
+      const response = await this.fetch(`/tts/transcribe`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.headers
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const errorMessage = errorData.error || `Transcription failed: ${response.status}`;
+        throw new ApiError(errorMessage, response.status);
+      }
+      const result = await response.json();
+      const transcription = result.text || "";
+      this.debug("Transcription result:", { text: transcription });
+      return transcription;
+    } catch (error) {
+      if (error instanceof ApiError) throw error;
+      throw new DistriError("Failed to transcribe audio", "TRANSCRIPTION_ERROR", error);
+    }
+  }
+  async getConfiguration() {
+    const response = await this.fetch(`/configuration`, {
+      method: "GET",
+      headers: {
+        ...this.config.headers
+      }
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new ApiError(errorData.error || "Failed to load configuration", response.status);
+    }
+    return response.json();
+  }
+  async updateConfiguration(configuration) {
+    const response = await this.fetch(`/configuration`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.config.headers
+      },
+      body: JSON.stringify(configuration)
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new ApiError(errorData.error || "Failed to update configuration", response.status);
+    }
+    return response.json();
+  }
+  /**
+   * Minimal LLM helper that proxies to the Distri server using Distri messages.
+   */
+  async llm(messages, tools = [], options) {
+    const headers = { "Content-Type": "application/json" };
+    const response = await this.fetch(`/llm/execute`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ messages, tools, ...options })
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      const message = errorData?.error || response.statusText || "LLM request failed";
+      throw new ApiError(`LLM request failed: ${message}`, response.status);
+    }
+    return response.json();
   }
   /**
    * Get all available agents from the Distri server
@@ -837,14 +1327,18 @@ var DistriClient = class {
    * Get or create A2AClient for an agent
    */
   getA2AClient(agentId) {
-    if (!this.agentClients.has(agentId)) {
+    const agentUrl = `${this.config.baseUrl}/agents/${agentId}`;
+    const existing = this.agentClients.get(agentId);
+    if (!existing || existing.url !== agentUrl) {
       const fetchFn = this.fetchAbsolute.bind(this);
-      const agentUrl = `${this.config.baseUrl}/agents/${agentId}`;
       const client = new A2AClient(agentUrl, fetchFn);
-      this.agentClients.set(agentId, client);
-      this.debug(`Created A2AClient for agent ${agentId} at ${agentUrl}`);
+      this.agentClients.set(agentId, { url: agentUrl, client });
+      this.debug(
+        existing ? `Recreated A2AClient for agent ${agentId} with new URL ${agentUrl}` : `Created A2AClient for agent ${agentId} at ${agentUrl}`
+      );
+      return client;
     }
-    return this.agentClients.get(agentId);
+    return existing.client;
   }
   /**
    * Send a message to an agent
@@ -871,6 +1365,7 @@ var DistriClient = class {
    * Send a streaming message to an agent
    */
   async *sendMessageStream(agentId, params) {
+    console.log("sendMessageStream", agentId, params);
     try {
       const client = this.getA2AClient(agentId);
       yield* await client.sendMessageStream(params);
@@ -976,18 +1471,195 @@ var DistriClient = class {
     };
     await this.sendMessage(threadId, params);
   }
+  /**
+   * Complete an external tool call
+   */
+  async completeTool(agentId, result) {
+    try {
+      const response = await this.fetch(`/agents/${agentId}/complete-tool`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.headers
+        },
+        body: JSON.stringify({
+          tool_call_id: result.tool_call_id,
+          tool_response: result
+        })
+      });
+      if (!response.ok) {
+        throw new ApiError(`Failed to complete tool: ${response.statusText}`, response.status);
+      }
+      this.debug(`Tool completed: ${result.tool_name} (${result.tool_call_id}) for agent ${agentId}`);
+    } catch (error) {
+      if (error instanceof ApiError) throw error;
+      throw new DistriError(`Failed to complete tool ${result.tool_name} (${result.tool_call_id}) for agent ${agentId}`, "COMPLETE_TOOL_ERROR", error);
+    }
+  }
+  /**
+   * Complete an inline hook with a mutation payload.
+   */
+  async completeInlineHook(hookId, mutation) {
+    const response = await this.fetch(`/event/hooks`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.config.headers
+      },
+      body: JSON.stringify({
+        hook_id: hookId,
+        mutation
+      })
+    });
+    if (!response.ok) {
+      throw new ApiError(`Failed to complete inline hook: ${response.statusText}`, response.status);
+    }
+  }
   /**
    * Get the base URL for making direct requests
    */
   get baseUrl() {
     return this.config.baseUrl;
   }
+  applyTokens(accessToken, refreshToken, notify) {
+    this.accessToken = accessToken;
+    this.refreshToken = refreshToken;
+    if (notify && this.onTokenRefresh) {
+      this.onTokenRefresh({ accessToken, refreshToken });
+    }
+  }
+  async ensureAccessToken() {
+    if (!this.refreshToken) {
+      return;
+    }
+    if (!this.accessToken || this.isTokenExpiring(this.accessToken)) {
+      try {
+        await this.refreshTokens();
+      } catch (error) {
+        this.debug("Token refresh failed:", error);
+      }
+    }
+  }
+  async refreshTokens() {
+    if (!this.refreshToken) {
+      return;
+    }
+    if (!this.refreshPromise) {
+      this.refreshPromise = this.performTokenRefresh().finally(() => {
+        this.refreshPromise = void 0;
+      });
+    }
+    return this.refreshPromise;
+  }
+  async performTokenRefresh() {
+    const response = await this.fetchAbsolute(
+      `${this.config.baseUrl}/token`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.headers
+        },
+        body: JSON.stringify({
+          grant_type: "refresh_token",
+          refresh_token: this.refreshToken
+        })
+      },
+      { skipAuth: true, retryOnAuth: false }
+    );
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new ApiError(errorData.error || "Failed to refresh token", response.status);
+    }
+    const tokens = await response.json();
+    if (!tokens?.access_token || !tokens?.refresh_token) {
+      throw new ApiError("Invalid token response", response.status);
+    }
+    this.applyTokens(tokens.access_token, tokens.refresh_token, true);
+  }
+  isTokenExpiring(token) {
+    const expiresAt = this.getTokenExpiry(token);
+    if (!expiresAt) {
+      return false;
+    }
+    return expiresAt <= Date.now() + this.tokenRefreshSkewMs;
+  }
+  getTokenExpiry(token) {
+    const payload = this.decodeJwtPayload(token);
+    const exp = payload?.exp;
+    if (typeof exp !== "number") {
+      return null;
+    }
+    return exp * 1e3;
+  }
+  decodeJwtPayload(token) {
+    const parts = token.split(".");
+    if (parts.length < 2) {
+      return null;
+    }
+    const decoded = this.decodeBase64Url(parts[1]);
+    if (!decoded) {
+      return null;
+    }
+    try {
+      return JSON.parse(decoded);
+    } catch {
+      return null;
+    }
+  }
+  decodeBase64Url(value) {
+    const base64 = value.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+    try {
+      if (typeof atob === "function") {
+        return atob(padded);
+      }
+      const buffer = globalThis.Buffer;
+      if (typeof buffer !== "undefined") {
+        return buffer.from(padded, "base64").toString("utf8");
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  applyAuthHeader(headers) {
+    if (this.accessToken && !headers.has("authorization")) {
+      headers.set("Authorization", `Bearer ${this.accessToken}`);
+    }
+  }
   /**
    * Enhanced fetch with retry logic
    */
-  async fetchAbsolute(url, initialInit) {
+  async fetchAbsolute(url, initialInit, options) {
+    const { skipAuth = false, retryOnAuth = true } = options ?? {};
     const init = await this.config.interceptor(initialInit);
     let lastError;
+    const headers = new Headers();
+    const applyHeaders = (src) => {
+      if (!src) return;
+      if (src instanceof Headers) {
+        src.forEach((value, key) => headers.set(key, value));
+      } else if (Array.isArray(src)) {
+        src.forEach(([key, value]) => headers.set(key, value));
+      } else if (typeof src === "object") {
+        Object.entries(src).forEach(([key, value]) => {
+          if (typeof value === "string") {
+            headers.set(key, value);
+          }
+        });
+      }
+    };
+    applyHeaders(this.config.headers);
+    applyHeaders(init?.headers);
+    const hasBody = init?.body !== void 0 && !(init.body instanceof FormData) && !(init.body instanceof Blob);
+    if (!headers.has("content-type") && hasBody) {
+      headers.set("Content-Type", "application/json");
+    }
+    if (!skipAuth) {
+      await this.ensureAccessToken();
+      this.applyAuthHeader(headers);
+    }
     for (let attempt = 0; attempt <= this.config.retryAttempts; attempt++) {
       try {
         const controller = new AbortController();
@@ -995,12 +1667,15 @@ var DistriClient = class {
         const response = await fetch(url, {
           ...init,
           signal: controller.signal,
-          headers: {
-            ...this.config.headers,
-            ...init?.headers
-          }
+          headers
         });
         clearTimeout(timeoutId);
+        if (!skipAuth && retryOnAuth && response.status === 401 && this.refreshToken) {
+          const refreshed = await this.refreshTokens().then(() => true).catch(() => false);
+          if (refreshed) {
+            return this.fetchAbsolute(url, initialInit, { skipAuth, retryOnAuth: false });
+          }
+        }
         return response;
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
@@ -1013,7 +1688,8 @@ var DistriClient = class {
     throw lastError;
   }
   /**
-   * Enhanced fetch with retry logic
+   * Enhanced fetch with retry logic and auth headers.
+   * Exposed publicly for extensions like DistriHomeClient.
    */
   async fetch(input, initialInit) {
     const url = `${this.config.baseUrl}${input}`;
@@ -1055,7 +1731,7 @@ var DistriClient = class {
       id: id || uuidv4(),
       role,
       parts,
-      created_at
+      created_at: created_at || (/* @__PURE__ */ new Date()).getTime()
     };
   }
   /**
@@ -1085,6 +1761,25 @@ var DistriClient = class {
     };
   }
 };
+// ============================================================
+// Additional User Message Parts API
+// ============================================================
+// These methods allow external tools to append parts (text, images)
+// to the user message in the next agent iteration.
+// The parts are stored under the key "__additional_user_parts".
+_DistriClient.ADDITIONAL_PARTS_KEY = "__additional_user_parts";
+// ============================================================
+// Token API
+// ============================================================
+// Issue access + refresh tokens for temporary authentication (e.g., frontend use)
+/**
+ * Response from the token endpoint
+ */
+_DistriClient.TokenType = {
+  Main: "main",
+  Short: "short"
+};
+var DistriClient = _DistriClient;
 function uuidv4() {
   if (typeof crypto?.randomUUID === "function") {
     return crypto.randomUUID();
@@ -1099,42 +1794,32 @@ function uuidv4() {
 }
 
 // src/agent.ts
+var ExternalToolValidationError = class extends DistriError {
+  constructor(agentName, result) {
+    super(
+      result.message || "Missing required external tools for agent invocation.",
+      "EXTERNAL_TOOL_VALIDATION_ERROR",
+      {
+        agentName,
+        missingTools: result.missingTools,
+        requiredTools: result.requiredTools,
+        providedTools: result.providedTools
+      }
+    );
+    this.name = "ExternalToolValidationError";
+    this.agentName = agentName;
+    this.missingTools = result.missingTools;
+    this.requiredTools = result.requiredTools;
+    this.providedTools = result.providedTools;
+  }
+};
 var Agent = class _Agent {
   constructor(agentDefinition, client) {
-    this.tools = /* @__PURE__ */ new Map();
+    this.hookHandlers = /* @__PURE__ */ new Map();
+    this.defaultHookHandler = null;
     this.agentDefinition = agentDefinition;
     this.client = client;
   }
-  /**
-   * Add a tool to the agent (AG-UI style)
-   */
-  registerTool(tool) {
-    this.tools.set(tool.name, tool);
-  }
-  /**
-   * Add multiple tools at once
-   */
-  registerTools(tools) {
-    tools.forEach((tool) => this.registerTool(tool));
-  }
-  /**
-   * Remove a tool
-   */
-  unregisterTool(toolName) {
-    this.tools.delete(toolName);
-  }
-  /**
-   * Get all registered tools
-   */
-  getTools() {
-    return Array.from(this.tools.values());
-  }
-  /**
-   * Check if a tool is registered
-   */
-  hasTool(toolName) {
-    return this.tools.has(toolName);
-  }
   /**
    * Get agent information
    */
@@ -1147,9 +1832,18 @@ var Agent = class _Agent {
   get description() {
     return this.agentDefinition.description;
   }
+  get agentType() {
+    return this.agentDefinition.agent_type;
+  }
   get iconUrl() {
     return this.agentDefinition.icon_url;
   }
+  /**
+   * Get the full agent definition (including backend tools)
+   */
+  getDefinition() {
+    return this.agentDefinition;
+  }
   /**
    * Fetch messages for a thread (public method for useChat)
    */
@@ -1159,51 +1853,154 @@ var Agent = class _Agent {
   /**
    * Direct (non-streaming) invoke
    */
-  async invoke(params) {
-    const enhancedParams = this.enhanceParamsWithTools(params);
-    console.log("enhancedParams", enhancedParams);
+  async invoke(params, tools, hooks) {
+    if (hooks) {
+      this.registerHooks(hooks);
+    }
+    const enhancedParams = this.enhanceParamsWithTools(params, tools);
     return await this.client.sendMessage(this.agentDefinition.id, enhancedParams);
   }
   /**
    * Streaming invoke
    */
-  async invokeStream(params) {
-    const enhancedParams = this.enhanceParamsWithTools(params);
-    console.log("enhancedParams", enhancedParams);
+  async invokeStream(params, tools, hooks) {
+    if (hooks) {
+      this.registerHooks(hooks);
+    }
+    const enhancedParams = this.enhanceParamsWithTools(params, tools);
     const a2aStream = this.client.sendMessageStream(this.agentDefinition.id, enhancedParams);
-    return async function* () {
+    const self = this;
+    return (async function* () {
       for await (const event of a2aStream) {
         const converted = decodeA2AStreamEvent(event);
-        if (converted) {
+        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: {} });
+          }
+          yield converted;
+        } else if (converted) {
           yield converted;
         }
       }
-    }();
+    })();
+  }
+  /**
+   * Validate that required external tools are registered before invoking.
+   */
+  validateExternalTools(tools = []) {
+    const requiredTools = this.getRequiredExternalTools();
+    const providedTools = tools.map((tool) => tool.name);
+    if (requiredTools.length === 0) {
+      return {
+        isValid: true,
+        requiredTools: [],
+        providedTools,
+        missingTools: []
+      };
+    }
+    const providedSet = new Set(providedTools);
+    const missingTools = requiredTools.filter((tool) => !providedSet.has(tool));
+    const isValid = missingTools.length === 0;
+    return {
+      isValid,
+      requiredTools,
+      providedTools,
+      missingTools,
+      message: isValid ? void 0 : this.formatExternalToolValidationMessage(requiredTools, missingTools)
+    };
   }
   /**
    * Enhance message params with tool definitions
    */
-  enhanceParamsWithTools(params) {
-    const tools = this.getTools();
+  enhanceParamsWithTools(params, tools) {
+    this.assertExternalTools(tools);
+    const metadata = {
+      ...params.metadata,
+      external_tools: tools?.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+        is_final: tool.is_final
+      })) || []
+    };
     return {
       ...params,
-      metadata: {
-        ...params.metadata,
-        tools: tools.map((tool) => ({
-          name: tool.name,
-          description: tool.description,
-          input_schema: tool.input_schema
-        }))
-      }
+      metadata
     };
   }
+  assertExternalTools(tools) {
+    const result = this.validateExternalTools(tools ?? []);
+    if (!result.isValid) {
+      throw new ExternalToolValidationError(this.agentDefinition.name || this.agentDefinition.id, result);
+    }
+  }
+  getRequiredExternalTools() {
+    const toolConfig = this.resolveToolConfig();
+    if (!toolConfig?.external || !Array.isArray(toolConfig.external)) {
+      return [];
+    }
+    return toolConfig.external.filter((tool) => typeof tool === "string" && tool.trim().length > 0);
+  }
+  resolveToolConfig() {
+    const root = this.agentDefinition;
+    return this.extractToolConfig(root) || this.extractToolConfig(root?.agent) || this.extractToolConfig(root?.definition);
+  }
+  extractToolConfig(candidate) {
+    if (!candidate) return null;
+    const tools = candidate.tools;
+    if (!tools || Array.isArray(tools) || typeof tools !== "object") {
+      return null;
+    }
+    return tools;
+  }
+  formatExternalToolValidationMessage(requiredTools, missingTools) {
+    const requiredList = requiredTools.join(", ");
+    const missingList = missingTools.join(", ");
+    return `Agent has external tools that are not registered: ${missingList}. This is an embedded agent that can run within the parent application. Register DistriWidget for embedding the parent component. Required tools: ${requiredList}.`;
+  }
+  /**
+   * Register multiple hooks at once.
+   */
+  registerHooks(hooks, defaultHandler) {
+    Object.entries(hooks).forEach(([hook, handler]) => {
+      this.hookHandlers.set(hook, handler);
+    });
+    if (defaultHandler) {
+      this.defaultHookHandler = defaultHandler;
+    }
+  }
   /**
    * Create an agent instance from an agent ID
    */
   static async create(agentIdOrDef, client) {
     const agentDefinition = typeof agentIdOrDef === "string" ? await client.getAgent(agentIdOrDef) : agentIdOrDef;
+    const tools = agentDefinition?.resolved_tools || [];
+    console.log("\u{1F916} Agent definition loaded:", {
+      id: agentDefinition.id,
+      name: agentDefinition.name,
+      tools: tools.map((t) => ({
+        name: t.name,
+        type: "function"
+      })) || [],
+      toolCount: agentDefinition.tools?.length || 0
+    });
     return new _Agent(agentDefinition, client);
   }
+  /**
+   * Complete an external tool call by sending the result back to the server
+   */
+  async completeTool(result) {
+    await this.client.completeTool(this.agentDefinition.id, result);
+  }
   /**
    * List all available agents
    */
@@ -1218,22 +2015,25 @@ var Agent = class _Agent {
   Agent,
   ApiError,
   ConnectionError,
+  DEFAULT_BASE_URL,
   DistriClient,
   DistriError,
-  convertA2AArtifactToDistri,
+  ExternalToolValidationError,
   convertA2AMessageToDistri,
   convertA2APartToDistri,
   convertA2AStatusUpdateToDistri,
   convertDistriMessageToA2A,
   convertDistriPartToA2A,
+  createFailedToolResult,
+  createSuccessfulToolResult,
   decodeA2AStreamEvent,
   extractTextFromDistriMessage,
   extractToolCallsFromDistriMessage,
+  extractToolResultData,
   extractToolResultsFromDistriMessage,
-  isDistriArtifact,
+  isArrayParts,
   isDistriEvent,
   isDistriMessage,
-  isDistriPlan,
   processA2AMessagesData,
   processA2AStreamData,
   uuidv4