@witqq/agent-sdk 0.1.0

package/dist/backends/claude.cjs

@@ -0,0 +1,718 @@
+'use strict';
+
+// src/types.ts
+function getTextContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+
+// src/errors.ts
+var AgentSDKError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "AgentSDKError";
+  }
+};
+var ReentrancyError = class extends AgentSDKError {
+  constructor() {
+    super("Agent is already running. Await the current run before starting another.");
+    this.name = "ReentrancyError";
+  }
+};
+var DisposedError = class extends AgentSDKError {
+  constructor(entity) {
+    super(`${entity} has been disposed and cannot be used.`);
+    this.name = "DisposedError";
+  }
+};
+var SubprocessError = class extends AgentSDKError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SubprocessError";
+  }
+};
+var AbortError = class extends AgentSDKError {
+  constructor() {
+    super("Agent run was aborted.");
+    this.name = "AbortError";
+  }
+};
+
+// src/base-agent.ts
+var BaseAgent = class {
+  state = "idle";
+  abortController = null;
+  config;
+  constructor(config) {
+    this.config = Object.freeze({ ...config });
+  }
+  // ─── Public Interface ─────────────────────────────────────────
+  async run(prompt, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "running";
+    try {
+      const messages = [{ role: "user", content: prompt }];
+      return await this.executeRun(messages, options, ac.signal);
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  async runWithContext(messages, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "running";
+    try {
+      return await this.executeRun(messages, options, ac.signal);
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  async runStructured(prompt, schema, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "running";
+    try {
+      const messages = [{ role: "user", content: prompt }];
+      return await this.executeRunStructured(
+        messages,
+        schema,
+        options,
+        ac.signal
+      );
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  async *stream(prompt, options) {
+    this.guardReentrancy();
+    this.guardDisposed();
+    const ac = this.createAbortController(options?.signal);
+    this.state = "streaming";
+    try {
+      const messages = [{ role: "user", content: prompt }];
+      yield* this.executeStream(messages, options, ac.signal);
+    } finally {
+      this.state = "idle";
+      this.abortController = null;
+    }
+  }
+  abort() {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  getConfig() {
+    return this.config;
+  }
+  /** Mark agent as disposed. Override to add cleanup. */
+  dispose() {
+    this.abort();
+    this.state = "disposed";
+  }
+  // ─── Guards ───────────────────────────────────────────────────
+  guardReentrancy() {
+    if (this.state === "running" || this.state === "streaming") {
+      throw new ReentrancyError();
+    }
+  }
+  guardDisposed() {
+    if (this.state === "disposed") {
+      throw new DisposedError("Agent");
+    }
+  }
+  /** Throw AbortError if signal is already aborted */
+  checkAbort(signal) {
+    if (signal.aborted) {
+      throw new AbortError();
+    }
+  }
+  // ─── Internal Helpers ─────────────────────────────────────────
+  createAbortController(externalSignal) {
+    const ac = new AbortController();
+    this.abortController = ac;
+    if (externalSignal) {
+      if (externalSignal.aborted) {
+        ac.abort();
+      } else {
+        externalSignal.addEventListener("abort", () => ac.abort(), {
+          once: true
+        });
+      }
+    }
+    return ac;
+  }
+};
+
+// src/utils/schema.ts
+function zodToJsonSchema(schema) {
+  const schemaAny = schema;
+  if ("jsonSchema" in schema && typeof schemaAny.jsonSchema === "function") {
+    return schemaAny.jsonSchema();
+  }
+  return extractSchemaFromDef(schema);
+}
+function extractSchemaFromDef(schema) {
+  const def = schema._def;
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return { type: "string" };
+    case "ZodNumber":
+      return { type: "number" };
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodNull":
+      return { type: "null" };
+    case "ZodArray":
+      return {
+        type: "array",
+        items: extractSchemaFromDef(def.type)
+      };
+    case "ZodObject": {
+      const shape = schema.shape;
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        const valueDef = value._def;
+        if (valueDef.typeName === "ZodOptional") {
+          properties[key] = extractSchemaFromDef(valueDef.innerType);
+        } else {
+          properties[key] = extractSchemaFromDef(value);
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+    case "ZodOptional":
+      return extractSchemaFromDef(def.innerType);
+    case "ZodEnum":
+      return { type: "string", enum: def.values };
+    default:
+      return {};
+  }
+}
+
+// src/backends/claude.ts
+var sdkModule = null;
+async function loadSDK() {
+  if (sdkModule) return sdkModule;
+  try {
+    sdkModule = await import('@anthropic-ai/claude-agent-sdk');
+    return sdkModule;
+  } catch {
+    throw new SubprocessError(
+      "@anthropic-ai/claude-agent-sdk is not installed. Install it: npm install @anthropic-ai/claude-agent-sdk"
+    );
+  }
+}
+function _injectSDK(mock) {
+  sdkModule = mock;
+}
+function _resetSDK() {
+  sdkModule = null;
+}
+var CLAUDE_KNOWN_MODELS = [
+  { id: "claude-sonnet-4-5-20250514", name: "Claude Sonnet 4.5" },
+  { id: "claude-haiku-3-5-20241022", name: "Claude 3.5 Haiku" },
+  { id: "claude-opus-4-20250514", name: "Claude Opus 4" },
+  { id: "claude-sonnet-4-20250514", name: "Claude Sonnet 4" }
+];
+function buildMcpServer(sdk, tools, toolResultCapture) {
+  if (tools.length === 0) return void 0;
+  const mcpTools = tools.map(
+    (tool) => sdk.tool(
+      tool.name,
+      tool.description ?? "",
+      zodToJsonSchema(tool.parameters),
+      async (args) => {
+        const result = await tool.execute(args);
+        if (toolResultCapture) {
+          toolResultCapture.set(tool.name, result);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: typeof result === "string" ? result : JSON.stringify(result)
+            }
+          ]
+        };
+      }
+    )
+  );
+  return sdk.createSdkMcpServer({
+    name: "agent-sdk-tools",
+    version: "1.0.0",
+    tools: mcpTools
+  });
+}
+function scopeToDestination(scope) {
+  switch (scope) {
+    case "once":
+      return "session";
+    case "session":
+      return "session";
+    case "project":
+      return "projectSettings";
+    case "always":
+      return "userSettings";
+  }
+}
+function destinationToScope(dest) {
+  switch (dest) {
+    case "session":
+    case "cliArg":
+      return "session";
+    case "projectSettings":
+    case "localSettings":
+      return "project";
+    case "userSettings":
+      return "always";
+  }
+}
+function extractSuggestedScope(suggestions) {
+  if (!suggestions || suggestions.length === 0) return void 0;
+  return destinationToScope(suggestions[0].destination);
+}
+function buildCanUseTool(config) {
+  const onPermission = config.supervisor?.onPermission;
+  if (!onPermission) return void 0;
+  const permissionStore = config.permissionStore;
+  return async (toolName, input, options) => {
+    if (permissionStore && await permissionStore.isApproved(toolName)) {
+      return {
+        behavior: "allow",
+        toolUseID: options.toolUseID
+      };
+    }
+    const unifiedRequest = {
+      toolName,
+      toolArgs: input,
+      suggestedScope: extractSuggestedScope(options.suggestions),
+      rawSDKRequest: { toolName, input, ...options }
+    };
+    const decision = await onPermission(
+      unifiedRequest,
+      options.signal
+    );
+    if (decision.allowed) {
+      if (permissionStore && decision.scope) {
+        await permissionStore.approve(toolName, decision.scope);
+      }
+      const result = {
+        behavior: "allow",
+        toolUseID: options.toolUseID
+      };
+      if (decision.modifiedInput) {
+        result.updatedInput = decision.modifiedInput;
+      }
+      if (decision.scope && decision.scope !== "once" && options.suggestions) {
+        result.updatedPermissions = options.suggestions.map((s) => ({
+          ...s,
+          destination: scopeToDestination(decision.scope)
+        }));
+      }
+      return result;
+    }
+    return {
+      behavior: "deny",
+      message: decision.reason ?? "Permission denied",
+      toolUseID: options.toolUseID
+    };
+  };
+}
+function aggregateUsage(modelUsage) {
+  let promptTokens = 0;
+  let completionTokens = 0;
+  for (const u of Object.values(modelUsage ?? {})) {
+    promptTokens += u.inputTokens ?? 0;
+    completionTokens += u.outputTokens ?? 0;
+  }
+  return { promptTokens, completionTokens };
+}
+function mapSDKMessage(msg, thinkingBlockIndices) {
+  switch (msg.type) {
+    case "assistant": {
+      const betaMessage = msg.message;
+      if (!betaMessage?.content) return null;
+      const events = [];
+      const textParts = betaMessage.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("");
+      if (textParts) {
+        events.push({ type: "text_delta", text: textParts });
+      }
+      for (const block of betaMessage.content) {
+        if (block.type === "tool_use") {
+          events.push({
+            type: "tool_call_start",
+            toolName: block.name ?? "unknown",
+            args: block.input ?? {}
+          });
+        }
+      }
+      return events.length > 0 ? events : null;
+    }
+    case "user": {
+      const toolResult = msg.tool_use_result;
+      if (toolResult !== void 0) {
+        return null;
+      }
+      return null;
+    }
+    case "tool_use_summary": {
+      const summary = msg.summary;
+      const toolName = msg.tool_name ?? "unknown";
+      if (summary) {
+        return {
+          type: "tool_call_end",
+          toolName,
+          result: summary
+        };
+      }
+      return null;
+    }
+    case "stream_event": {
+      const event = msg.event;
+      if (!event) return null;
+      if (event.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
+        return { type: "text_delta", text: event.delta.text };
+      }
+      if (event.type === "content_block_start" && event.content_block?.type === "thinking") {
+        if (thinkingBlockIndices && event.index !== void 0) {
+          thinkingBlockIndices.add(event.index);
+        }
+        return { type: "thinking_start" };
+      }
+      if (event.type === "content_block_stop" && event.index !== void 0 && thinkingBlockIndices?.has(event.index)) {
+        thinkingBlockIndices.delete(event.index);
+        return { type: "thinking_end" };
+      }
+      return null;
+    }
+    case "tool_progress": {
+      const toolName = msg.tool_name;
+      return toolName ? { type: "tool_call_start", toolName, args: {} } : null;
+    }
+    case "result": {
+      if (msg.subtype === "success") {
+        const r = msg;
+        return {
+          type: "usage_update",
+          ...aggregateUsage(r.modelUsage)
+        };
+      }
+      if (msg.is_error) {
+        const r = msg;
+        return {
+          type: "error",
+          error: r.errors?.join("; ") ?? "Unknown error",
+          recoverable: false
+        };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+var ClaudeAgent = class extends BaseAgent {
+  options;
+  tools;
+  canUseTool;
+  constructor(config, options) {
+    super(config);
+    this.options = options;
+    this.tools = config.tools;
+    this.canUseTool = buildCanUseTool(config);
+    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."
+      );
+    }
+  }
+  buildQueryOptions(signal) {
+    const ac = new AbortController();
+    signal.addEventListener("abort", () => ac.abort(), { once: true });
+    const opts = {
+      abortController: ac,
+      model: this.config.model,
+      maxTurns: this.options.maxTurns,
+      cwd: this.options.workingDirectory,
+      pathToClaudeCodeExecutable: this.options.cliPath,
+      persistSession: false,
+      includePartialMessages: true,
+      canUseTool: this.canUseTool
+    };
+    if (this.config.systemPrompt) {
+      opts.systemPrompt = this.config.systemPrompt;
+    }
+    return opts;
+  }
+  async buildMcpConfig(opts, toolResultCapture) {
+    if (this.tools.length === 0) return opts;
+    const sdk = await loadSDK();
+    const mcpServer = buildMcpServer(sdk, this.tools, toolResultCapture);
+    if (mcpServer) {
+      opts.mcpServers = {
+        "agent-sdk-tools": mcpServer
+      };
+    }
+    return opts;
+  }
+  // ─── executeRun ─────────────────────────────────────────────────
+  async executeRun(messages, _options, signal) {
+    this.checkAbort(signal);
+    const sdk = await loadSDK();
+    const prompt = extractLastUserPrompt(messages);
+    let opts = this.buildQueryOptions(signal);
+    const toolResultCapture = /* @__PURE__ */ new Map();
+    opts = await this.buildMcpConfig(opts, toolResultCapture);
+    const q = sdk.query({ prompt, options: opts });
+    const toolCalls = [];
+    let output = null;
+    let usage;
+    try {
+      for await (const msg of q) {
+        if (msg.type === "assistant") {
+          const betaMessage = msg.message;
+          if (betaMessage?.content) {
+            for (const block of betaMessage.content) {
+              if (block.type === "tool_use") {
+                const toolName = 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);
+          } else if (msg.is_error) {
+            const r = msg;
+            throw new Error(
+              `Claude query failed: ${r.errors?.join("; ") ?? "unknown error"}`
+            );
+          }
+        }
+      }
+    } catch (e) {
+      if (signal.aborted) throw new AbortError();
+      throw e;
+    }
+    return {
+      output,
+      structuredOutput: void 0,
+      toolCalls,
+      messages: [
+        ...messages,
+        ...output !== null ? [{ role: "assistant", content: output }] : []
+      ],
+      usage
+    };
+  }
+  // ─── executeRunStructured ───────────────────────────────────────
+  async executeRunStructured(messages, schema, _options, signal) {
+    this.checkAbort(signal);
+    const sdk = await loadSDK();
+    const prompt = extractLastUserPrompt(messages);
+    let opts = this.buildQueryOptions(signal);
+    opts = await this.buildMcpConfig(opts);
+    const jsonSchema = zodToJsonSchema(schema.schema);
+    opts.outputFormat = {
+      type: "json_schema",
+      schema: jsonSchema
+    };
+    const q = sdk.query({ prompt, options: opts });
+    const toolCalls = [];
+    let output = null;
+    let structuredOutput;
+    let usage;
+    try {
+      for await (const msg of q) {
+        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);
+        } else if (msg.type === "result" && msg.is_error) {
+          const r = msg;
+          throw new Error(
+            `Claude query failed: ${r.errors?.join("; ") ?? "unknown error"}`
+          );
+        }
+      }
+    } catch (e) {
+      if (signal.aborted) throw new AbortError();
+      throw e;
+    }
+    return {
+      output,
+      structuredOutput,
+      toolCalls,
+      messages: [
+        ...messages,
+        ...output !== null ? [{ role: "assistant", content: output }] : []
+      ],
+      usage
+    };
+  }
+  // ─── executeStream ──────────────────────────────────────────────
+  async *executeStream(messages, _options, signal) {
+    this.checkAbort(signal);
+    const sdk = await loadSDK();
+    const prompt = extractLastUserPrompt(messages);
+    let opts = this.buildQueryOptions(signal);
+    opts = await this.buildMcpConfig(opts);
+    const q = sdk.query({ prompt, options: opts });
+    const thinkingBlockIndices = /* @__PURE__ */ new Set();
+    try {
+      for await (const msg of q) {
+        if (signal.aborted) throw new AbortError();
+        const event = mapSDKMessage(msg, thinkingBlockIndices);
+        if (event) {
+          if (Array.isArray(event)) {
+            for (const e of event) yield e;
+          } else {
+            yield event;
+          }
+        }
+        if (msg.type === "result" && msg.subtype === "success") {
+          const r = msg;
+          yield { type: "done", finalOutput: r.result };
+        }
+      }
+    } catch (e) {
+      if (signal.aborted) throw new AbortError();
+      throw e;
+    }
+  }
+  dispose() {
+    super.dispose();
+  }
+};
+function extractLastUserPrompt(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "user") {
+      return getTextContent(msg.content);
+    }
+  }
+  return "";
+}
+var ClaudeAgentService = class {
+  name = "claude";
+  disposed = false;
+  options;
+  cachedModels = null;
+  constructor(options) {
+    this.options = options;
+  }
+  createAgent(config) {
+    if (this.disposed) throw new DisposedError("ClaudeAgentService");
+    return new ClaudeAgent(config, this.options);
+  }
+  async listModels() {
+    if (this.disposed) throw new DisposedError("ClaudeAgentService");
+    if (this.cachedModels) return this.cachedModels;
+    this.cachedModels = CLAUDE_KNOWN_MODELS.map((m) => ({
+      id: m.id,
+      name: m.name,
+      provider: "claude"
+    }));
+    return this.cachedModels;
+  }
+  async validate() {
+    if (this.disposed) throw new DisposedError("ClaudeAgentService");
+    const errors = [];
+    try {
+      await loadSDK();
+    } catch (e) {
+      errors.push(
+        e instanceof Error ? e.message : String(e)
+      );
+      return { valid: false, errors };
+    }
+    try {
+      const sdk = await loadSDK();
+      const q = sdk.query({
+        prompt: "echo test",
+        options: {
+          model: CLAUDE_KNOWN_MODELS[0].id,
+          pathToClaudeCodeExecutable: this.options.cliPath,
+          cwd: this.options.workingDirectory,
+          persistSession: false,
+          maxTurns: 1,
+          permissionMode: "plan"
+        }
+      });
+      const first = await q.next();
+      q.close();
+      if (first.done) {
+        errors.push("Claude CLI returned no messages \u2014 may not be authenticated.");
+      }
+    } catch (e) {
+      errors.push(
+        `Failed to connect to Claude CLI: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.cachedModels = null;
+  }
+};
+function createClaudeService(options) {
+  return new ClaudeAgentService(options);
+}
+
+exports._injectSDK = _injectSDK;
+exports._resetSDK = _resetSDK;
+exports.createClaudeService = createClaudeService;
+//# sourceMappingURL=claude.cjs.map
+//# sourceMappingURL=claude.cjs.map