@ideascol/agents-generator-sdk 0.0.3-rc5 → 0.0.4-rc1

package/dist/bin/cli.js

@@ -598,7 +598,7 @@ var OpenAPI;
 var init_OpenAPI = __esm(() => {
   OpenAPI = {
     BASE: "",
-    VERSION: "main-3e9b5b5b62a0af3d34e07f2a82593d3a5b0543da",
+    VERSION: "main-6851016f7efc01be9f722f975c072d2cd49e46e7",
     WITH_CREDENTIALS: false,
     CREDENTIALS: "include",
     TOKEN: undefined,
@@ -1135,11 +1135,229 @@ var init_agentsCommand = __esm(() => {
   agentsCommand_default = commandAgents;
 });
 
+// src/lib/index.ts
+class AgentClient {
+  agent;
+  conversations;
+  mcpServers;
+  root;
+  ApiError;
+  CancelError;
+  CancelablePromise;
+  OpenAPI;
+  conversationsStream;
+  constructor({
+    apiUrl,
+    apiToken
+  }) {
+    OpenAPI.BASE = apiUrl;
+    OpenAPI.TOKEN = apiToken;
+    OpenAPI.HEADERS = {
+      "Api-Version": OpenAPI.VERSION
+    };
+    this.agent = AgentService;
+    this.conversations = ConversationsService;
+    this.mcpServers = McpServersService;
+    this.root = RootService;
+    this.conversationsStream = ConversationsServiceStream;
+    this.ApiError = ApiError;
+    this.CancelError = CancelError;
+    this.CancelablePromise = CancelablePromise;
+    this.OpenAPI = OpenAPI;
+  }
+  sendMessageWithStreaming(conversationId, requestBody, callbacks) {
+    return ConversationsServiceStream.addMessageConversationsConversationIdMessagesPostStream(conversationId, requestBody, callbacks);
+  }
+  sendMessage(conversationId, requestBody) {
+    return ConversationsServiceStream.addMessageConversationsConversationIdMessagesPost(conversationId, requestBody);
+  }
+}
+var ConversationsServiceStream;
+var init_lib = __esm(() => {
+  init_agents_generator();
+  ConversationsServiceStream = class ConversationsServiceStream extends ConversationsService {
+    constructor() {
+      super();
+    }
+    static addMessageConversationsConversationIdMessagesPostStream(conversationId, requestBody, callbacks) {
+      const apiUrl = OpenAPI.BASE;
+      const url = `${apiUrl}/conversations/${conversationId}/messages`;
+      const controller = new AbortController;
+      const headers = new Headers({
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      });
+      if (OpenAPI.TOKEN) {
+        if (typeof OpenAPI.TOKEN === "function") {
+          OpenAPI.TOKEN({ url, method: "POST", body: requestBody }).then((token) => {
+            headers.append("Authorization", `Bearer ${token}`);
+          }).catch((error) => {
+            if (callbacks.onError) {
+              callbacks.onError(new Error(`Failed to get auth token: ${error.message}`));
+            }
+          });
+        } else {
+          headers.append("Authorization", `Bearer ${OpenAPI.TOKEN}`);
+        }
+      }
+      fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody),
+        credentials: OpenAPI.WITH_CREDENTIALS ? OpenAPI.CREDENTIALS : undefined,
+        signal: controller.signal
+      }).then((response) => {
+        if (!response.ok) {
+          throw new Error(`Error: ${response.status} - ${response.statusText}`);
+        }
+        if (!response.body) {
+          throw new Error("ReadableStream not supported");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        let fullMessage = "";
+        let isDirectTextMode = false;
+        function processStream() {
+          reader.read().then(({ done, value }) => {
+            if (done) {
+              console.log("Stream completado");
+              if (buffer.length > 0) {
+                console.log("Procesando buffer final:", buffer);
+                if (isDirectTextMode) {
+                  fullMessage += buffer;
+                  if (callbacks.onMessage) {
+                    console.log("Actualizando mensaje final (texto directo):", fullMessage);
+                    callbacks.onMessage(fullMessage);
+                  }
+                } else {
+                  let eventEnd2 = buffer.indexOf(`
+
+`);
+                  if (eventEnd2 > -1) {
+                    const eventData = buffer.substring(0, eventEnd2);
+                    buffer = buffer.substring(eventEnd2 + 2);
+                    if (eventData.startsWith("data: ")) {
+                      try {
+                        const jsonStr = eventData.substring(6);
+                        const data = JSON.parse(jsonStr);
+                        if (data.type === "message" && data.content && callbacks.onMessage) {
+                          fullMessage = data.content;
+                          callbacks.onMessage(fullMessage);
+                        } else if (data.type === "done" && data.message_id && callbacks.onDone) {
+                          callbacks.onDone(data.message_id);
+                        }
+                      } catch (e) {
+                        fullMessage += eventData.substring(6);
+                        if (callbacks.onMessage) {
+                          callbacks.onMessage(fullMessage);
+                        }
+                      }
+                    }
+                  }
+                  if (buffer.length > 0) {
+                    fullMessage += buffer;
+                    if (callbacks.onMessage) {
+                      console.log("Actualizando mensaje final (buffer restante):", fullMessage);
+                      callbacks.onMessage(fullMessage);
+                    }
+                  }
+                }
+              }
+              if (callbacks.onDone) {
+                callbacks.onDone("stream-completed");
+              }
+              return;
+            }
+            const chunk = decoder.decode(value, { stream: true });
+            buffer += chunk;
+            console.log("Chunk recibido:", chunk);
+            let eventEnd = buffer.indexOf(`
+
+`);
+            if (buffer.length > 50 && eventEnd === -1 && !isDirectTextMode) {
+              isDirectTextMode = true;
+              console.log("Detectado modo texto directo");
+            }
+            if (isDirectTextMode) {
+              fullMessage += chunk;
+              if (callbacks.onMessage) {
+                console.log("Actualizando con texto directo:", fullMessage);
+                callbacks.onMessage(fullMessage);
+              }
+            } else {
+              while (eventEnd > -1) {
+                const eventData = buffer.substring(0, eventEnd);
+                buffer = buffer.substring(eventEnd + 2);
+                if (eventData.startsWith("data: ")) {
+                  const jsonStr = eventData.substring(6);
+                  try {
+                    const data = JSON.parse(jsonStr);
+                    console.log("Evento SSE recibido:", data);
+                    if (data.type === "message" && data.content && callbacks.onMessage) {
+                      fullMessage = data.content;
+                      callbacks.onMessage(fullMessage);
+                    } else if (data.type === "done" && data.message_id && callbacks.onDone) {
+                      callbacks.onDone(data.message_id);
+                    }
+                  } catch (e) {
+                    console.error("Error al parsear JSON del evento:", e);
+                    if (eventData.startsWith("data: ")) {
+                      const directContent = eventData.substring(6);
+                      fullMessage += directContent;
+                      if (callbacks.onMessage) {
+                        console.log("Actualizando con texto SSE simple:", fullMessage);
+                        callbacks.onMessage(fullMessage);
+                      }
+                    } else {
+                      if (callbacks.onError) {
+                        callbacks.onError(new Error(`Error parsing SSE event: ${e}`));
+                      }
+                    }
+                  }
+                } else {
+                  fullMessage += eventData;
+                  if (callbacks.onMessage) {
+                    console.log("Actualizando con evento no reconocido:", fullMessage);
+                    callbacks.onMessage(fullMessage);
+                  }
+                }
+                eventEnd = buffer.indexOf(`
+
+`);
+              }
+              if (buffer.length > 20 && !buffer.includes("data: ")) {
+                fullMessage += buffer;
+                buffer = "";
+                if (callbacks.onMessage) {
+                  console.log("Actualizando con buffer residual:", fullMessage);
+                  callbacks.onMessage(fullMessage);
+                }
+              }
+            }
+            processStream();
+          }).catch((error) => {
+            if (callbacks.onError) {
+              callbacks.onError(error);
+            }
+          });
+        }
+        processStream();
+      }).catch((error) => {
+        if (callbacks.onError) {
+          callbacks.onError(error);
+        }
+      });
+      return () => controller.abort();
+    }
+  };
+});
+
 // src/commands/rootCommand.ts
 var import_cli_maker2, rootCommand, rootCommand_default;
 var init_rootCommand = __esm(() => {
   import_cli_maker2 = __toESM(require_dist());
-  init_agents_generator();
+  init_lib();
   rootCommand = {
     name: "version",
     description: "Get the version of the API",
@@ -1148,34 +1366,82 @@ var init_rootCommand = __esm(() => {
       description: "The URL of the API",
       required: false,
       type: import_cli_maker2.ParamType.Url
+    }, {
+      name: "apiToken",
+      description: "The API token",
+      required: false,
+      type: import_cli_maker2.ParamType.Text
     }],
     action: async (args) => {
-      OpenAPI["BASE"] = args.URL || "https://api.agentsgenerator.dev/";
-      console.log(OpenAPI);
-      const hello = await RootService.healthCheckHealthGet();
+      const client = new AgentClient({
+        apiUrl: args.URL || "https://api.agentsgenerator.dev/",
+        apiToken: args.apiToken
+      });
+      const hello = await client.root.healthCheckHealthGet();
       console.log(hello);
     }
   };
   rootCommand_default = rootCommand;
 });
 
+// src/commands/conversationsCommand.ts
+var import_cli_maker3, commandConversations, conversationsCommand_default;
+var init_conversationsCommand = __esm(() => {
+  import_cli_maker3 = __toESM(require_dist());
+  init_agents_generator();
+  commandConversations = {
+    name: "getConversations",
+    description: "Get the list of conversations",
+    params: [{
+      name: "URL",
+      description: "The URL of the API",
+      required: true,
+      type: import_cli_maker3.ParamType.Url
+    }, {
+      name: "conversationId",
+      description: "The ID of the conversation",
+      required: true,
+      type: import_cli_maker3.ParamType.Text
+    }, {
+      name: "agentId",
+      description: "The ID of the agent",
+      required: true,
+      type: import_cli_maker3.ParamType.Text
+    }],
+    action: async (args) => {
+      OpenAPI["BASE"] = args.URL;
+      const conversationId = args.conversationId;
+      const agentId = args.agentId;
+      const conversationList = await ConversationsService.getAgentConversationsConversationsAgentAgentIdGet(agentId);
+      const conversations = await ConversationsService.getConversationConversationsConversationIdGet(conversationId);
+      return {
+        conversationList,
+        conversations
+      };
+    }
+  };
+  conversationsCommand_default = commandConversations;
+});
+
 // src/cli.ts
 var exports_cli = {};
 __export(exports_cli, {
   cli: () => cli
 });
-var import_cli_maker3, cli;
+var import_cli_maker4, cli;
 var init_cli = __esm(() => {
-  import_cli_maker3 = __toESM(require_dist());
+  import_cli_maker4 = __toESM(require_dist());
   init_agents_generator();
   init_agentsCommand();
   init_rootCommand();
-  cli = new import_cli_maker3.CLI("@ideascol/agents-generator-sdk", "agents-generator-sdk", {
+  init_conversationsCommand();
+  cli = new import_cli_maker4.CLI("@ideascol/agents-generator-sdk", "agents-generator-sdk", {
     interactive: true,
     version: OpenAPI.VERSION
   });
   cli.command(rootCommand_default);
   cli.command(agentsCommand_default);
+  cli.command(conversationsCommand_default);
   cli.parse(process.argv);
 });
 

package/dist/commands/conversationsCommand.d.ts

@@ -0,0 +1,3 @@
+import { Command } from '@ideascol/cli-maker';
+declare let commandConversations: Command;
+export default commandConversations;

package/dist/index.js

@@ -166,7 +166,7 @@ var OpenAPI;
 var init_OpenAPI = __esm(() => {
   OpenAPI = {
     BASE: "",
-    VERSION: "main-3e9b5b5b62a0af3d34e07f2a82593d3a5b0543da",
+    VERSION: "main-6851016f7efc01be9f722f975c072d2cd49e46e7",
     WITH_CREDENTIALS: false,
     CREDENTIALS: "include",
     TOKEN: undefined,
@@ -679,198 +679,228 @@ var init_agents_generator = __esm(() => {
   init_RootService();
 });
 
-// src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  RootService: () => RootService,
-  OpenAPI: () => OpenAPI,
-  McpServersService: () => McpServersService,
-  ConversationsServiceStream: () => ConversationsServiceStream,
-  ConversationsService: () => ConversationsService,
-  CancelablePromise: () => CancelablePromise,
-  CancelError: () => CancelError,
-  ApiError: () => ApiError,
-  AgentService: () => AgentService
-});
-module.exports = __toCommonJS(exports_src);
-
 // src/lib/index.ts
-init_agents_generator();
-init_agents_generator();
-
-class ConversationsServiceStream extends ConversationsService {
-  constructor() {
-    super();
-  }
-  static addMessageConversationsConversationIdMessagesPostStream(conversationId, requestBody, callbacks) {
-    const apiUrl = OpenAPI.BASE;
-    const url = `${apiUrl}/conversations/${conversationId}/messages`;
-    const controller = new AbortController;
-    const headers = new Headers({
-      "Content-Type": "application/json",
-      Accept: "text/event-stream"
-    });
-    if (OpenAPI.TOKEN) {
-      if (typeof OpenAPI.TOKEN === "function") {
-        OpenAPI.TOKEN({ url, method: "POST", body: requestBody }).then((token) => {
-          headers.append("Authorization", `Bearer ${token}`);
-        }).catch((error) => {
-          if (callbacks.onError) {
-            callbacks.onError(new Error(`Failed to get auth token: ${error.message}`));
-          }
-        });
-      } else {
-        headers.append("Authorization", `Bearer ${OpenAPI.TOKEN}`);
-      }
+class AgentClient {
+  agent;
+  conversations;
+  mcpServers;
+  root;
+  ApiError;
+  CancelError;
+  CancelablePromise;
+  OpenAPI;
+  conversationsStream;
+  constructor({
+    apiUrl,
+    apiToken
+  }) {
+    OpenAPI.BASE = apiUrl;
+    OpenAPI.TOKEN = apiToken;
+    OpenAPI.HEADERS = {
+      "Api-Version": OpenAPI.VERSION
+    };
+    this.agent = AgentService;
+    this.conversations = ConversationsService;
+    this.mcpServers = McpServersService;
+    this.root = RootService;
+    this.conversationsStream = ConversationsServiceStream;
+    this.ApiError = ApiError;
+    this.CancelError = CancelError;
+    this.CancelablePromise = CancelablePromise;
+    this.OpenAPI = OpenAPI;
+  }
+  sendMessageWithStreaming(conversationId, requestBody, callbacks) {
+    return ConversationsServiceStream.addMessageConversationsConversationIdMessagesPostStream(conversationId, requestBody, callbacks);
+  }
+  sendMessage(conversationId, requestBody) {
+    return ConversationsServiceStream.addMessageConversationsConversationIdMessagesPost(conversationId, requestBody);
+  }
+}
+var ConversationsServiceStream;
+var init_lib = __esm(() => {
+  init_agents_generator();
+  ConversationsServiceStream = class ConversationsServiceStream extends ConversationsService {
+    constructor() {
+      super();
     }
-    fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(requestBody),
-      credentials: OpenAPI.WITH_CREDENTIALS ? OpenAPI.CREDENTIALS : undefined,
-      signal: controller.signal
-    }).then((response) => {
-      if (!response.ok) {
-        throw new Error(`Error: ${response.status} - ${response.statusText}`);
-      }
-      if (!response.body) {
-        throw new Error("ReadableStream not supported");
+    static addMessageConversationsConversationIdMessagesPostStream(conversationId, requestBody, callbacks) {
+      const apiUrl = OpenAPI.BASE;
+      const url = `${apiUrl}/conversations/${conversationId}/messages`;
+      const controller = new AbortController;
+      const headers = new Headers({
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      });
+      if (OpenAPI.TOKEN) {
+        if (typeof OpenAPI.TOKEN === "function") {
+          OpenAPI.TOKEN({ url, method: "POST", body: requestBody }).then((token) => {
+            headers.append("Authorization", `Bearer ${token}`);
+          }).catch((error) => {
+            if (callbacks.onError) {
+              callbacks.onError(new Error(`Failed to get auth token: ${error.message}`));
+            }
+          });
+        } else {
+          headers.append("Authorization", `Bearer ${OpenAPI.TOKEN}`);
+        }
       }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder;
-      let buffer = "";
-      let fullMessage = "";
-      let isDirectTextMode = false;
-      function processStream() {
-        reader.read().then(({ done, value }) => {
-          if (done) {
-            console.log("Stream completado");
-            if (buffer.length > 0) {
-              console.log("Procesando buffer final:", buffer);
-              if (isDirectTextMode) {
-                fullMessage += buffer;
-                if (callbacks.onMessage) {
-                  console.log("Actualizando mensaje final (texto directo):", fullMessage);
-                  callbacks.onMessage(fullMessage);
-                }
-              } else {
-                let eventEnd2 = buffer.indexOf(`
+      fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody),
+        credentials: OpenAPI.WITH_CREDENTIALS ? OpenAPI.CREDENTIALS : undefined,
+        signal: controller.signal
+      }).then((response) => {
+        if (!response.ok) {
+          throw new Error(`Error: ${response.status} - ${response.statusText}`);
+        }
+        if (!response.body) {
+          throw new Error("ReadableStream not supported");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        let fullMessage = "";
+        let isDirectTextMode = false;
+        function processStream() {
+          reader.read().then(({ done, value }) => {
+            if (done) {
+              console.log("Stream completado");
+              if (buffer.length > 0) {
+                console.log("Procesando buffer final:", buffer);
+                if (isDirectTextMode) {
+                  fullMessage += buffer;
+                  if (callbacks.onMessage) {
+                    console.log("Actualizando mensaje final (texto directo):", fullMessage);
+                    callbacks.onMessage(fullMessage);
+                  }
+                } else {
+                  let eventEnd2 = buffer.indexOf(`
 
 `);
-                if (eventEnd2 > -1) {
-                  const eventData = buffer.substring(0, eventEnd2);
-                  buffer = buffer.substring(eventEnd2 + 2);
-                  if (eventData.startsWith("data: ")) {
-                    try {
-                      const jsonStr = eventData.substring(6);
-                      const data = JSON.parse(jsonStr);
-                      if (data.type === "message" && data.content && callbacks.onMessage) {
-                        fullMessage = data.content;
-                        callbacks.onMessage(fullMessage);
-                      } else if (data.type === "done" && data.message_id && callbacks.onDone) {
-                        callbacks.onDone(data.message_id);
-                      }
-                    } catch (e) {
-                      fullMessage += eventData.substring(6);
-                      if (callbacks.onMessage) {
-                        callbacks.onMessage(fullMessage);
+                  if (eventEnd2 > -1) {
+                    const eventData = buffer.substring(0, eventEnd2);
+                    buffer = buffer.substring(eventEnd2 + 2);
+                    if (eventData.startsWith("data: ")) {
+                      try {
+                        const jsonStr = eventData.substring(6);
+                        const data = JSON.parse(jsonStr);
+                        if (data.type === "message" && data.content && callbacks.onMessage) {
+                          fullMessage = data.content;
+                          callbacks.onMessage(fullMessage);
+                        } else if (data.type === "done" && data.message_id && callbacks.onDone) {
+                          callbacks.onDone(data.message_id);
+                        }
+                      } catch (e) {
+                        fullMessage += eventData.substring(6);
+                        if (callbacks.onMessage) {
+                          callbacks.onMessage(fullMessage);
+                        }
                       }
                     }
                   }
-                }
-                if (buffer.length > 0) {
-                  fullMessage += buffer;
-                  if (callbacks.onMessage) {
-                    console.log("Actualizando mensaje final (buffer restante):", fullMessage);
-                    callbacks.onMessage(fullMessage);
+                  if (buffer.length > 0) {
+                    fullMessage += buffer;
+                    if (callbacks.onMessage) {
+                      console.log("Actualizando mensaje final (buffer restante):", fullMessage);
+                      callbacks.onMessage(fullMessage);
+                    }
                   }
                 }
               }
+              if (callbacks.onDone) {
+                callbacks.onDone("stream-completed");
+              }
+              return;
             }
-            if (callbacks.onDone) {
-              callbacks.onDone("stream-completed");
-            }
-            return;
-          }
-          const chunk = decoder.decode(value, { stream: true });
-          buffer += chunk;
-          console.log("Chunk recibido:", chunk);
-          let eventEnd = buffer.indexOf(`
+            const chunk = decoder.decode(value, { stream: true });
+            buffer += chunk;
+            console.log("Chunk recibido:", chunk);
+            let eventEnd = buffer.indexOf(`
 
 `);
-          if (buffer.length > 50 && eventEnd === -1 && !isDirectTextMode) {
-            isDirectTextMode = true;
-            console.log("Detectado modo texto directo");
-          }
-          if (isDirectTextMode) {
-            fullMessage += chunk;
-            if (callbacks.onMessage) {
-              console.log("Actualizando con texto directo:", fullMessage);
-              callbacks.onMessage(fullMessage);
+            if (buffer.length > 50 && eventEnd === -1 && !isDirectTextMode) {
+              isDirectTextMode = true;
+              console.log("Detectado modo texto directo");
             }
-          } else {
-            while (eventEnd > -1) {
-              const eventData = buffer.substring(0, eventEnd);
-              buffer = buffer.substring(eventEnd + 2);
-              if (eventData.startsWith("data: ")) {
-                const jsonStr = eventData.substring(6);
-                try {
-                  const data = JSON.parse(jsonStr);
-                  console.log("Evento SSE recibido:", data);
-                  if (data.type === "message" && data.content && callbacks.onMessage) {
-                    fullMessage = data.content;
-                    callbacks.onMessage(fullMessage);
-                  } else if (data.type === "done" && data.message_id && callbacks.onDone) {
-                    callbacks.onDone(data.message_id);
-                  }
-                } catch (e) {
-                  console.error("Error al parsear JSON del evento:", e);
-                  if (eventData.startsWith("data: ")) {
-                    const directContent = eventData.substring(6);
-                    fullMessage += directContent;
-                    if (callbacks.onMessage) {
-                      console.log("Actualizando con texto SSE simple:", fullMessage);
+            if (isDirectTextMode) {
+              fullMessage += chunk;
+              if (callbacks.onMessage) {
+                console.log("Actualizando con texto directo:", fullMessage);
+                callbacks.onMessage(fullMessage);
+              }
+            } else {
+              while (eventEnd > -1) {
+                const eventData = buffer.substring(0, eventEnd);
+                buffer = buffer.substring(eventEnd + 2);
+                if (eventData.startsWith("data: ")) {
+                  const jsonStr = eventData.substring(6);
+                  try {
+                    const data = JSON.parse(jsonStr);
+                    console.log("Evento SSE recibido:", data);
+                    if (data.type === "message" && data.content && callbacks.onMessage) {
+                      fullMessage = data.content;
                       callbacks.onMessage(fullMessage);
+                    } else if (data.type === "done" && data.message_id && callbacks.onDone) {
+                      callbacks.onDone(data.message_id);
                     }
-                  } else {
-                    if (callbacks.onError) {
-                      callbacks.onError(new Error(`Error parsing SSE event: ${e}`));
+                  } catch (e) {
+                    console.error("Error al parsear JSON del evento:", e);
+                    if (eventData.startsWith("data: ")) {
+                      const directContent = eventData.substring(6);
+                      fullMessage += directContent;
+                      if (callbacks.onMessage) {
+                        console.log("Actualizando con texto SSE simple:", fullMessage);
+                        callbacks.onMessage(fullMessage);
+                      }
+                    } else {
+                      if (callbacks.onError) {
+                        callbacks.onError(new Error(`Error parsing SSE event: ${e}`));
+                      }
                     }
                   }
+                } else {
+                  fullMessage += eventData;
+                  if (callbacks.onMessage) {
+                    console.log("Actualizando con evento no reconocido:", fullMessage);
+                    callbacks.onMessage(fullMessage);
+                  }
                 }
-              } else {
-                fullMessage += eventData;
+                eventEnd = buffer.indexOf(`
+
+`);
+              }
+              if (buffer.length > 20 && !buffer.includes("data: ")) {
+                fullMessage += buffer;
+                buffer = "";
                 if (callbacks.onMessage) {
-                  console.log("Actualizando con evento no reconocido:", fullMessage);
+                  console.log("Actualizando con buffer residual:", fullMessage);
                   callbacks.onMessage(fullMessage);
                 }
               }
-              eventEnd = buffer.indexOf(`
-
-`);
             }
-            if (buffer.length > 20 && !buffer.includes("data: ")) {
-              fullMessage += buffer;
-              buffer = "";
-              if (callbacks.onMessage) {
-                console.log("Actualizando con buffer residual:", fullMessage);
-                callbacks.onMessage(fullMessage);
-              }
+            processStream();
+          }).catch((error) => {
+            if (callbacks.onError) {
+              callbacks.onError(error);
             }
-          }
-          processStream();
-        }).catch((error) => {
-          if (callbacks.onError) {
-            callbacks.onError(error);
-          }
-        });
-      }
-      processStream();
-    }).catch((error) => {
-      if (callbacks.onError) {
-        callbacks.onError(error);
-      }
-    });
-    return () => controller.abort();
-  }
-}
+          });
+        }
+        processStream();
+      }).catch((error) => {
+        if (callbacks.onError) {
+          callbacks.onError(error);
+        }
+      });
+      return () => controller.abort();
+    }
+  };
+});
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  AgentClient: () => AgentClient
+});
+module.exports = __toCommonJS(exports_src);
+init_lib();

package/dist/lib/clients/agents-generator/index.d.ts

@@ -10,6 +10,7 @@ export type { ConversationCreate } from './models/ConversationCreate';
 export type { ConversationResponse } from './models/ConversationResponse';
 export type { ConversationUpdate } from './models/ConversationUpdate';
 export type { Edge } from './models/Edge';
+export type { ErrorResponse } from './models/ErrorResponse';
 export type { Handoff } from './models/Handoff';
 export type { HTTPValidationError } from './models/HTTPValidationError';
 export type { MarkerEnd } from './models/MarkerEnd';

package/dist/lib/clients/agents-generator/models/ErrorResponse.d.ts

@@ -0,0 +1,4 @@
+export type ErrorResponse = {
+    status: string;
+    message: string;
+};

package/dist/lib/clients/agents-generator/services/ConversationsService.d.ts

@@ -46,13 +46,9 @@ export declare class ConversationsService {
      * Add Message
      * @param conversationId
      * @param requestBody
-     * @param accept Set to 'text/event-stream' to receive streaming events
+     * @param accept Content type to receive: 'text/event-stream' for streaming or 'text/plain' for plain text
      * @returns any Successful response
      * @throws ApiError
      */
-    static addMessageConversationsConversationIdMessagesPost(conversationId: string, requestBody: MessageCreate, accept?: string): CancelablePromise<{
-        status: string;
-        message: string;
-        message_id?: string;
-    }>;
+    static addMessageConversationsConversationIdMessagesPost(conversationId: string, requestBody: MessageCreate, accept?: (string | null)): CancelablePromise<any>;
 }

package/dist/lib/index.d.ts

@@ -1,5 +1,4 @@
-import { ConversationsService, MessageCreate } from "./clients/agents-generator";
-export * from "./clients/agents-generator";
+import { ApiError, CancelablePromise, CancelError, ConversationsService, MessageCreate, OpenAPI, AgentService, McpServersService, RootService } from "./clients/agents-generator";
 export interface StreamEvent {
     type: string;
     content?: string;
@@ -10,7 +9,7 @@ export interface StreamCallbacks {
     onDone?: (messageId: string) => void;
     onError?: (error: Error) => void;
 }
-export declare class ConversationsServiceStream extends ConversationsService {
+declare class ConversationsServiceStream extends ConversationsService {
     constructor();
     /**
      * Add Message with SSE streaming support
@@ -21,3 +20,31 @@ export declare class ConversationsServiceStream extends ConversationsService {
      */
     static addMessageConversationsConversationIdMessagesPostStream(conversationId: string, requestBody: MessageCreate, callbacks: StreamCallbacks): () => void;
 }
+export declare class AgentClient {
+    agent: typeof AgentService;
+    conversations: typeof ConversationsService;
+    mcpServers: typeof McpServersService;
+    root: typeof RootService;
+    ApiError: typeof ApiError;
+    CancelError: typeof CancelError;
+    CancelablePromise: typeof CancelablePromise;
+    OpenAPI: typeof OpenAPI;
+    conversationsStream: typeof ConversationsServiceStream;
+    constructor({ apiUrl, apiToken, }: {
+        apiUrl: string;
+        apiToken: string;
+    });
+    /**
+     * Envía un mensaje a una conversación con soporte para streaming
+     */
+    sendMessageWithStreaming(conversationId: string, requestBody: MessageCreate, callbacks: StreamCallbacks): () => void;
+    /**
+     * Envía un mensaje a una conversación sin streaming
+     */
+    sendMessage(conversationId: string, requestBody: MessageCreate): CancelablePromise<{
+        status: string;
+        message: string;
+        message_id?: string;
+    }>;
+}
+export default AgentClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ideascol/agents-generator-sdk",
-  "version": "0.0.3-rc5",
+  "version": "0.0.4-rc1",
   "main": "dist/index.js",
   "scripts": {
     "test": "bun test",