@cadraos/sdk 0.1.2 → 0.1.3

package/README.md

@@ -398,4 +398,4 @@ const stream = await client.agents.stream(uuid, { task: '...' });
 
 ## License
 
-MIT
+Apache-2.0

package/dist/index.cjs

@@ -405,6 +405,9 @@ var SSEClient = class {
    */
   async connect() {
     this.abortController = new AbortController();
+    console.log("[SDK:SSE] Connecting to:", this.config.url);
+    console.log("[SDK:SSE] Auth header:", this.config.authHeader ? `${this.config.authHeader.substring(0, 30)}...` : "MISSING");
+    console.log("[SDK:SSE] Org ID:", this.config.orgId);
     try {
       const response = await fetch(this.config.url, {
         method: "GET",
@@ -416,23 +419,39 @@ var SSEClient = class {
         },
         signal: this.abortController.signal
       });
+      console.log("[SDK:SSE] Response status:", response.status, response.statusText);
+      console.log("[SDK:SSE] Response headers:", {
+        contentType: response.headers.get("content-type"),
+        cacheControl: response.headers.get("cache-control")
+      });
       if (!response.ok) {
-        throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+        let errorBody = "";
+        try {
+          errorBody = await response.text();
+          console.error("[SDK:SSE] Error response body:", errorBody);
+        } catch (e) {
+          console.error("[SDK:SSE] Could not read error body");
+        }
+        throw new Error(`SSE connection failed: ${response.status} ${response.statusText} - ${errorBody}`);
       }
       if (!response.body) {
         throw new Error("Response body not available");
       }
+      console.log("[SDK:SSE] Connection successful, starting stream parsing");
       this.connected = true;
       this.config.onConnectionChange(true);
       await this.parseStream(response.body);
     } catch (error) {
       if (error instanceof Error && error.name === "AbortError") {
+        console.log("[SDK:SSE] Connection aborted (intentional)");
         return;
       }
+      console.error("[SDK:SSE] Connection error:", error);
       this.config.onError(error instanceof Error ? error : new Error(String(error)));
     } finally {
       this.connected = false;
       this.config.onConnectionChange(false);
+      console.log("[SDK:SSE] Connection closed");
     }
   }
   /**
@@ -459,18 +478,29 @@ var SSEClient = class {
     const decoder = new TextDecoder();
     let buffer = "";
     let currentEvent = {};
+    let chunkCount = 0;
+    let eventCount = 0;
+    console.log("[SDK:SSE] Starting to parse stream");
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) {
+          console.log("[SDK:SSE] Stream reading complete. Total chunks:", chunkCount, "events:", eventCount);
           break;
         }
-        buffer += decoder.decode(value, { stream: true });
+        chunkCount++;
+        const chunk = decoder.decode(value, { stream: true });
+        buffer += chunk;
+        if (chunkCount <= 5) {
+          console.log(`[SDK:SSE] Chunk ${chunkCount} (${value.length} bytes):`, chunk.substring(0, 200));
+        }
         const lines = buffer.split("\n");
         buffer = lines.pop() ?? "";
         for (const line of lines) {
           if (line === "") {
             if (currentEvent.type && currentEvent.data !== void 0) {
+              eventCount++;
+              console.log(`[SDK:SSE] Event ${eventCount}:`, currentEvent.type, "- data length:", currentEvent.data.length);
               this.dispatchEvent(currentEvent);
             }
             currentEvent = {};
@@ -502,6 +532,7 @@ var SSEClient = class {
         }
       }
     } finally {
+      console.log("[SDK:SSE] parseStream finished. Releasing reader lock.");
       reader.releaseLock();
     }
   }
@@ -509,10 +540,12 @@ var SSEClient = class {
    * Dispatch parsed event
    */
   dispatchEvent(event) {
+    console.log("[SDK:SSE] dispatchEvent called:", event.type, "id:", event.id);
     try {
       let data;
       try {
         data = JSON.parse(event.data);
+        console.log("[SDK:SSE] Parsed event data:", typeof data, data && typeof data === "object" ? Object.keys(data) : "");
       } catch {
         data = event.data;
       }
@@ -556,6 +589,13 @@ var ExecutionStreamControllerImpl = class {
     toolCall: [],
     toolResult: [],
     plan: [],
+    paused: [],
+    started: [],
+    progress: [],
+    taskListUpdate: [],
+    delegationStarted: [],
+    delegationCompleted: [],
+    textDelta: [],
     complete: [],
     error: [],
     connectionChange: []
@@ -574,6 +614,18 @@ var ExecutionStreamControllerImpl = class {
   get lastEventId() {
     return this._lastEventId;
   }
+  /**
+   * Get the execution ID
+   */
+  get executionId() {
+    return this.options.executionId;
+  }
+  /**
+   * Get the session ID (if available)
+   */
+  get sessionId() {
+    return this.options.sessionId;
+  }
   /**
    * Connect to the execution stream
    */
@@ -635,13 +687,23 @@ var ExecutionStreamControllerImpl = class {
    */
   async connectSSE() {
     const url = `${this.options.baseUrl}/agents/runs/${this.options.executionId}/stream`;
+    console.log("[SDK:StreamController] Connecting to SSE");
+    console.log("[SDK:StreamController] URL:", url);
+    console.log("[SDK:StreamController] baseUrl:", this.options.baseUrl);
+    console.log("[SDK:StreamController] executionId:", this.options.executionId);
+    console.log("[SDK:StreamController] orgId:", this.options.orgId);
+    console.log("[SDK:StreamController] apiKey:", this.options.apiKey ? `${this.options.apiKey.substring(0, 20)}...` : "MISSING");
     this.sseClient = new SSEClient({
       url,
       authHeader: `Bearer ${this.options.apiKey}`,
       orgId: this.options.orgId,
       onEvent: (event) => this.handleEvent(event),
-      onError: (error) => this.handleConnectionError(error),
+      onError: (error) => {
+        console.error("[SDK:StreamController] SSE error:", error);
+        this.handleConnectionError(error);
+      },
       onConnectionChange: (connected) => {
+        console.log("[SDK:StreamController] SSE connection change:", connected);
         if (connected) {
           this.status = "connected";
           this.reconnectAttempts = 0;
@@ -650,15 +712,23 @@ var ExecutionStreamControllerImpl = class {
         this.emit("connectionChange", { connected, usingFallback: false });
       }
     });
-    await this.sseClient.connect();
+    try {
+      await this.sseClient.connect();
+      console.log("[SDK:StreamController] SSE connect() completed");
+    } catch (error) {
+      console.error("[SDK:StreamController] SSE connect() threw:", error);
+      throw error;
+    }
   }
   /**
    * Handle incoming SSE event
    */
   handleEvent(event) {
+    console.log("[SDK:StreamController] handleEvent called:", event.type, "id:", event.id);
     this.resetActivityTimeout();
     if (event.id) {
       if (this.seenEventIds.has(event.id)) {
+        console.log("[SDK:StreamController] Skipping duplicate event:", event.id);
         return;
       }
       this.seenEventIds.add(event.id);
@@ -669,24 +739,52 @@ var ExecutionStreamControllerImpl = class {
       }
     }
     const data = event.data;
+    console.log("[SDK:StreamController] Event data keys:", Object.keys(data));
     switch (event.type) {
-      case "log":
-        this.emit("log", data.log);
+      case "log": {
+        const rawLog = data.log;
+        if (!rawLog) {
+          console.warn("[StreamController] Received log event without log data");
+          break;
+        }
+        const logTypeValue = rawLog.logType || rawLog.type || "info";
+        const transformedLog = {
+          uuid: rawLog.uuid || `log-${rawLog.stepIndex || Date.now()}`,
+          type: logTypeValue,
+          title: rawLog.message || rawLog.title || "",
+          content: rawLog.content,
+          metadata: {
+            ...rawLog.metadata || {},
+            // Include stepIndex in metadata for deduplication
+            stepIndex: rawLog.stepIndex ?? 0
+          },
+          timestamp: rawLog.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: rawLog.durationMs
+        };
+        this.emit("log", transformedLog);
         break;
+      }
       case "tool_call":
         this.emit("toolCall", {
-          toolCallId: data.toolCallId,
-          toolName: data.toolName,
-          inputs: data.args,
+          toolCallId: data.toolCallId || `tool-call-${Date.now()}`,
+          toolName: data.toolName || "Unknown Tool",
+          inputs: data.args || {},
           stepIndex: data.stepIndex ?? 0
         });
         break;
       case "tool_result":
         this.emit("toolResult", {
-          toolCallId: data.toolCallId,
-          toolName: data.toolName,
+          toolCallId: data.toolCallId || `tool-result-${Date.now()}`,
+          toolName: data.toolName || "Unknown Tool",
           result: data.result,
-          durationMs: data.durationMs
+          durationMs: data.durationMs ?? 0
+        });
+        break;
+      case "execution_paused":
+        this.emit("paused", {
+          question: data.question || data.output || "",
+          options: data.options,
+          reason: "waiting_user_input"
         });
         break;
       case "complete":
@@ -698,6 +796,12 @@ var ExecutionStreamControllerImpl = class {
           errorCode: data.errorCode
         });
         break;
+      case "failed":
+        this.handleError({
+          error: data.error || data.message || "Execution failed",
+          errorCode: data.errorCode || "execution_failed"
+        });
+        break;
       case "timeout":
         if (data.retryable) {
           this.handleConnectionError(new Error("Stream timeout"));
@@ -708,6 +812,74 @@ var ExecutionStreamControllerImpl = class {
           });
         }
         break;
+      // Handle started event - immediate feedback that execution began
+      case "started":
+        this.emit("started", {
+          executionId: data.executionId,
+          agentUuid: data.agentUuid,
+          status: "initializing",
+          currentStep: data.currentStep
+        });
+        break;
+      // Handle progress event - status updates during execution
+      case "progress":
+        this.emit("progress", {
+          status: data.status,
+          iteration: data.iteration ?? 0,
+          currentStep: data.currentStep,
+          tokenUsage: data.tokenUsage,
+          cost: data.cost,
+          toolCalls: data.toolCalls
+        });
+        break;
+      // Handle task list update event from TaskTracker
+      case "task_list_update":
+        this.emit("taskListUpdate", {
+          executionId: data.executionId,
+          tasks: data.tasks,
+          timestamp: data.timestamp
+        });
+        break;
+      // Handle delegation started event (handoff_to_agent initiated)
+      case "delegation_started":
+        this.emit("delegationStarted", {
+          type: "delegation_started",
+          handoffId: data.handoffId,
+          targetAgentUuid: data.targetAgentUuid,
+          targetAgentName: data.targetAgentName,
+          taskPreview: data.taskPreview,
+          timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+        });
+        break;
+      // Handle delegation completed event (handoff_to_agent finished)
+      case "delegation_completed":
+        this.emit("delegationCompleted", {
+          type: "delegation_completed",
+          handoffId: data.handoffId,
+          status: data.status,
+          resultPreview: data.resultPreview,
+          error: data.error,
+          durationMs: data.durationMs,
+          timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+        });
+        break;
+      // Handle status_update event - immediate feedback (e.g., "thinking")
+      // Map to progress event for consistency
+      case "status_update":
+        this.emit("progress", {
+          status: data.status || "thinking",
+          iteration: 0,
+          currentStep: data.message
+        });
+        break;
+      // Handle text_delta event - token-by-token streaming
+      case "text_delta":
+        this.emit("textDelta", {
+          delta: data.delta,
+          executionId: data.executionId,
+          timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+        });
+        break;
     }
   }
   /**
@@ -716,9 +888,11 @@ var ExecutionStreamControllerImpl = class {
   handleComplete(data) {
     this.status = "closed";
     this.stopActivityTimeout();
+    const sessionId = data.sessionId ?? this.options.sessionId;
     const execution = {
       uuid: this.options.executionId,
       agentUuid: "",
+      sessionId,
       status: "completed",
       input: { task: "" },
       output: data.output,
@@ -842,6 +1016,7 @@ var ExecutionStreamControllerImpl = class {
    */
   emit(event, data) {
     const listeners = this.listeners[event];
+    console.log(`[SDK:StreamController] Emitting '${event}' to ${listeners?.length || 0} listeners`);
     if (listeners) {
       for (const listener of listeners) {
         try {
@@ -921,8 +1096,12 @@ var AgentsAPI = class extends BaseResourceAPI {
     return this.httpPost(
       `/${uuid}/execute`,
       {
-        task: input.task,
-        context: input.context,
+        input: {
+          task: input.task,
+          context: input.context ?? {},
+          // Pass attachment IDs for multi-modal messages (images, documents, etc.)
+          attachmentIds: input.attachmentIds
+        },
         options: input.options
       },
       { idempotencyKey }
@@ -973,16 +1152,69 @@ var AgentsAPI = class extends BaseResourceAPI {
    * ```
    */
   async stream(uuid, input) {
-    const { executionId } = await this.execute(uuid, input);
+    console.log("[SDK:Agents] stream() called for agent:", uuid);
+    const { executionId, sessionId } = await this.execute(uuid, input);
+    console.log("[SDK:Agents] Execution started:", { executionId, sessionId });
     const config = this.getStreamConfig();
+    console.log("[SDK:Agents] Stream config:", {
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey ? `${config.apiKey.substring(0, 20)}...` : "MISSING",
+      orgId: config.orgId
+    });
     const controller = createExecutionStreamController({
       executionId,
+      sessionId,
       baseUrl: config.baseUrl,
       apiKey: config.apiKey,
       orgId: config.orgId,
       getExecution: (id) => this.getExecution(id)
     });
-    await controller.connect();
+    console.log("[SDK:Agents] Stream controller created - caller must call connect() after registering listeners");
+    return controller;
+  }
+  /**
+   * Connect to an existing execution's stream
+   *
+   * Use this when the execution was started externally (e.g., via tRPC for team executions)
+   * and you need to connect to its SSE stream for real-time updates.
+   *
+   * @param executionId - Execution UUID (already running)
+   * @param sessionId - Optional session ID for conversation continuity
+   * @returns Stream controller for the execution
+   *
+   * @example
+   * ```typescript
+   * // Execution started via tRPC
+   * const executionId = await trpc.executions.start.mutate({ teamUuid, task });
+   *
+   * // Connect to SSE stream for real-time updates
+   * const stream = client.agents.streamExecution(executionId);
+   *
+   * stream.on('log', (log) => console.log(log.title));
+   * stream.on('delegationStarted', (data) => console.log('Subagent:', data.targetAgentName));
+   * stream.on('complete', ({ execution }) => console.log(execution.output));
+   *
+   * await stream.connect();
+   * const result = await stream.wait();
+   * ```
+   */
+  streamExecution(executionId, sessionId) {
+    console.log("[SDK:Agents] streamExecution() called for execution:", executionId);
+    const config = this.getStreamConfig();
+    console.log("[SDK:Agents] Stream config:", {
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey ? `${config.apiKey.substring(0, 20)}...` : "MISSING",
+      orgId: config.orgId
+    });
+    const controller = createExecutionStreamController({
+      executionId,
+      sessionId,
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey,
+      orgId: config.orgId,
+      getExecution: (id) => this.getExecution(id)
+    });
+    console.log("[SDK:Agents] Stream controller created for existing execution - caller must call connect() after registering listeners");
     return controller;
   }
   // ===== RECEIVE Operations =====
@@ -1514,13 +1746,16 @@ var ArtifactsAPI = class extends BaseResourceAPI {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        const arrayBuffer = value.buffer.slice(
-          value.byteOffset,
-          value.byteOffset + value.byteLength
-        );
-        chunks.push(arrayBuffer);
+        chunks.push(new Uint8Array(value));
+      }
+      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+      const combined = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.length;
       }
-      const blob = new Blob(chunks, { type: input.mimeType ?? "application/octet-stream" });
+      const blob = new Blob([combined.buffer], { type: input.mimeType ?? "application/octet-stream" });
       formData.append("file", blob, input.name);
     }
     if (input.type) {
@@ -1620,7 +1855,9 @@ var SessionsAPI = class extends BaseResourceAPI {
       `/${sessionId}/messages`,
       {
         message: input.message,
-        context: input.context
+        context: input.context,
+        // Pass attachment IDs for multi-modal messages (images, documents, etc.)
+        attachmentIds: input.attachmentIds
       },
       { idempotencyKey }
     );
@@ -1671,6 +1908,7 @@ var SessionsAPI = class extends BaseResourceAPI {
     const config = this.getStreamConfig();
     const controller = createExecutionStreamController({
       executionId,
+      sessionId,
       baseUrl: config.baseUrl,
       apiKey: config.apiKey,
       orgId: config.orgId,