@caspian2026/agent-sdk 0.0.2 → 0.0.4

package/dist/sdk/query.cjs

@@ -0,0 +1,407 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/entrypoints/sdk/query.ts
+var exports_query = {};
+__export(exports_query, {
+  query: () => query
+});
+module.exports = __toCommonJS(exports_query);
+var import_node_child_process = require("node:child_process");
+var import_node_readline = require("node:readline");
+var require_ = require;
+function resolveCliPath(options) {
+  if (options.pathToClaudeCodeExecutable) {
+    return options.pathToClaudeCodeExecutable;
+  }
+  try {
+    return require_.resolve("@caspian2026/agent-sdk/dist/cli.js");
+  } catch {
+    throw new Error("Cannot resolve CLI path. Set options.pathToClaudeCodeExecutable or install @caspian2026/agent-sdk.");
+  }
+}
+function buildCliArgs(options) {
+  const args = ["-p", "--output-format", "stream-json", "--input-format", "stream-json", "--verbose"];
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  if (options.resume) {
+    args.push("--resume", options.resume);
+  }
+  if (options.continue) {
+    args.push("--continue");
+  }
+  if (options.permissionMode) {
+    args.push("--permission-mode", options.permissionMode);
+  }
+  if (options.maxTurns !== undefined) {
+    args.push("--max-turns", String(options.maxTurns));
+  }
+  if (options.maxBudgetUsd !== undefined) {
+    args.push("--max-budget-usd", String(options.maxBudgetUsd));
+  }
+  if (options.thinking) {
+    args.push("--thinking", options.thinking);
+  }
+  if (options.allowedTools?.length) {
+    args.push("--allowed-tools", ...options.allowedTools);
+  }
+  if (options.includePartialMessages) {
+    args.push("--include-partial-messages");
+  }
+  if (options.allowDangerouslySkipPermissions) {
+    args.push("--dangerously-skip-permissions");
+  }
+  if (options.permissionPromptToolName) {
+    args.push("--permission-prompt-tool", options.permissionPromptToolName);
+  }
+  if (options.plugins?.length) {
+    for (const plugin of options.plugins) {
+      args.push("--plugin-dir", plugin.path);
+    }
+  }
+  if (options.additionalDirectories?.length) {
+    args.push("--add-dir", ...options.additionalDirectories);
+  }
+  if (options.settingSources?.length) {
+    args.push("--setting-sources", ...options.settingSources);
+  }
+  if (typeof options.systemPrompt === "string") {
+    args.push("--system-prompt", options.systemPrompt);
+  } else if (options.systemPrompt && typeof options.systemPrompt === "object") {
+    if (options.systemPrompt.type === "preset" && options.systemPrompt.append) {
+      args.push("--append-system-prompt", options.systemPrompt.append);
+    }
+  }
+  if (options.fallbackModel) {
+    args.push("--fallback-model", options.fallbackModel);
+  }
+  if (options.mcpServers && Object.keys(options.mcpServers).length > 0) {
+    args.push("--mcp-config", JSON.stringify(options.mcpServers));
+  }
+  if (options.extraArgs) {
+    for (const [key, value] of Object.entries(options.extraArgs)) {
+      if (value === null) {
+        args.push(key);
+      } else {
+        args.push(key, value);
+      }
+    }
+  }
+  return args;
+}
+function ndjsonParse(line) {
+  if (!line.trim())
+    return;
+  return JSON.parse(line);
+}
+function ndjsonStringify(obj) {
+  return JSON.stringify(obj) + `
+`;
+}
+function buildHookCallbackMap(hooks) {
+  const map = new Map;
+  if (!hooks)
+    return map;
+  for (const [_event, matchers] of Object.entries(hooks)) {
+    if (!matchers)
+      continue;
+    for (const matcher of matchers) {
+      for (const hook of matcher.hooks) {
+        const id = `hook_${_event}_${matcher.matcher || "all"}_${map.size}`;
+        map.set(id, { callback: hook, timeout: matcher.timeout });
+      }
+    }
+  }
+  return map;
+}
+function buildHooksConfig(hooks) {
+  if (!hooks)
+    return;
+  const config = {};
+  for (const [event, matchers] of Object.entries(hooks)) {
+    if (!matchers)
+      continue;
+    const eventHooks = [];
+    for (const matcher of matchers) {
+      const callbackIds = [];
+      for (let i = 0;i < matcher.hooks.length; i++) {
+        callbackIds.push(`hook_${event}_${matcher.matcher || "all"}_${eventHooks.length * matcher.hooks.length + i}`);
+      }
+      eventHooks.push({
+        matcher: matcher.matcher,
+        hookCallbackIds: callbackIds,
+        timeout: matcher.timeout
+      });
+    }
+    if (eventHooks.length > 0) {
+      config[event] = eventHooks;
+    }
+  }
+  return Object.keys(config).length > 0 ? config : undefined;
+}
+async function* query(params) {
+  const { prompt, options } = params;
+  const abortController = options.abortController ?? new AbortController;
+  const signal = abortController.signal;
+  const cliPath = resolveCliPath(options);
+  const cliArgs = buildCliArgs(options);
+  const cliDir = options.cwd ?? process.cwd();
+  const env = {
+    ...process.env,
+    ...options.env,
+    ELECTRON_RUN_AS_NODE: "1"
+  };
+  const child = import_node_child_process.spawn(process.execPath, [cliPath, ...cliArgs], {
+    cwd: cliDir,
+    env,
+    stdio: ["pipe", "pipe", "pipe"],
+    signal
+  });
+  const stdin = child.stdin;
+  const stdout = child.stdout;
+  const stderr = child.stderr;
+  if (options.stderr) {
+    stderr.on("data", (chunk) => {
+      options.stderr(chunk.toString());
+    });
+  } else {
+    stderr.resume();
+  }
+  const hookCallbacks = buildHookCallbackMap(options.hooks);
+  const pendingControlRequests = new Map;
+  const hooksConfig = buildHooksConfig(options.hooks);
+  if (hooksConfig) {
+    const initRequestId = "sdk-init-hooks";
+    const initRequest = {
+      type: "control_request",
+      request_id: initRequestId,
+      request: {
+        subtype: "initialize",
+        hooks: hooksConfig
+      }
+    };
+    stdin.write(ndjsonStringify(initRequest));
+  }
+  const promptQueue = [];
+  async function writePrompt() {
+    if (typeof prompt === "string") {
+      const msg = {
+        type: "user",
+        content: prompt,
+        uuid: "",
+        session_id: "",
+        message: { role: "user", content: prompt },
+        parent_tool_use_id: null
+      };
+      stdin.write(ndjsonStringify(msg));
+    } else {
+      for await (const userMsg of prompt) {
+        if (signal.aborted)
+          break;
+        stdin.write(ndjsonStringify(userMsg));
+      }
+    }
+  }
+  const promptPromise = writePrompt().catch((err) => {
+    if (!signal.aborted) {
+      throw err;
+    }
+  });
+  const rl = import_node_readline.createInterface({ input: stdout });
+  async function handleControlRequest(msg) {
+    const { request_id, request } = msg;
+    try {
+      switch (request.subtype) {
+        case "can_use_tool": {
+          if (!options.canUseTool) {
+            const response2 = {
+              type: "control_response",
+              response: { subtype: "success", request_id, response: { behavior: "deny", message: "No permission handler configured" } }
+            };
+            stdin.write(ndjsonStringify(response2));
+            break;
+          }
+          const toolName = request.tool_name;
+          const toolInput = request.input ?? {};
+          const toolUseID = request.tool_use_id;
+          const suggestions = request.permission_suggestions;
+          const blockedPath = request.blocked_path;
+          const decisionReason = request.decision_reason;
+          const agentID = request.agent_id;
+          const result = await options.canUseTool(toolName, toolInput, {
+            signal,
+            suggestions,
+            blockedPath,
+            decisionReason,
+            toolUseID,
+            agentID
+          });
+          const response = {
+            type: "control_response",
+            response: {
+              subtype: "success",
+              request_id,
+              response: result
+            }
+          };
+          stdin.write(ndjsonStringify(response));
+          break;
+        }
+        case "hook_callback": {
+          const callbackId = request.callback_id;
+          const hookInput = request.input;
+          const toolUseId = request.tool_use_id;
+          const hookEntry = hookCallbacks.get(callbackId);
+          if (hookEntry) {
+            const result = await hookEntry.callback(hookInput, toolUseId, { signal });
+            const response = {
+              type: "control_response",
+              response: {
+                subtype: "success",
+                request_id,
+                response: result
+              }
+            };
+            stdin.write(ndjsonStringify(response));
+          } else {
+            const response = {
+              type: "control_response",
+              response: {
+                subtype: "success",
+                request_id,
+                response: {}
+              }
+            };
+            stdin.write(ndjsonStringify(response));
+          }
+          break;
+        }
+        case "initialize": {
+          const response = {
+            type: "control_response",
+            response: { subtype: "success", request_id, response: {} }
+          };
+          stdin.write(ndjsonStringify(response));
+          break;
+        }
+        default: {
+          const response = {
+            type: "control_response",
+            response: { subtype: "success", request_id, response: {} }
+          };
+          stdin.write(ndjsonStringify(response));
+        }
+      }
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      const response = {
+        type: "control_response",
+        response: { subtype: "error", request_id, error: errorMsg }
+      };
+      try {
+        stdin.write(ndjsonStringify(response));
+      } catch {}
+    }
+  }
+  try {
+    for await (const line of rl) {
+      if (signal.aborted)
+        break;
+      let msg;
+      try {
+        msg = ndjsonParse(line);
+      } catch {
+        continue;
+      }
+      if (!msg || typeof msg !== "object")
+        continue;
+      const typed = msg;
+      switch (typed.type) {
+        case "control_request": {
+          handleControlRequest(typed).catch(() => {});
+          break;
+        }
+        case "control_response": {
+          const resp = typed;
+          const pending = pendingControlRequests.get(resp.response.request_id);
+          if (pending) {
+            pendingControlRequests.delete(resp.response.request_id);
+            if (resp.response.subtype === "error") {
+              pending.reject(new Error(resp.response.error));
+            } else {
+              pending.resolve(resp.response);
+            }
+          }
+          break;
+        }
+        case "control_cancel_request": {
+          const cancel = typed;
+          const pending = pendingControlRequests.get(cancel.request_id);
+          if (pending) {
+            pendingControlRequests.delete(cancel.request_id);
+            pending.reject(new Error("Request cancelled"));
+          }
+          break;
+        }
+        case "keep_alive": {
+          stdin.write(ndjsonStringify({ type: "keep_alive" }));
+          break;
+        }
+        default: {
+          if (typed.type === "assistant" || typed.type === "user" || typed.type === "system" || typed.type === "result" || typed.type === "stream_event" || typed.type === "tool_progress") {
+            yield typed;
+          }
+        }
+      }
+    }
+  } finally {
+    rl.close();
+    try {
+      stdin.end();
+    } catch {}
+    if (!child.killed) {
+      child.kill();
+    }
+    for (const pending of pendingControlRequests.values()) {
+      pending.reject(new Error("Query ended"));
+    }
+    pendingControlRequests.clear();
+    await promptPromise.catch(() => {});
+  }
+}