@distri/react 0.2.1 → 0.2.3

package/dist/index.js

@@ -1,957 +1,8 @@
 "use client";
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/DistriProvider.tsx
 import { createContext as createContext2, useContext as useContext2, useEffect as useEffect2, useState as useState2 } from "react";
-
-// ../../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.
-   * It initiates fetching the agent card from the provided agent baseUrl.
-   * The Agent Card is expected at `${agentBaseUrl}/.well-known/agent.json`.
-   * The `url` field from the Agent Card will be used as the RPC service endpoint.
-   * @param agentBaseUrl The base URL of the A2A agent (e.g., https://agent.example.com).
-   */
-  constructor(agentBaseUrl, fetchFn) {
-    __publicField(this, "agentBaseUrl");
-    __publicField(this, "agentCardPromise");
-    __publicField(this, "requestIdCounter", 1);
-    __publicField(this, "serviceEndpointUrl");
-    // To be populated from AgentCard after fetching
-    __publicField(this, "fetchFn");
-    this.agentBaseUrl = agentBaseUrl.replace(/\/$/, "");
-    this.fetchFn = fetchFn || globalThis.fetch;
-    this.agentCardPromise = this._fetchAndCacheAgentCard();
-  }
-  /**
-   * Fetches the Agent Card from the agent's well-known URI and caches its service endpoint URL.
-   * This method is called by the constructor.
-   * @returns A Promise that resolves to the AgentCard.
-   */
-  async _fetchAndCacheAgentCard() {
-    const agentCardUrl = `${this.agentBaseUrl}/.well-known/agent.json`;
-    try {
-      const response = await this.fetchFn(agentCardUrl, {
-        headers: { "Accept": "application/json" }
-      });
-      if (!response.ok) {
-        throw new Error(`Failed to fetch Agent Card from ${agentCardUrl}: ${response.status} ${response.statusText}`);
-      }
-      const agentCard = await response.json();
-      if (!agentCard.url) {
-        throw new Error("Fetched Agent Card does not contain a valid 'url' for the service endpoint.");
-      }
-      this.serviceEndpointUrl = agentCard.url;
-      return agentCard;
-    } catch (error) {
-      console.error("Error fetching or parsing Agent Card:");
-      throw error;
-    }
-  }
-  /**
-   * Retrieves the Agent Card.
-   * If an `agentBaseUrl` is provided, it fetches the card from that specific URL.
-   * Otherwise, it returns the card fetched and cached during client construction.
-   * @param agentBaseUrl Optional. The base URL of the agent to fetch the card from.
-   * If provided, this will fetch a new card, not use the cached one from the constructor's URL.
-   * @returns A Promise that resolves to the AgentCard.
-   */
-  async getAgentCard(agentBaseUrl) {
-    if (agentBaseUrl) {
-      const specificAgentBaseUrl = agentBaseUrl.replace(/\/$/, "");
-      const agentCardUrl = `${specificAgentBaseUrl}/.well-known/agent.json`;
-      const response = await this.fetchFn(agentCardUrl, {
-        headers: { "Accept": "application/json" }
-      });
-      if (!response.ok) {
-        throw new Error(`Failed to fetch Agent Card from ${agentCardUrl}: ${response.status} ${response.statusText}`);
-      }
-      return await response.json();
-    }
-    return this.agentCardPromise;
-  }
-  /**
-   * Gets the RPC service endpoint URL. Ensures the agent card has been fetched first.
-   * @returns A Promise that resolves to the service endpoint URL string.
-   */
-  async _getServiceEndpoint() {
-    if (this.serviceEndpointUrl) {
-      return this.serviceEndpointUrl;
-    }
-    await this.agentCardPromise;
-    if (!this.serviceEndpointUrl) {
-      throw new Error("Agent Card URL for RPC endpoint is not available. Fetching might have failed.");
-    }
-    return this.serviceEndpointUrl;
-  }
-  /**
-   * Helper method to make a generic JSON-RPC POST request.
-   * @param method The RPC method name.
-   * @param params The parameters for the RPC method.
-   * @returns A Promise that resolves to the RPC response.
-   */
-  async _postRpcRequest(method, params) {
-    const endpoint = await this._getServiceEndpoint();
-    const requestId = this.requestIdCounter++;
-    const rpcRequest = {
-      jsonrpc: "2.0",
-      method,
-      params,
-      // Cast because TParams structure varies per method
-      id: requestId
-    };
-    const httpResponse = await this.fetchFn(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Accept": "application/json"
-        // Expect JSON response for non-streaming requests
-      },
-      body: JSON.stringify(rpcRequest)
-    });
-    if (!httpResponse.ok) {
-      let errorBodyText = "(empty or non-JSON response)";
-      try {
-        errorBodyText = await httpResponse.text();
-        const errorJson = JSON.parse(errorBodyText);
-        if (!errorJson.jsonrpc && errorJson.error) {
-          throw new Error(`RPC error for ${method}: ${errorJson.error.message} (Code: ${errorJson.error.code}, HTTP Status: ${httpResponse.status}) Data: ${JSON.stringify(errorJson.error.data)}`);
-        } else if (!errorJson.jsonrpc) {
-          throw new Error(`HTTP error for ${method}! Status: ${httpResponse.status} ${httpResponse.statusText}. Response: ${errorBodyText}`);
-        }
-      } catch (e) {
-        if (e.message.startsWith("RPC error for") || e.message.startsWith("HTTP error for")) throw e;
-        throw new Error(`HTTP error for ${method}! Status: ${httpResponse.status} ${httpResponse.statusText}. Response: ${errorBodyText}`);
-      }
-    }
-    const rpcResponse = await httpResponse.json();
-    if (rpcResponse.id !== requestId) {
-      console.error(`CRITICAL: RPC response ID mismatch for method ${method}. Expected ${requestId}, got ${rpcResponse.id}. This may lead to incorrect response handling.`);
-    }
-    return rpcResponse;
-  }
-  /**
-   * Sends a message to the agent.
-   * The behavior (blocking/non-blocking) and push notification configuration
-   * are specified within the `params.configuration` object.
-   * Optionally, `params.message.contextId` or `params.message.taskId` can be provided.
-   * @param params The parameters for sending the message, including the message content and configuration.
-   * @returns A Promise resolving to SendMessageResponse, which can be a Message, Task, or an error.
-   */
-  async sendMessage(params) {
-    return this._postRpcRequest("message/send", params);
-  }
-  /**
-   * Sends a message to the agent and streams back responses using Server-Sent Events (SSE).
-   * Push notification configuration can be specified in `params.configuration`.
-   * Optionally, `params.message.contextId` or `params.message.taskId` can be provided.
-   * Requires the agent to support streaming (`capabilities.streaming: true` in AgentCard).
-   * @param params The parameters for sending the message.
-   * @returns An AsyncGenerator yielding A2AStreamEventData (Message, Task, TaskStatusUpdateEvent, or TaskArtifactUpdateEvent).
-   * The generator throws an error if streaming is not supported or if an HTTP/SSE error occurs.
-   */
-  async *sendMessageStream(params) {
-    const agentCard = await this.agentCardPromise;
-    if (!agentCard.capabilities?.streaming) {
-      throw new Error("Agent does not support streaming (AgentCard.capabilities.streaming is not true).");
-    }
-    const endpoint = await this._getServiceEndpoint();
-    const clientRequestId = this.requestIdCounter++;
-    const rpcRequest = {
-      // This is the initial JSON-RPC request to establish the stream
-      jsonrpc: "2.0",
-      method: "message/stream",
-      params,
-      id: clientRequestId
-    };
-    const response = await this.fetchFn(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Accept": "text/event-stream"
-        // Crucial for SSE
-      },
-      body: JSON.stringify(rpcRequest)
-    });
-    if (!response.ok) {
-      let errorBody = "";
-      try {
-        errorBody = await response.text();
-        const errorJson = JSON.parse(errorBody);
-        if (errorJson.error) {
-          throw new Error(`HTTP error establishing stream for message/stream: ${response.status} ${response.statusText}. RPC Error: ${errorJson.error.message} (Code: ${errorJson.error.code})`);
-        }
-      } catch (e) {
-        if (e.message.startsWith("HTTP error establishing stream")) throw e;
-        throw new Error(`HTTP error establishing stream for message/stream: ${response.status} ${response.statusText}. Response: ${errorBody || "(empty)"}`);
-      }
-      throw new Error(`HTTP error establishing stream for message/stream: ${response.status} ${response.statusText}`);
-    }
-    if (!response.headers.get("Content-Type")?.startsWith("text/event-stream")) {
-      throw new Error("Invalid response Content-Type for SSE stream. Expected 'text/event-stream'.");
-    }
-    yield* this._parseA2ASseStream(response, clientRequestId);
-  }
-  /**
-   * Sets or updates the push notification configuration for a given task.
-   * Requires the agent to support push notifications (`capabilities.pushNotifications: true` in AgentCard).
-   * @param params Parameters containing the taskId and the TaskPushNotificationConfig.
-   * @returns A Promise resolving to SetTaskPushNotificationConfigResponse.
-   */
-  async setTaskPushNotificationConfig(params) {
-    const agentCard = await this.agentCardPromise;
-    if (!agentCard.capabilities?.pushNotifications) {
-      throw new Error("Agent does not support push notifications (AgentCard.capabilities.pushNotifications is not true).");
-    }
-    return this._postRpcRequest(
-      "tasks/pushNotificationConfig/set",
-      params
-    );
-  }
-  /**
-   * Gets the push notification configuration for a given task.
-   * @param params Parameters containing the taskId.
-   * @returns A Promise resolving to GetTaskPushNotificationConfigResponse.
-   */
-  async getTaskPushNotificationConfig(params) {
-    return this._postRpcRequest(
-      "tasks/pushNotificationConfig/get",
-      params
-    );
-  }
-  /**
-   * Retrieves a task by its ID.
-   * @param params Parameters containing the taskId and optional historyLength.
-   * @returns A Promise resolving to GetTaskResponse, which contains the Task object or an error.
-   */
-  async getTask(params) {
-    return this._postRpcRequest("tasks/get", params);
-  }
-  /**
-   * Cancels a task by its ID.
-   * @param params Parameters containing the taskId.
-   * @returns A Promise resolving to CancelTaskResponse, which contains the updated Task object or an error.
-   */
-  async cancelTask(params) {
-    return this._postRpcRequest("tasks/cancel", params);
-  }
-  /**
-   * Resubscribes to a task's event stream using Server-Sent Events (SSE).
-   * This is used if a previous SSE connection for an active task was broken.
-   * Requires the agent to support streaming (`capabilities.streaming: true` in AgentCard).
-   * @param params Parameters containing the taskId.
-   * @returns An AsyncGenerator yielding A2AStreamEventData (Message, Task, TaskStatusUpdateEvent, or TaskArtifactUpdateEvent).
-   */
-  async *resubscribeTask(params) {
-    const agentCard = await this.agentCardPromise;
-    if (!agentCard.capabilities?.streaming) {
-      throw new Error("Agent does not support streaming (required for tasks/resubscribe).");
-    }
-    const endpoint = await this._getServiceEndpoint();
-    const clientRequestId = this.requestIdCounter++;
-    const rpcRequest = {
-      // Initial JSON-RPC request to establish the stream
-      jsonrpc: "2.0",
-      method: "tasks/resubscribe",
-      params,
-      id: clientRequestId
-    };
-    const response = await this.fetchFn(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Accept": "text/event-stream"
-      },
-      body: JSON.stringify(rpcRequest)
-    });
-    if (!response.ok) {
-      let errorBody = "";
-      try {
-        errorBody = await response.text();
-        const errorJson = JSON.parse(errorBody);
-        if (errorJson.error) {
-          throw new Error(`HTTP error establishing stream for tasks/resubscribe: ${response.status} ${response.statusText}. RPC Error: ${errorJson.error.message} (Code: ${errorJson.error.code})`);
-        }
-      } catch (e) {
-        if (e.message.startsWith("HTTP error establishing stream")) throw e;
-        throw new Error(`HTTP error establishing stream for tasks/resubscribe: ${response.status} ${response.statusText}. Response: ${errorBody || "(empty)"}`);
-      }
-      throw new Error(`HTTP error establishing stream for tasks/resubscribe: ${response.status} ${response.statusText}`);
-    }
-    if (!response.headers.get("Content-Type")?.startsWith("text/event-stream")) {
-      throw new Error("Invalid response Content-Type for SSE stream on resubscribe. Expected 'text/event-stream'.");
-    }
-    yield* this._parseA2ASseStream(response, clientRequestId);
-  }
-  /**
-   * Parses an HTTP response body as an A2A Server-Sent Event stream.
-   * Each 'data' field of an SSE event is expected to be a JSON-RPC 2.0 Response object,
-   * specifically a SendStreamingMessageResponse (or similar structure for resubscribe).
-   * @param response The HTTP Response object whose body is the SSE stream.
-   * @param originalRequestId The ID of the client's JSON-RPC request that initiated this stream.
-   * Used to validate the `id` in the streamed JSON-RPC responses.
-   * @returns An AsyncGenerator yielding the `result` field of each valid JSON-RPC success response from the stream.
-   */
-  async *_parseA2ASseStream(response, originalRequestId) {
-    if (!response.body) {
-      throw new Error("SSE response body is undefined. Cannot read stream.");
-    }
-    const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
-    let buffer = "";
-    let eventDataBuffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          if (eventDataBuffer.trim()) {
-            const result = this._processSseEventData(eventDataBuffer, originalRequestId);
-            yield result;
-          }
-          break;
-        }
-        buffer += value;
-        let lineEndIndex;
-        while ((lineEndIndex = buffer.indexOf("\n")) >= 0) {
-          const line = buffer.substring(0, lineEndIndex).trim();
-          buffer = buffer.substring(lineEndIndex + 1);
-          if (line === "") {
-            if (eventDataBuffer) {
-              const result = this._processSseEventData(eventDataBuffer, originalRequestId);
-              yield result;
-              eventDataBuffer = "";
-            }
-          } else if (line.startsWith("data:")) {
-            eventDataBuffer += line.substring(5).trimStart() + "\n";
-          } else if (line.startsWith(":")) {
-          } else if (line.includes(":")) {
-          }
-        }
-      }
-    } catch (error) {
-      console.error("Error reading or parsing SSE stream:", error.message);
-      throw error;
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  /**
-   * Processes a single SSE event's data string, expecting it to be a JSON-RPC response.
-   * @param jsonData The string content from one or more 'data:' lines of an SSE event.
-   * @param originalRequestId The ID of the client's request that initiated the stream.
-   * @returns The `result` field of the parsed JSON-RPC success response.
-   * @throws Error if data is not valid JSON, not a valid JSON-RPC response, an error response, or ID mismatch.
-   */
-  _processSseEventData(jsonData, originalRequestId) {
-    if (!jsonData.trim()) {
-      throw new Error("Attempted to process empty SSE event data.");
-    }
-    try {
-      const sseJsonRpcResponse = JSON.parse(jsonData.replace(/\n$/, ""));
-      const a2aStreamResponse = sseJsonRpcResponse;
-      if (a2aStreamResponse.id !== originalRequestId) {
-        console.warn(`SSE Event's JSON-RPC response ID mismatch. Client request ID: ${originalRequestId}, event response ID: ${a2aStreamResponse.id}.`);
-      }
-      if (this.isErrorResponse(a2aStreamResponse)) {
-        const err = a2aStreamResponse.error;
-        throw new Error(`SSE event contained an error: ${err.message} (Code: ${err.code}) Data: ${JSON.stringify(err.data)}`);
-      }
-      if (!("result" in a2aStreamResponse) || typeof a2aStreamResponse.result === "undefined") {
-        throw new Error(`SSE event JSON-RPC response is missing 'result' field. Data: ${jsonData}`);
-      }
-      const successResponse = a2aStreamResponse;
-      return successResponse.result;
-    } catch (e) {
-      if (e.message.startsWith("SSE event contained an error") || e.message.startsWith("SSE event JSON-RPC response is missing 'result' field")) {
-        throw e;
-      }
-      console.error("Failed to parse SSE event data string or unexpected JSON-RPC structure:", jsonData, e);
-      throw new Error(`Failed to parse SSE event data: "${jsonData.substring(0, 100)}...". Original error: ${e.message}`);
-    }
-  }
-  isErrorResponse(response) {
-    return "error" in response;
-  }
-};
-
-// ../core/src/types.ts
-var DistriError = class extends Error {
-  constructor(message, code, details) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = "DistriError";
-  }
-};
-var A2AProtocolError = class extends DistriError {
-  constructor(message, details) {
-    super(message, "A2A_PROTOCOL_ERROR", details);
-    this.name = "A2AProtocolError";
-  }
-};
-var ApiError = class extends DistriError {
-  constructor(message, statusCode, details) {
-    super(message, "API_ERROR", details);
-    this.statusCode = statusCode;
-    this.name = "ApiError";
-  }
-};
-function isDistriMessage(event) {
-  return "id" in event && "role" in event && "parts" in event;
-}
-
-// ../core/src/encoder.ts
-function convertA2AMessageToDistri(a2aMessage) {
-  const role = a2aMessage.role === "agent" ? "assistant" : "user";
-  return {
-    id: a2aMessage.messageId,
-    role,
-    parts: a2aMessage.parts.map(convertA2APartToDistri),
-    created_at: a2aMessage.createdAt
-  };
-}
-function decodeA2AStreamEvent(event) {
-  if (event.kind === "message") {
-    return convertA2AMessageToDistri(event);
-  } else if (event.kind === "status-update") {
-    return event;
-  } else if (event.kind === "artifact-update") {
-    return event;
-  }
-  return event;
-}
-function convertA2APartToDistri(a2aPart) {
-  switch (a2aPart.kind) {
-    case "text":
-      return { type: "text", text: a2aPart.text };
-    case "file":
-      if ("uri" in a2aPart.file) {
-        return { type: "image_url", image: { mime_type: a2aPart.file.mimeType, url: a2aPart.file.uri } };
-      } else {
-        return { type: "image_bytes", image: { mime_type: a2aPart.file.mimeType, data: a2aPart.file.bytes } };
-      }
-    case "data":
-      switch (a2aPart.data.part_type) {
-        case "tool_call":
-          return { type: "tool_call", tool_call: 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 };
-        default:
-          return { type: "data", data: a2aPart.data };
-      }
-    default:
-      return { type: "text", text: JSON.stringify(a2aPart) };
-  }
-}
-function convertDistriMessageToA2A(distriMessage, context) {
-  let role;
-  switch (distriMessage.role) {
-    case "assistant":
-      role = "agent";
-      break;
-    case "user":
-      role = "user";
-      break;
-    case "system":
-    case "tool":
-      role = "user";
-      break;
-    default:
-      role = "user";
-  }
-  return {
-    messageId: distriMessage.id,
-    role,
-    parts: distriMessage.parts.map(convertDistriPartToA2A),
-    kind: "message",
-    contextId: context.thread_id,
-    taskId: context.run_id
-  };
-}
-function convertDistriPartToA2A(distriPart) {
-  switch (distriPart.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 } };
-    case "tool_call":
-      return { kind: "data", data: { part_type: "tool_call", tool_call: distriPart.tool_call } };
-    case "tool_result":
-      let val = {
-        kind: "data",
-        data: {
-          tool_call_id: distriPart.tool_result.tool_call_id,
-          result: distriPart.tool_result.result,
-          part_type: "tool_result"
-        }
-      };
-      console.log("<> val", val);
-      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 };
-  }
-}
-
-// ../core/src/distri-client.ts
-var DistriClient = class {
-  constructor(config) {
-    this.agentClients = /* @__PURE__ */ new Map();
-    this.config = {
-      baseUrl: config.baseUrl.replace(/\/$/, ""),
-      apiVersion: config.apiVersion || "v1",
-      timeout: config.timeout || 3e4,
-      retryAttempts: config.retryAttempts || 3,
-      retryDelay: config.retryDelay || 1e3,
-      debug: config.debug || false,
-      headers: config.headers || {},
-      interceptor: config.interceptor || ((init) => Promise.resolve(init))
-    };
-    this.debug("DistriClient initialized with config:", this.config);
-  }
-  /**
-   * Get all available agents from the Distri server
-   */
-  async getAgents() {
-    try {
-      const response = await this.fetch(`/agents`, {
-        headers: {
-          ...this.config.headers
-        }
-      });
-      if (!response.ok) {
-        throw new ApiError(`Failed to fetch agents: ${response.statusText}`, response.status);
-      }
-      const agents = await response.json();
-      agents.forEach((agent) => {
-        if (!agent.id) {
-          agent.id = agent.name;
-        }
-      });
-      return agents;
-    } catch (error) {
-      if (error instanceof ApiError) throw error;
-      throw new DistriError("Failed to fetch agents", "FETCH_ERROR", error);
-    }
-  }
-  /**
-   * Get specific agent by ID
-   */
-  async getAgent(agentId) {
-    try {
-      const response = await this.fetch(`/agents/${agentId}`, {
-        headers: {
-          ...this.config.headers
-        }
-      });
-      if (!response.ok) {
-        if (response.status === 404) {
-          throw new ApiError(`Agent not found: ${agentId}`, 404);
-        }
-        throw new ApiError(`Failed to fetch agent: ${response.statusText}`, response.status);
-      }
-      const agent = await response.json();
-      if (!agent.id) {
-        agent.id = agentId;
-      }
-      return agent;
-    } catch (error) {
-      if (error instanceof ApiError) throw error;
-      throw new DistriError(`Failed to fetch agent ${agentId}`, "FETCH_ERROR", error);
-    }
-  }
-  /**
-   * Get or create A2AClient for an agent
-   */
-  getA2AClient(agentId) {
-    if (!this.agentClients.has(agentId)) {
-      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}`);
-    }
-    return this.agentClients.get(agentId);
-  }
-  /**
-   * Send a message to an agent
-   */
-  async sendMessage(agentId, params) {
-    try {
-      const client = this.getA2AClient(agentId);
-      const response = await client.sendMessage(params);
-      if ("error" in response && response.error) {
-        throw new A2AProtocolError(response.error.message, response.error);
-      }
-      if ("result" in response) {
-        const result = response.result;
-        this.debug(`Message sent to ${agentId}, got ${result.kind}:`, result);
-        return result;
-      }
-      throw new DistriError("Invalid response format", "INVALID_RESPONSE");
-    } catch (error) {
-      if (error instanceof A2AProtocolError || error instanceof DistriError) throw error;
-      throw new DistriError(`Failed to send message to agent ${agentId}`, "SEND_MESSAGE_ERROR", error);
-    }
-  }
-  /**
-   * Send a streaming message to an agent
-   */
-  async *sendMessageStream(agentId, params) {
-    try {
-      const client = this.getA2AClient(agentId);
-      yield* await client.sendMessageStream(params);
-    } catch (error) {
-      throw new DistriError(`Failed to stream message to agent ${agentId}`, "STREAM_MESSAGE_ERROR", error);
-    }
-  }
-  /**
-   * Get task details
-   */
-  async getTask(agentId, taskId) {
-    try {
-      const client = this.getA2AClient(agentId);
-      const response = await client.getTask({ id: taskId });
-      if ("error" in response && response.error) {
-        throw new A2AProtocolError(response.error.message, response.error);
-      }
-      if ("result" in response) {
-        const result = response.result;
-        this.debug(`Got task ${taskId} from ${agentId}:`, result);
-        return result;
-      }
-      throw new DistriError("Invalid response format", "INVALID_RESPONSE");
-    } catch (error) {
-      if (error instanceof A2AProtocolError || error instanceof DistriError) throw error;
-      throw new DistriError(`Failed to get task ${taskId} from agent ${agentId}`, "GET_TASK_ERROR", error);
-    }
-  }
-  /**
-   * Cancel a task
-   */
-  async cancelTask(agentId, taskId) {
-    try {
-      const client = this.getA2AClient(agentId);
-      await client.cancelTask({ id: taskId });
-      this.debug(`Cancelled task ${taskId} on agent ${agentId}`);
-    } catch (error) {
-      throw new DistriError(`Failed to cancel task ${taskId} on agent ${agentId}`, "CANCEL_TASK_ERROR", error);
-    }
-  }
-  /**
-   * Get threads from Distri server
-   */
-  async getThreads() {
-    try {
-      const response = await this.fetch(`/threads`);
-      if (!response.ok) {
-        throw new ApiError(`Failed to fetch threads: ${response.statusText}`, response.status);
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof ApiError) throw error;
-      throw new DistriError("Failed to fetch threads", "FETCH_ERROR", error);
-    }
-  }
-  async getThread(threadId) {
-    try {
-      const response = await this.fetch(`/threads/${threadId}`);
-      if (!response.ok) {
-        throw new ApiError(`Failed to fetch thread: ${response.statusText}`, response.status);
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof ApiError) throw error;
-      throw new DistriError(`Failed to fetch thread ${threadId}`, "FETCH_ERROR", error);
-    }
-  }
-  /**
-   * Get thread messages
-   */
-  async getThreadMessages(threadId) {
-    try {
-      const response = await this.fetch(`/threads/${threadId}/messages`);
-      if (!response.ok) {
-        if (response.status === 404) {
-          return [];
-        }
-        throw new ApiError(`Failed to fetch thread messages: ${response.statusText}`, response.status);
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof ApiError) throw error;
-      throw new DistriError(`Failed to fetch messages for thread ${threadId}`, "FETCH_ERROR", error);
-    }
-  }
-  /**
-   * Get messages from a thread as DistriMessage format
-   */
-  async getThreadMessagesAsDistri(threadId) {
-    const messages = await this.getThreadMessages(threadId);
-    return messages.map(convertA2AMessageToDistri);
-  }
-  /**
-   * Send a DistriMessage to a thread
-   */
-  async sendDistriMessage(threadId, message, context) {
-    const a2aMessage = convertDistriMessageToA2A(message, context);
-    const params = {
-      message: a2aMessage,
-      metadata: context.metadata
-    };
-    await this.sendMessage(threadId, params);
-  }
-  /**
-   * Get the base URL for making direct requests
-   */
-  get baseUrl() {
-    return this.config.baseUrl;
-  }
-  /**
-   * Enhanced fetch with retry logic
-   */
-  async fetchAbsolute(url, initialInit) {
-    const init = await this.config.interceptor(initialInit);
-    let lastError;
-    for (let attempt = 0; attempt <= this.config.retryAttempts; attempt++) {
-      try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-        const response = await fetch(url, {
-          ...init,
-          signal: controller.signal,
-          headers: {
-            ...this.config.headers,
-            ...init?.headers
-          }
-        });
-        clearTimeout(timeoutId);
-        return response;
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        if (attempt < this.config.retryAttempts) {
-          this.debug(`Request failed (attempt ${attempt + 1}), retrying in ${this.config.retryDelay}ms...`);
-          await this.delay(this.config.retryDelay);
-        }
-      }
-    }
-    throw lastError;
-  }
-  /**
-   * Enhanced fetch with retry logic
-   */
-  async fetch(input, initialInit) {
-    const url = `${this.config.baseUrl}${input}`;
-    return this.fetchAbsolute(url, initialInit);
-  }
-  /**
-   * Delay utility
-   */
-  delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  /**
-   * Debug logging
-   */
-  debug(...args) {
-    if (this.config.debug) {
-      console.log("[DistriClient]", ...args);
-    }
-  }
-  /**
-   * Helper method to create A2A messages
-   */
-  static initMessage(parts, role = "user", message) {
-    return {
-      messageId: message.messageId || uuidv4(),
-      taskId: message.taskId || uuidv4(),
-      contextId: message.contextId,
-      role,
-      parts: Array.isArray(parts) ? parts : [{ kind: "text", text: parts.trim() }],
-      ...message,
-      kind: "message"
-    };
-  }
-  /**
-   * Create a DistriMessage instance
-   */
-  static initDistriMessage(role, parts, id, created_at) {
-    return {
-      id: id || uuidv4(),
-      role,
-      parts,
-      created_at
-    };
-  }
-  /**
-   * Helper method to create message send parameters
-   */
-  static initMessageParams(message, configuration, metadata) {
-    return {
-      message,
-      configuration: {
-        acceptedOutputModes: ["text/plain"],
-        blocking: false,
-        // Default to non-blocking for streaming
-        ...configuration
-      },
-      metadata
-    };
-  }
-  /**
-   * Create MessageSendParams from a DistriMessage using InvokeContext
-   */
-  static initDistriMessageParams(message, context) {
-    const a2aMessage = convertDistriMessageToA2A(message, context);
-    return {
-      message: a2aMessage,
-      metadata: context.metadata
-    };
-  }
-};
-function uuidv4() {
-  if (typeof crypto?.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  const array = new Uint8Array(16);
-  crypto.getRandomValues(array);
-  array[6] = array[6] & 15 | 64;
-  array[8] = array[8] & 63 | 128;
-  return [...array].map(
-    (b, i) => ([4, 6, 8, 10].includes(i) ? "-" : "") + b.toString(16).padStart(2, "0")
-  ).join("");
-}
-
-// ../core/src/agent.ts
-var Agent = class _Agent {
-  constructor(agentDefinition, client) {
-    this.tools = /* @__PURE__ */ new Map();
-    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
-   */
-  get id() {
-    return this.agentDefinition.id;
-  }
-  get name() {
-    return this.agentDefinition.name;
-  }
-  get description() {
-    return this.agentDefinition.description;
-  }
-  get iconUrl() {
-    return this.agentDefinition.icon_url;
-  }
-  /**
-   * Fetch messages for a thread (public method for useChat)
-   */
-  async getThreadMessages(threadId) {
-    return this.client.getThreadMessages(threadId);
-  }
-  /**
-   * Direct (non-streaming) invoke
-   */
-  async invoke(params) {
-    const enhancedParams = this.enhanceParamsWithTools(params);
-    console.log("enhancedParams", enhancedParams);
-    return await this.client.sendMessage(this.agentDefinition.id, enhancedParams);
-  }
-  /**
-   * Streaming invoke
-   */
-  async invokeStream(params) {
-    const enhancedParams = this.enhanceParamsWithTools(params);
-    console.log("enhancedParams", enhancedParams);
-    const a2aStream = this.client.sendMessageStream(this.agentDefinition.id, enhancedParams);
-    return async function* () {
-      for await (const event of a2aStream) {
-        if (event.kind === "message") {
-          yield convertA2AMessageToDistri(event);
-        } else if (event.kind === "status-update") {
-          yield event;
-        } else if (event.kind === "artifact-update") {
-          yield event;
-        } else {
-          yield event;
-        }
-      }
-    }();
-  }
-  /**
-   * Enhance message params with tool definitions
-   */
-  enhanceParamsWithTools(params) {
-    const tools = this.getTools();
-    return {
-      ...params,
-      metadata: {
-        ...params.metadata,
-        tools: tools.map((tool) => ({
-          name: tool.name,
-          description: tool.description,
-          input_schema: tool.input_schema
-        }))
-      }
-    };
-  }
-  /**
-   * Create an agent instance from an agent ID
-   */
-  static async create(agentId, client) {
-    const agentDefinition = await client.getAgent(agentId);
-    return new _Agent(agentDefinition, client);
-  }
-  /**
-   * List all available agents
-   */
-  static async list(client) {
-    const agentDefinitions = await client.getAgents();
-    return agentDefinitions.map((def) => new _Agent(def, client));
-  }
-};
+import { DistriClient } from "@distri/core";
 
 // src/components/ThemeProvider.tsx
 import { createContext, useContext, useEffect, useState } from "react";
@@ -1059,6 +110,9 @@ function useDistri() {
 
 // src/useAgent.ts
 import React2, { useState as useState3, useCallback, useRef } from "react";
+import {
+  Agent
+} from "@distri/core";
 function useAgent({
   agentId,
   autoCreateAgent = true
@@ -1178,6 +232,63 @@ function useAgents() {
 
 // src/useChat.ts
 import { useState as useState7, useCallback as useCallback4, useEffect as useEffect6, useRef as useRef3 } from "react";
+import { DistriClient as DistriClient2 } from "@distri/core";
+import {
+  convertDistriMessageToA2A
+} from "@distri/core";
+
+// ../core/src/encoder.ts
+function convertA2AMessageToDistri(a2aMessage) {
+  const role = a2aMessage.role === "agent" ? "assistant" : "user";
+  return {
+    id: a2aMessage.messageId,
+    role,
+    parts: a2aMessage.parts.map(convertA2APartToDistri),
+    created_at: a2aMessage.createdAt
+  };
+}
+function decodeA2AStreamEvent(event) {
+  if (event.kind === "message") {
+    return convertA2AMessageToDistri(event);
+  } else if (event.kind === "status-update") {
+    return event;
+  } else if (event.kind === "artifact-update") {
+    return event;
+  }
+  return event;
+}
+function convertA2APartToDistri(a2aPart) {
+  switch (a2aPart.kind) {
+    case "text":
+      return { type: "text", text: a2aPart.text };
+    case "file":
+      if ("uri" in a2aPart.file) {
+        return { type: "image_url", image: { mime_type: a2aPart.file.mimeType, url: a2aPart.file.uri } };
+      } else {
+        return { type: "image_bytes", image: { mime_type: a2aPart.file.mimeType, data: a2aPart.file.bytes } };
+      }
+    case "data":
+      switch (a2aPart.data.part_type) {
+        case "tool_call":
+          return { type: "tool_call", tool_call: 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 };
+        default:
+          return { type: "data", data: a2aPart.data };
+      }
+    default:
+      return { type: "text", text: JSON.stringify(a2aPart) };
+  }
+}
+
+// ../core/src/types.ts
+function isDistriMessage(event) {
+  return "id" in event && "role" in event && "parts" in event;
+}
 
 // src/hooks/registerTools.tsx
 import { useEffect as useEffect5, useRef as useRef2 } from "react";
@@ -1528,7 +639,7 @@ function useChat({
   threadId,
   onMessage,
   onError,
-  metadata,
+  getMetadata,
   onMessagesUpdate,
   agent,
   tools
@@ -1541,8 +652,8 @@ function useChat({
   const createInvokeContext = useCallback4(() => ({
     thread_id: threadId,
     run_id: void 0,
-    metadata
-  }), [threadId, metadata]);
+    getMetadata
+  }), [threadId, getMetadata]);
   registerTools({ agent, tools });
   const toolStateHandler = useToolCallState({
     agent,
@@ -1647,13 +758,14 @@ function useChat({
     abortControllerRef.current = new AbortController();
     try {
       const parts = typeof content === "string" ? [{ type: "text", text: content }] : content;
-      const distriMessage = DistriClient.initDistriMessage("user", parts);
+      const distriMessage = DistriClient2.initDistriMessage("user", parts);
       const context = createInvokeContext();
       const a2aMessage = convertDistriMessageToA2A(distriMessage, context);
       setMessages((prev) => [...prev, distriMessage]);
+      const contextMetadata = await getMetadata?.() || {};
       const stream = await agent.invokeStream({
         message: a2aMessage,
-        metadata: context.metadata
+        metadata: contextMetadata
       });
       for await (const event of stream) {
         if (abortControllerRef.current?.signal.aborted) {
@@ -1685,13 +797,14 @@ function useChat({
     abortControllerRef.current = new AbortController();
     try {
       const parts = typeof content === "string" ? [{ type: "text", text: content }] : content;
-      const distriMessage = DistriClient.initDistriMessage(role, parts);
+      const distriMessage = DistriClient2.initDistriMessage(role, parts);
       const context = createInvokeContext();
       const a2aMessage = convertDistriMessageToA2A(distriMessage, context);
       setMessages((prev) => [...prev, distriMessage]);
+      const contextMetadata = await getMetadata?.() || {};
       const stream = await agent.invokeStream({
         message: a2aMessage,
-        metadata: context.metadata
+        metadata: { ...contextMetadata }
       });
       for await (const event of stream) {
         if (abortControllerRef.current?.signal.aborted) {
@@ -1757,6 +870,9 @@ function useThreads() {
   const [error, setError] = useState8(null);
   const fetchThreads = useCallback5(async () => {
     if (!client) {
+      console.error("[useThreads] Client not available");
+      setError(new Error("Client not available"));
+      setLoading(false);
       return;
     }
     try {
@@ -1788,7 +904,7 @@ function useThreads() {
       throw new Error("Client not available");
     }
     try {
-      const response = await fetch(`${client.baseUrl}/api/v1/threads/${threadId}`, {
+      const response = await fetch(`${client.baseUrl}/threads/${threadId}`, {
         method: "DELETE"
       });
       if (!response.ok) {
@@ -1805,7 +921,7 @@ function useThreads() {
       return;
     }
     try {
-      const response = await fetch(`${client.baseUrl}/api/v1/threads/${threadId}`);
+      const response = await fetch(`${client.baseUrl}/threads/${threadId}`);
       if (response.ok) {
         const updatedThread = await response.json();
         setThreads((prev) => {
@@ -1864,6 +980,7 @@ import { useState as useState13, useCallback as useCallback8, useEffect as useEf
 // src/components/EmbeddableChat.tsx
 import { useState as useState10, useRef as useRef5, useEffect as useEffect9, useMemo as useMemo2 } from "react";
 import { MessageSquare } from "lucide-react";
+import { isDistriMessage as isDistriMessage4 } from "@distri/core";
 
 // src/components/Components.tsx
 import React8, { useState as useState9 } from "react";
@@ -1901,6 +1018,7 @@ var useChatConfig = () => {
 };
 
 // src/components/MessageRenderer.tsx
+import { isDistriMessage as isDistriMessage2 } from "@distri/core";
 import { jsx as jsx8, jsxs as jsxs2 } from "react/jsx-runtime";
 var CodeBlock = ({ language, children, inline = false }) => {
   const [copied, setCopied] = React7.useState(false);
@@ -2119,7 +1237,7 @@ var MessageRenderer = ({
       theme: "chatgpt"
     };
   }
-  if (message && isDistriMessage(message)) {
+  if (message && isDistriMessage2(message)) {
     const hasToolCalls = message.parts.some((part) => part.type === "tool_call");
     const filteredParts = hasToolCalls ? message.parts.filter((part) => part.type !== "tool_result") : message.parts;
     const groupedParts = [];
@@ -2528,8 +1646,9 @@ var DebugMessage = ({
 };
 
 // src/utils/messageUtils.ts
+import { isDistriMessage as isDistriMessage3 } from "@distri/core";
 var extractTextFromMessage = (message) => {
-  if (isDistriMessage(message)) {
+  if (isDistriMessage3(message)) {
     if (!message?.parts || !Array.isArray(message.parts)) {
       return "";
     }
@@ -2541,7 +1660,7 @@ var extractTextFromMessage = (message) => {
 };
 var shouldDisplayMessage = (message, showDebugMessages = false) => {
   if (!message) return false;
-  if (isDistriMessage(message)) {
+  if (isDistriMessage3(message)) {
     if (message.role === "user") {
       const textContent2 = extractTextFromMessage(message);
       return textContent2.trim().length > 0;
@@ -2561,7 +1680,6 @@ import * as SelectPrimitive from "@radix-ui/react-select";
 import { Check as Check2, ChevronDown as ChevronDown2, ChevronUp } from "lucide-react";
 import { jsx as jsx10, jsxs as jsxs4 } from "react/jsx-runtime";
 var Select = SelectPrimitive.Root;
-var SelectGroup = SelectPrimitive.Group;
 var SelectValue = SelectPrimitive.Value;
 var SelectTrigger = React9.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs4(
   SelectPrimitive.Trigger,
@@ -2785,6 +1903,20 @@ var ChatInput = ({
   ] }) }) });
 };
 
+// ../core/src/distri-client.ts
+function uuidv4() {
+  if (typeof crypto?.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const array = new Uint8Array(16);
+  crypto.getRandomValues(array);
+  array[6] = array[6] & 15 | 64;
+  array[8] = array[8] & 63 | 128;
+  return [...array].map(
+    (b, i) => ([4, 6, 8, 10].includes(i) ? "-" : "") + b.toString(16).padStart(2, "0")
+  ).join("");
+}
+
 // src/components/EmbeddableChat.tsx
 import { jsx as jsx14, jsxs as jsxs7 } from "react/jsx-runtime";
 var EmbeddableChat = ({
@@ -2792,7 +1924,7 @@ var EmbeddableChat = ({
   agent,
   className = "",
   style = {},
-  metadata,
+  getMetadata,
   tools,
   availableAgents = [],
   UserMessageComponent = UserMessage,
@@ -2822,7 +1954,7 @@ var EmbeddableChat = ({
     threadId,
     agent: agent || void 0,
     tools,
-    metadata,
+    getMetadata,
     onMessagesUpdate
   });
   useEffect9(() => {
@@ -2855,7 +1987,7 @@ var EmbeddableChat = ({
       const messageContent = extractTextFromMessage(message);
       const key = `message-${index}`;
       const timestamp = message.created_at ? new Date(message.created_at) : void 0;
-      if (isDistriMessage(message)) {
+      if (isDistriMessage4(message)) {
         switch (getMessageType(message)) {
           case "user":
             return /* @__PURE__ */ jsx14(
@@ -3892,17 +3024,11 @@ var badgeVariants = cva3(
     }
   }
 );
-function Badge({ className, variant, ...props }) {
-  return /* @__PURE__ */ jsx24("div", { className: cn(badgeVariants({ variant }), className), ...props });
-}
 
 // src/components/ui/dialog.tsx
 import * as React19 from "react";
 import { jsx as jsx25, jsxs as jsxs12 } from "react/jsx-runtime";
 var Dialog = React19.createContext({});
-var DialogRoot = ({ open, onOpenChange, children }) => {
-  return /* @__PURE__ */ jsx25(Dialog.Provider, { value: { open, onOpenChange }, children });
-};
 var DialogTrigger = React19.forwardRef(({ className, children, ...props }, ref) => {
   const context = React19.useContext(Dialog);
   return /* @__PURE__ */ jsx25(
@@ -4342,7 +3468,7 @@ function AppSidebar({
 import { jsx as jsx29, jsxs as jsxs15 } from "react/jsx-runtime";
 var FullChat = ({
   agentId: initialAgentId,
-  metadata,
+  getMetadata,
   className = "",
   UserMessageComponent,
   AssistantMessageComponent,
@@ -4366,7 +3492,8 @@ var FullChat = ({
   const currentThread = threads.find((t) => t.id === selectedThreadId);
   const { messages } = useChat({
     threadId: selectedThreadId,
-    agent: agent || void 0
+    agent: agent || void 0,
+    getMetadata
   });
   const threadHasStarted = messages.length > 0;
   useEffect11(() => {
@@ -4433,7 +3560,7 @@ var FullChat = ({
         threadId: selectedThreadId,
         showAgentSelector: false,
         agent,
-        metadata,
+        getMetadata,
         height: "calc(100vh - 4rem)",
         availableAgents,
         UserMessageComponent,
@@ -4521,76 +3648,16 @@ export {
   ApprovalToolCall,
   AssistantMessage,
   AssistantWithToolCalls,
-  Badge,
-  Button,
-  Card,
-  CardContent,
-  CardDescription,
-  CardFooter,
-  CardHeader,
-  CardTitle,
   ChatInput,
   DebugMessage,
-  DialogRoot as Dialog,
-  DialogContent,
-  DialogHeader,
-  DialogTitle,
-  DialogTrigger,
   DistriProvider,
   EmbeddableChat,
   FullChat_default as FullChat,
-  Input,
   PlanMessage,
-  Select,
-  SelectContent,
-  SelectGroup,
-  SelectItem,
-  SelectLabel,
-  SelectScrollDownButton,
-  SelectScrollUpButton,
-  SelectSeparator,
-  SelectTrigger,
-  SelectValue,
-  Separator2 as Separator,
-  Sheet,
-  SheetContent,
-  SheetDescription,
-  SheetFooter,
-  SheetHeader,
-  SheetTitle,
-  Sidebar,
-  SidebarContent,
-  SidebarFooter,
-  SidebarGroup,
-  SidebarGroupAction,
-  SidebarGroupContent,
-  SidebarGroupLabel,
-  SidebarHeader,
-  SidebarInset,
-  SidebarMenu,
-  SidebarMenuAction,
-  SidebarMenuBadge,
-  SidebarMenuButton,
-  SidebarMenuItem,
-  SidebarMenuSkeleton,
-  SidebarMenuSub,
-  SidebarMenuSubButton,
-  SidebarMenuSubItem,
-  SidebarProvider,
-  SidebarRail,
-  SidebarSeparator,
-  SidebarTrigger,
-  Skeleton,
-  Textarea,
   ThemeProvider,
   ThemeToggle,
   ToastToolCall,
-  Tooltip,
-  TooltipContent,
-  TooltipProvider,
-  TooltipTrigger,
   UserMessage,
-  cn,
   extractTextFromMessage,
   registerTools,
   shouldDisplayMessage,
@@ -4598,7 +3665,6 @@ export {
   useAgents,
   useChat,
   useDistri,
-  useSidebar,
   useTheme,
   useThreads,
   useToolCallState