@caspian2026/agent-sdk 0.0.2 → 0.0.3

package/dist/sdk/query.js

@@ -0,0 +1,372 @@
+// @bun
+import {
+  __require
+} from "../chunk-qp2qdcda.js";
+
+// src/entrypoints/sdk/query.ts
+import { spawn } from "child_process";
+import { createInterface } from "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 = 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 = 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(() => {});
+  }
+}
+export {
+  query
+};

package/package.json

@@ -1,11 +1,19 @@
 {
   "name": "@caspian2026/agent-sdk",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "AI-powered agent SDK for the terminal",
   "type": "module",
   "engines": {
     "bun": ">=1.2.0"
   },
+  "main": "dist/sdk/query.cjs",
+  "exports": {
+    ".": {
+      "import": "./dist/sdk/query.js",
+      "require": "./dist/sdk/query.cjs",
+      "default": "./dist/sdk/query.cjs"
+    }
+  },
   "bin": {
     "ccb": "dist/cli.js",
     "agent-sdk": "dist/cli.js"
@@ -40,7 +48,6 @@
     "@ant/computer-use-input": "workspace:*",
     "@ant/computer-use-mcp": "workspace:*",
     "@ant/computer-use-swift": "workspace:*",
-    "@anthropic-ai/claude-agent-sdk": "^0.2.87",
     "@anthropic-ai/mcpb": "^2.1.2",
     "@anthropic-ai/sandbox-runtime": "^0.0.44",
     "@anthropic-ai/sdk": "^0.80.0",

package/dist/{chunk-tp2jxmcx.js → chunk-tr9rx7f4.js}

@@ -13,10 +13,6 @@ import {
   normalizePathForConfigKey,
   sanitizePath
 } from "./chunk-1ax1znzj.js";
-import {
-  getProxyFetchOptions,
-  init_proxy
-} from "./chunk-wha6v7za.js";
 import {
   count,
   init_array,
@@ -32,6 +28,10 @@ import {
   init_lazySchema,
   lazySchema
 } from "./chunk-64c1avct.js";
+import {
+  getProxyFetchOptions,
+  init_proxy
+} from "./chunk-wha6v7za.js";
 import {
   init_v4,
   v4_default