@ideascol/agents-generator-sdk 0.0.3-rc1 → 0.0.3-rc3

package/dist/index.js

@@ -685,6 +685,7 @@ __export(exports_src, {
   RootService: () => RootService,
   OpenAPI: () => OpenAPI,
   McpServersService: () => McpServersService,
+  ConversationsServiceStream: () => ConversationsServiceStream,
   ConversationsService: () => ConversationsService,
   CancelablePromise: () => CancelablePromise,
   CancelError: () => CancelError,
@@ -695,3 +696,100 @@ 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}`);
+      }
+    }
+    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 = "";
+      function processStream() {
+        reader.read().then(({ done, value }) => {
+          if (done) {
+            console.log("Stream completado");
+            return;
+          }
+          const chunk = decoder.decode(value, { stream: true });
+          buffer += chunk;
+          console.log("Chunk recibido:", chunk);
+          let eventEnd = buffer.indexOf(`
+
+`);
+          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 (callbacks.onError) {
+                  callbacks.onError(new Error(`Error parsing SSE event: ${e}`));
+                }
+              }
+            }
+            eventEnd = buffer.indexOf(`
+
+`);
+          }
+          processStream();
+        }).catch((error) => {
+          if (callbacks.onError) {
+            callbacks.onError(error);
+          }
+        });
+      }
+      processStream();
+    }).catch((error) => {
+      if (callbacks.onError) {
+        callbacks.onError(error);
+      }
+    });
+    return () => controller.abort();
+  }
+}

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

@@ -1,5 +1,4 @@
 export type MessageCreate = {
     content: string;
     metadata?: (Record<string, any> | null);
-    stream?: boolean;
 };

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

@@ -50,5 +50,9 @@ export declare class ConversationsService {
      * @returns any Successful response
      * @throws ApiError
      */
-    static addMessageConversationsConversationIdMessagesPost(conversationId: string, requestBody: MessageCreate, accept?: string): CancelablePromise<Record<string, any>>;
+    static addMessageConversationsConversationIdMessagesPost(conversationId: string, requestBody: MessageCreate, accept?: string): CancelablePromise<{
+        status: string;
+        message: string;
+        message_id?: string;
+    }>;
 }

package/dist/lib/index.d.ts

@@ -1 +1,23 @@
-export * from './clients/agents-generator';
+import { ConversationsService, MessageCreate } from "./clients/agents-generator";
+export * from "./clients/agents-generator";
+export interface StreamEvent {
+    type: string;
+    content?: string;
+    message_id?: string;
+}
+export interface StreamCallbacks {
+    onMessage?: (content: string) => void;
+    onDone?: (messageId: string) => void;
+    onError?: (error: Error) => void;
+}
+export declare class ConversationsServiceStream extends ConversationsService {
+    constructor();
+    /**
+     * Add Message with SSE streaming support
+     * @param conversationId The ID of the conversation
+     * @param requestBody The message data to send
+     * @param callbacks Callbacks for handling streaming events
+     * @returns A function to abort the stream
+     */
+    static addMessageConversationsConversationIdMessagesPostStream(conversationId: string, requestBody: MessageCreate, callbacks: StreamCallbacks): () => void;
+}

package/package.json

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