@witqq/agent-sdk 0.6.1 → 0.7.0

package/dist/backends/claude.cjs

@@ -8,10 +8,16 @@ function getTextContent(content) {
 
 // src/errors.ts
 var AgentSDKError = class extends Error {
+  /** @internal Marker for cross-bundle identity checks */
+  _agentSDKError = true;
   constructor(message, options) {
     super(message, options);
     this.name = "AgentSDKError";
   }
+  /** Check if an error is an AgentSDKError (works across bundled copies) */
+  static is(error) {
+    return error instanceof Error && "_agentSDKError" in error && error._agentSDKError === true;
+  }
 };
 var ReentrancyError = class extends AgentSDKError {
   constructor() {
@@ -43,6 +49,7 @@ var BaseAgent = class {
   state = "idle";
   abortController = null;
   config;
+  _cleanupExternalSignal = null;
   /** CLI session ID for persistent mode. Override in backends that support it. */
   get sessionId() {
     return void 0;
@@ -62,8 +69,7 @@ var BaseAgent = class {
       this.enrichAndNotifyUsage(result);
       return result;
     } finally {
-      this.state = "idle";
-      this.abortController = null;
+      this.cleanupRun();
     }
   }
   async runWithContext(messages, options) {
@@ -76,8 +82,7 @@ var BaseAgent = class {
       this.enrichAndNotifyUsage(result);
       return result;
     } finally {
-      this.state = "idle";
-      this.abortController = null;
+      this.cleanupRun();
     }
   }
   async runStructured(prompt, schema, options) {
@@ -96,8 +101,7 @@ var BaseAgent = class {
       this.enrichAndNotifyUsage(result);
       return result;
     } finally {
-      this.state = "idle";
-      this.abortController = null;
+      this.cleanupRun();
     }
   }
   async *stream(prompt, options) {
@@ -110,8 +114,7 @@ var BaseAgent = class {
       const enriched = this.enrichStream(this.executeStream(messages, options, ac.signal));
       yield* this.heartbeatStream(enriched);
     } finally {
-      this.state = "idle";
-      this.abortController = null;
+      this.cleanupRun();
     }
   }
   async *streamWithContext(messages, options) {
@@ -123,8 +126,7 @@ var BaseAgent = class {
       const enriched = this.enrichStream(this.executeStream(messages, options, ac.signal));
       yield* this.heartbeatStream(enriched);
     } finally {
-      this.state = "idle";
-      this.abortController = null;
+      this.cleanupRun();
     }
   }
   abort() {
@@ -144,6 +146,8 @@ var BaseAgent = class {
   }
   /** Mark agent as disposed. Override to add cleanup. */
   dispose() {
+    this._cleanupExternalSignal?.();
+    this._cleanupExternalSignal = null;
     this.abort();
     this.state = "disposed";
   }
@@ -254,16 +258,24 @@ var BaseAgent = class {
     }
   }
   // ─── Internal Helpers ─────────────────────────────────────────
+  /** Clean up after a run completes (success, error, or abort). */
+  cleanupRun() {
+    this._cleanupExternalSignal?.();
+    this._cleanupExternalSignal = null;
+    this.state = "idle";
+    this.abortController = null;
+  }
   createAbortController(externalSignal) {
     const ac = new AbortController();
     this.abortController = ac;
+    this._cleanupExternalSignal = null;
     if (externalSignal) {
       if (externalSignal.aborted) {
         ac.abort();
       } else {
-        externalSignal.addEventListener("abort", () => ac.abort(), {
-          once: true
-        });
+        const listener = () => ac.abort();
+        externalSignal.addEventListener("abort", listener, { once: true });
+        this._cleanupExternalSignal = () => externalSignal.removeEventListener("abort", listener);
       }
     }
     return ac;
@@ -605,9 +617,12 @@ var ClaudeAgent = class extends BaseAgent {
   constructor(config, options) {
     super(config);
     this.options = options;
-    this.tools = config.tools;
+    this.tools = config.tools ?? [];
     this.canUseTool = buildCanUseTool(config);
     this.isPersistent = config.sessionMode === "persistent";
+    if (options.resumeSessionId) {
+      this._sessionId = options.resumeSessionId;
+    }
     if (config.supervisor?.onAskUser) {
       console.warn(
         "[agent-sdk/claude] supervisor.onAskUser is not supported by the Claude CLI backend. User interaction requests from the model will not be forwarded."
@@ -666,7 +681,7 @@ var ClaudeAgent = class extends BaseAgent {
       opts.permissionMode = "default";
     }
     if (this.config.availableTools) {
-      opts.allowedTools = [...this.config.availableTools];
+      opts.tools = [...this.config.availableTools];
     }
     return opts;
   }
@@ -740,8 +755,78 @@ var ClaudeAgent = class extends BaseAgent {
         }
       }
     } catch (e) {
-      if (this.isPersistent) this.clearPersistentSession();
       if (signal.aborted) throw new AbortError();
+      if (isResuming && this.isPersistent) {
+        this.clearPersistentSession();
+        const retryPrompt = buildContextualPrompt(messages);
+        let retryOpts = this.buildQueryOptions(signal);
+        toolResultCapture.clear();
+        retryOpts = await this.buildMcpConfig(retryOpts, toolResultCapture);
+        const retryQ = sdk.query({ prompt: retryPrompt, options: retryOpts });
+        this.activeQuery = retryQ;
+        toolCalls.length = 0;
+        output = null;
+        try {
+          for await (const msg of retryQ) {
+            if (msg.type === "assistant") {
+              const betaMessage = msg.message;
+              if (betaMessage?.content) {
+                for (const block of betaMessage.content) {
+                  if (block.type === "tool_use") {
+                    const toolName = stripMcpPrefix(block.name ?? "unknown");
+                    toolCalls.push({
+                      toolName,
+                      args: block.input ?? {},
+                      result: toolResultCapture.get(toolName) ?? null,
+                      approved: true
+                    });
+                  }
+                }
+              }
+            }
+            if (msg.type === "tool_use_summary" || msg.type === "result") {
+              for (const tc of toolCalls) {
+                if (tc.result === null) {
+                  const captured = toolResultCapture.get(tc.toolName);
+                  if (captured !== void 0) tc.result = captured;
+                }
+              }
+            }
+            if (msg.type === "result") {
+              if (msg.subtype === "success") {
+                const r = msg;
+                output = r.result;
+                usage = aggregateUsage(r.modelUsage);
+                if (this.isPersistent && r.session_id) {
+                  this._sessionId = r.session_id;
+                }
+              } else if (msg.is_error) {
+                const r = msg;
+                throw new Error(
+                  `Claude query failed: ${r.errors?.join("; ") ?? "unknown error"}`
+                );
+              }
+            }
+          }
+        } catch (retryError) {
+          if (this.isPersistent) this.clearPersistentSession();
+          if (signal.aborted) throw new AbortError();
+          throw retryError;
+        } finally {
+          this.activeQuery = null;
+        }
+        return {
+          output,
+          structuredOutput: void 0,
+          toolCalls,
+          messages: [
+            ...messages,
+            ...output !== null ? [{ role: "assistant", content: output }] : []
+          ],
+          usage
+        };
+      }
+      if (this.isPersistent) this.clearPersistentSession();
       throw e;
     } finally {
       this.activeQuery = null;
@@ -835,8 +920,98 @@ var ClaudeAgent = class extends BaseAgent {
         }
       }
     } catch (e) {
-      if (this.isPersistent) this.clearPersistentSession();
       if (signal.aborted) throw new AbortError();
+      if (isResuming && this.isPersistent) {
+        this.clearPersistentSession();
+        const retryPrompt = buildContextualPrompt(messages);
+        let retryOpts = this.buildQueryOptions(signal);
+        toolResultCapture.clear();
+        retryOpts = await this.buildMcpConfig(retryOpts, toolResultCapture);
+        retryOpts.outputFormat = {
+          type: "json_schema",
+          schema: jsonSchema
+        };
+        const retryQ = sdk.query({ prompt: retryPrompt, options: retryOpts });
+        this.activeQuery = retryQ;
+        toolCalls.length = 0;
+        output = null;
+        structuredOutput = void 0;
+        try {
+          for await (const msg of retryQ) {
+            if (msg.type === "assistant") {
+              const betaMessage = msg.message;
+              if (betaMessage?.content) {
+                for (const block of betaMessage.content) {
+                  if (block.type === "tool_use") {
+                    const toolName = stripMcpPrefix(block.name ?? "unknown");
+                    toolCalls.push({
+                      toolName,
+                      args: block.input ?? {},
+                      result: toolResultCapture.get(toolName) ?? null,
+                      approved: true
+                    });
+                  }
+                }
+              }
+            }
+            if (msg.type === "tool_use_summary" || msg.type === "result") {
+              for (const tc of toolCalls) {
+                if (tc.result === null) {
+                  const captured = toolResultCapture.get(tc.toolName);
+                  if (captured !== void 0) tc.result = captured;
+                }
+              }
+            }
+            if (msg.type === "result" && msg.subtype === "success") {
+              const r = msg;
+              output = r.result;
+              if (r.structured_output !== void 0) {
+                try {
+                  structuredOutput = schema.schema.parse(r.structured_output);
+                } catch {
+                  try {
+                    structuredOutput = schema.schema.parse(JSON.parse(r.result));
+                  } catch {
+                  }
+                }
+              } else if (r.result) {
+                try {
+                  const jsonMatch = r.result.match(/```(?:json)?\s*([\s\S]*?)```/);
+                  const raw = jsonMatch ? jsonMatch[1].trim() : r.result.trim();
+                  structuredOutput = schema.schema.parse(JSON.parse(raw));
+                } catch {
+                }
+              }
+              usage = aggregateUsage(r.modelUsage);
+              if (this.isPersistent && r.session_id) {
+                this._sessionId = r.session_id;
+              }
+            } else if (msg.type === "result" && msg.is_error) {
+              const r = msg;
+              throw new Error(
+                `Claude query failed: ${r.errors?.join("; ") ?? "unknown error"}`
+              );
+            }
+          }
+        } catch (retryError) {
+          if (this.isPersistent) this.clearPersistentSession();
+          if (signal.aborted) throw new AbortError();
+          throw retryError;
+        } finally {
+          this.activeQuery = null;
+        }
+        return {
+          output,
+          structuredOutput,
+          toolCalls,
+          messages: [
+            ...messages,
+            ...output !== null ? [{ role: "assistant", content: output }] : []
+          ],
+          usage
+        };
+      }
+      if (this.isPersistent) this.clearPersistentSession();
       throw e;
     } finally {
       this.activeQuery = null;
@@ -859,21 +1034,47 @@ var ClaudeAgent = class extends BaseAgent {
     const isResuming = this.isPersistent && this._sessionId !== void 0;
     const prompt = isResuming ? extractLastUserPrompt(messages) : buildContextualPrompt(messages);
     let opts = this.buildQueryOptions(signal);
-    opts = await this.buildMcpConfig(opts);
+    const toolResultCapture = /* @__PURE__ */ new Map();
+    opts = await this.buildMcpConfig(opts, toolResultCapture);
     const q = sdk.query({ prompt, options: opts });
     this.activeQuery = q;
     const thinkingBlockIndices = /* @__PURE__ */ new Set();
     const toolCallTracker = new ClaudeToolCallTracker();
+    const pendingStreamToolCalls = /* @__PURE__ */ new Map();
     try {
       for await (const msg of q) {
         if (signal.aborted) throw new AbortError();
         const events = mapSDKMessage(msg, thinkingBlockIndices, toolCallTracker);
         if (events) {
           const mapped = Array.isArray(events) ? events : [events];
-          for (const e of mapped) yield e;
+          for (const e of mapped) {
+            if (e.type === "tool_call_start") {
+              pendingStreamToolCalls.set(e.toolCallId, e.toolName);
+            }
+            if (e.type === "tool_call_end" && toolResultCapture.has(e.toolName)) {
+              e.result = toolResultCapture.get(e.toolName);
+              toolResultCapture.delete(e.toolName);
+              pendingStreamToolCalls.delete(e.toolCallId);
+            } else if (e.type === "tool_call_end") {
+              pendingStreamToolCalls.delete(e.toolCallId);
+            }
+            yield e;
+          }
         }
         if (msg.type === "result" && msg.subtype === "success") {
           const r = msg;
+          for (const [toolCallId, toolName] of pendingStreamToolCalls) {
+            if (toolResultCapture.has(toolName)) {
+              yield {
+                type: "tool_call_end",
+                toolCallId,
+                toolName,
+                result: toolResultCapture.get(toolName)
+              };
+              toolResultCapture.delete(toolName);
+            }
+          }
+          pendingStreamToolCalls.clear();
           if (r.session_id) {
             if (this.isPersistent) {
               this._sessionId = r.session_id;
@@ -884,8 +1085,71 @@ var ClaudeAgent = class extends BaseAgent {
         }
       }
     } catch (e) {
-      if (this.isPersistent) this.clearPersistentSession();
       if (signal.aborted) throw new AbortError();
+      if (isResuming && this.isPersistent) {
+        this.clearPersistentSession();
+        const retryPrompt = buildContextualPrompt(messages);
+        let retryOpts = this.buildQueryOptions(signal);
+        toolResultCapture.clear();
+        retryOpts = await this.buildMcpConfig(retryOpts, toolResultCapture);
+        const retryQ = sdk.query({ prompt: retryPrompt, options: retryOpts });
+        this.activeQuery = retryQ;
+        const retryThinkingBlockIndices = /* @__PURE__ */ new Set();
+        const retryToolCallTracker = new ClaudeToolCallTracker();
+        const retryPendingToolCalls = /* @__PURE__ */ new Map();
+        try {
+          for await (const msg of retryQ) {
+            if (signal.aborted) throw new AbortError();
+            const retryEvents = mapSDKMessage(msg, retryThinkingBlockIndices, retryToolCallTracker);
+            if (retryEvents) {
+              const mapped = Array.isArray(retryEvents) ? retryEvents : [retryEvents];
+              for (const ev of mapped) {
+                if (ev.type === "tool_call_start") {
+                  retryPendingToolCalls.set(ev.toolCallId, ev.toolName);
+                }
+                if (ev.type === "tool_call_end" && toolResultCapture.has(ev.toolName)) {
+                  ev.result = toolResultCapture.get(ev.toolName);
+                  toolResultCapture.delete(ev.toolName);
+                  retryPendingToolCalls.delete(ev.toolCallId);
+                } else if (ev.type === "tool_call_end") {
+                  retryPendingToolCalls.delete(ev.toolCallId);
+                }
+                yield ev;
+              }
+            }
+            if (msg.type === "result" && msg.subtype === "success") {
+              const r = msg;
+              for (const [toolCallId, toolName] of retryPendingToolCalls) {
+                if (toolResultCapture.has(toolName)) {
+                  yield {
+                    type: "tool_call_end",
+                    toolCallId,
+                    toolName,
+                    result: toolResultCapture.get(toolName)
+                  };
+                  toolResultCapture.delete(toolName);
+                }
+              }
+              retryPendingToolCalls.clear();
+              if (r.session_id) {
+                if (this.isPersistent) {
+                  this._sessionId = r.session_id;
+                }
+                yield this.emitSessionInfo(r.session_id);
+              }
+              yield { type: "done", finalOutput: r.result };
+            }
+          }
+        } catch (retryError) {
+          if (this.isPersistent) this.clearPersistentSession();
+          if (signal.aborted) throw new AbortError();
+          throw retryError;
+        } finally {
+          this.activeQuery = null;
+        }
+        return;
+      }
+      if (this.isPersistent) this.clearPersistentSession();
       throw e;
     } finally {
       this.activeQuery = null;
@@ -905,13 +1169,43 @@ function extractLastUserPrompt(messages) {
   }
   return "";
 }
+function serializeToolCall(tc) {
+  const args = typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args);
+  return `  Tool call: ${tc.name}(${args})`;
+}
+function serializeToolResult(tr) {
+  const result = typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
+  const prefix = tr.isError ? "[ERROR] " : "";
+  return `  ${tr.name} \u2192 ${prefix}${result}`;
+}
 function buildContextualPrompt(messages) {
   if (messages.length <= 1) {
     return extractLastUserPrompt(messages);
   }
   const history = messages.slice(0, -1).map((msg) => {
+    if (msg.role === "user") {
+      return `User: ${msg.content ? getTextContent(msg.content) : ""}`;
+    }
+    if (msg.role === "tool" && msg.toolResults) {
+      const results = msg.toolResults.map(serializeToolResult).join("\n");
+      return `Tool results:
+${results}`;
+    }
+    if (msg.role === "assistant") {
+      const parts = [];
+      const thinking = msg.thinking;
+      if (thinking) {
+        parts.push(`[reasoning: ${thinking}]`);
+      }
+      const text2 = msg.content ? getTextContent(msg.content) : "";
+      if (text2) parts.push(text2);
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        parts.push(msg.toolCalls.map(serializeToolCall).join("\n"));
+      }
+      return `Assistant: ${parts.join("\n")}`;
+    }
     const text = msg.content ? getTextContent(msg.content) : "";
-    return msg.role === "user" ? `User: ${text}` : `Assistant: ${text}`;
+    return `${msg.role}: ${text}`;
   }).join("\n");
   const lastPrompt = extractLastUserPrompt(messages);
   return `Conversation history: