@robota-sdk/agent-sdk 3.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Robota Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# @robota-sdk/agent-sdk
+
+Programmatic SDK for building AI agents with Robota. Provides a single `query()` entry point along with Session management, built-in tools, permissions, hooks, streaming, and context loading.
+
+This is the **assembly layer** of the Robota ecosystem -- it composes lower-level packages (`agent-core`, `agent-tools`, `agent-sessions`) into a cohesive SDK.
+
+## Installation
+
+```bash
+npm install @robota-sdk/agent-sdk
+# or
+pnpm add @robota-sdk/agent-sdk
+```
+
+## Quick Start
+
+```typescript
+import { query } from '@robota-sdk/agent-sdk';
+
+// Simple one-shot query
+const response = await query('Show me the file list');
+
+// With options
+const response = await query('Analyze the code', {
+  cwd: '/path/to/project',
+  permissionMode: 'acceptEdits',
+  maxTurns: 10,
+  onTextDelta: (delta) => process.stdout.write(delta),
+});
+```
+
+## Features
+
+- **query()** -- Single entry point for AI agent interactions with streaming support
+- **Session** -- Wraps the Robota engine with permission checks, tool wiring, history, and streaming
+- **Built-in Tools** -- Bash, Read, Write, Edit, Glob, Grep (from `@robota-sdk/agent-tools`)
+- **Agent Tool** -- Sub-agent session creation for multi-agent workflows
+- **Permissions** -- 3-step evaluation (deny list, allow list, mode policy) with four modes: `plan`, `default`, `acceptEdits`, `bypassPermissions`
+- **Hooks** -- `PreToolUse`, `PostToolUse`, `SessionStart`, `Stop` events with shell command execution
+- **Streaming** -- Real-time text delta callbacks via `onTextDelta`
+- **Context Loading** -- AGENTS.md / CLAUDE.md walk-up discovery and system prompt assembly
+- **Config Loading** -- 3-layer merge (user global, project, local) with `$ENV:VAR` substitution
+- **Context Window Management** -- Token tracking, auto-compaction at ~83.5%, manual `session.compact()`
+
+## Architecture
+
+```
+agent-sdk (assembly layer)
+  -> agent-sessions  (Session, SessionStore)
+  -> agent-tools     (tool infrastructure + 6 built-in tools)
+  -> agent-core      (Robota engine, providers, permissions, hooks)
+```
+
+`agent-sdk` assembles existing packages -- it does not re-implement functionality that belongs in lower layers.
+
+## Session Usage
+
+```typescript
+import { Session } from '@robota-sdk/agent-sessions';
+
+const session = new Session({ config, context, terminal, permissionMode });
+const response = await session.run('Hello');
+session.getHistory();
+session.clearHistory();
+```
+
+## Documentation
+
+See [docs/SPEC.md](./docs/SPEC.md) for the full specification, architecture details, and design decisions.
+
+## License
+
+MIT

package/dist/node/index.cjs

@@ -0,0 +1,576 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Session: () => import_agent_sessions.Session,
+  SessionStore: () => import_agent_sessions2.SessionStore,
+  TRUST_TO_MODE: () => import_agent_core.TRUST_TO_MODE,
+  agentTool: () => agentTool,
+  bashTool: () => import_agent_tools.bashTool,
+  buildSystemPrompt: () => buildSystemPrompt,
+  detectProject: () => detectProject,
+  editTool: () => import_agent_tools4.editTool,
+  evaluatePermission: () => import_agent_core2.evaluatePermission,
+  globTool: () => import_agent_tools5.globTool,
+  grepTool: () => import_agent_tools6.grepTool,
+  loadConfig: () => loadConfig,
+  loadContext: () => loadContext,
+  promptForApproval: () => promptForApproval,
+  query: () => query,
+  readTool: () => import_agent_tools2.readTool,
+  runHooks: () => import_agent_core3.runHooks,
+  setAgentToolDeps: () => setAgentToolDeps,
+  writeTool: () => import_agent_tools3.writeTool
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var import_agent_core = require("@robota-sdk/agent-core");
+
+// src/session.ts
+var import_agent_sessions = require("@robota-sdk/agent-sessions");
+
+// src/session-store.ts
+var import_agent_sessions2 = require("@robota-sdk/agent-sessions");
+
+// src/config/config-loader.ts
+var import_fs = require("fs");
+var import_path = require("path");
+
+// src/config/config-types.ts
+var import_zod = require("zod");
+var ProviderSchema = import_zod.z.object({
+  name: import_zod.z.string().optional(),
+  model: import_zod.z.string().optional(),
+  apiKey: import_zod.z.string().optional()
+});
+var PermissionsSchema = import_zod.z.object({
+  /** Patterns that are always approved without prompting */
+  allow: import_zod.z.array(import_zod.z.string()).optional(),
+  /** Patterns that are always denied */
+  deny: import_zod.z.array(import_zod.z.string()).optional()
+});
+var EnvSchema = import_zod.z.record(import_zod.z.string()).optional();
+var HookDefinitionSchema = import_zod.z.object({
+  type: import_zod.z.literal("command"),
+  command: import_zod.z.string()
+});
+var HookGroupSchema = import_zod.z.object({
+  matcher: import_zod.z.string(),
+  hooks: import_zod.z.array(HookDefinitionSchema)
+});
+var HooksSchema = import_zod.z.object({
+  PreToolUse: import_zod.z.array(HookGroupSchema).optional(),
+  PostToolUse: import_zod.z.array(HookGroupSchema).optional(),
+  SessionStart: import_zod.z.array(HookGroupSchema).optional(),
+  Stop: import_zod.z.array(HookGroupSchema).optional()
+}).optional();
+var SettingsSchema = import_zod.z.object({
+  /** Trust level used when no --permission-mode flag is given */
+  defaultTrustLevel: import_zod.z.enum(["safe", "moderate", "full"]).optional(),
+  provider: ProviderSchema.optional(),
+  permissions: PermissionsSchema.optional(),
+  env: EnvSchema,
+  hooks: HooksSchema
+});
+
+// src/config/config-loader.ts
+function getHomeDir() {
+  return process.env.HOME ?? process.env.USERPROFILE ?? "/";
+}
+var DEFAULTS = {
+  defaultTrustLevel: "moderate",
+  provider: {
+    name: "anthropic",
+    model: "claude-opus-4-5",
+    apiKey: void 0
+  },
+  permissions: {
+    allow: [],
+    deny: []
+  },
+  env: {}
+};
+function readJsonFile(filePath) {
+  if (!(0, import_fs.existsSync)(filePath)) {
+    return void 0;
+  }
+  const raw = (0, import_fs.readFileSync)(filePath, "utf-8");
+  return JSON.parse(raw);
+}
+function resolveEnvRef(value) {
+  const ENV_PREFIX = "$ENV:";
+  if (value.startsWith(ENV_PREFIX)) {
+    const varName = value.slice(ENV_PREFIX.length);
+    return process.env[varName] ?? value;
+  }
+  return value;
+}
+function resolveEnvRefs(settings) {
+  if (settings.provider?.apiKey !== void 0) {
+    return {
+      ...settings,
+      provider: {
+        ...settings.provider,
+        apiKey: resolveEnvRef(settings.provider.apiKey)
+      }
+    };
+  }
+  return settings;
+}
+function mergeSettings(layers) {
+  return layers.reduce((merged, layer) => {
+    return {
+      ...merged,
+      ...layer,
+      provider: merged.provider !== void 0 || layer.provider !== void 0 ? { ...merged.provider, ...layer.provider } : void 0,
+      permissions: merged.permissions !== void 0 || layer.permissions !== void 0 ? {
+        allow: layer.permissions?.allow ?? merged.permissions?.allow,
+        deny: layer.permissions?.deny ?? merged.permissions?.deny
+      } : void 0,
+      env: {
+        ...merged.env ?? {},
+        ...layer.env ?? {}
+      }
+    };
+  }, {});
+}
+function toResolvedConfig(merged) {
+  return {
+    defaultTrustLevel: merged.defaultTrustLevel ?? DEFAULTS.defaultTrustLevel,
+    provider: {
+      name: merged.provider?.name ?? DEFAULTS.provider.name,
+      model: merged.provider?.model ?? DEFAULTS.provider.model,
+      apiKey: merged.provider?.apiKey ?? DEFAULTS.provider.apiKey
+    },
+    permissions: {
+      allow: merged.permissions?.allow ?? DEFAULTS.permissions.allow,
+      deny: merged.permissions?.deny ?? DEFAULTS.permissions.deny
+    },
+    env: merged.env ?? DEFAULTS.env,
+    hooks: merged.hooks ?? void 0
+  };
+}
+async function loadConfig(cwd) {
+  const userSettingsPath = (0, import_path.join)(getHomeDir(), ".robota", "settings.json");
+  const projectSettingsPath = (0, import_path.join)(cwd, ".robota", "settings.json");
+  const localSettingsPath = (0, import_path.join)(cwd, ".robota", "settings.local.json");
+  const rawLayers = [
+    readJsonFile(userSettingsPath),
+    readJsonFile(projectSettingsPath),
+    readJsonFile(localSettingsPath)
+  ].filter((v) => v !== void 0);
+  const parsedLayers = rawLayers.map((raw, index) => {
+    const result = SettingsSchema.safeParse(raw);
+    if (!result.success) {
+      const paths = [userSettingsPath, projectSettingsPath, localSettingsPath].filter(
+        (_, i) => rawLayers[i] !== void 0
+      );
+      throw new Error(`Invalid settings in ${paths[index] ?? "unknown"}: ${result.error.message}`);
+    }
+    return resolveEnvRefs(result.data);
+  });
+  const merged = mergeSettings(parsedLayers);
+  return toResolvedConfig(merged);
+}
+
+// src/context/context-loader.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var AGENTS_FILENAME = "AGENTS.md";
+var CLAUDE_FILENAME = "CLAUDE.md";
+function collectFilesWalkingUp(startDir, filename) {
+  const found = [];
+  let current = (0, import_path2.resolve)(startDir);
+  let atRoot = false;
+  while (!atRoot) {
+    const candidate = (0, import_path2.join)(current, filename);
+    if ((0, import_fs2.existsSync)(candidate)) {
+      found.push(candidate);
+    }
+    const parent = (0, import_path2.dirname)(current);
+    atRoot = parent === current;
+    if (!atRoot) {
+      current = parent;
+    }
+  }
+  return found.reverse();
+}
+function extractCompactInstructions(content) {
+  const lines = content.split("\n");
+  let capturing = false;
+  let headingLevel = 0;
+  const captured = [];
+  for (const line of lines) {
+    const headingMatch = /^(#{1,6})\s+/.exec(line);
+    if (headingMatch) {
+      if (capturing) {
+        if (headingMatch[1].length <= headingLevel) break;
+      }
+      if (/compact\s+instructions/i.test(line)) {
+        capturing = true;
+        headingLevel = headingMatch[1].length;
+        continue;
+      }
+    }
+    if (capturing) {
+      captured.push(line);
+    }
+  }
+  const result = captured.join("\n").trim();
+  return result || void 0;
+}
+async function loadContext(cwd) {
+  const agentsPaths = collectFilesWalkingUp(cwd, AGENTS_FILENAME);
+  const claudePaths = collectFilesWalkingUp(cwd, CLAUDE_FILENAME);
+  const agentsMd = agentsPaths.map((p) => (0, import_fs2.readFileSync)(p, "utf-8")).join("\n\n");
+  const claudeMd = claudePaths.map((p) => (0, import_fs2.readFileSync)(p, "utf-8")).join("\n\n");
+  const compactInstructions = extractCompactInstructions(claudeMd);
+  return { agentsMd, claudeMd, compactInstructions };
+}
+
+// src/context/project-detector.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+function tryReadJson(filePath) {
+  if (!(0, import_fs3.existsSync)(filePath)) return void 0;
+  try {
+    return JSON.parse((0, import_fs3.readFileSync)(filePath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function detectPackageManager(cwd) {
+  if ((0, import_fs3.existsSync)((0, import_path3.join)(cwd, "pnpm-workspace.yaml")) || (0, import_fs3.existsSync)((0, import_path3.join)(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if ((0, import_fs3.existsSync)((0, import_path3.join)(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if ((0, import_fs3.existsSync)((0, import_path3.join)(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if ((0, import_fs3.existsSync)((0, import_path3.join)(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  return void 0;
+}
+async function detectProject(cwd) {
+  const pkgJsonPath = (0, import_path3.join)(cwd, "package.json");
+  const tsconfigPath = (0, import_path3.join)(cwd, "tsconfig.json");
+  const pyprojectPath = (0, import_path3.join)(cwd, "pyproject.toml");
+  const cargoPath = (0, import_path3.join)(cwd, "Cargo.toml");
+  const goModPath = (0, import_path3.join)(cwd, "go.mod");
+  if ((0, import_fs3.existsSync)(pkgJsonPath)) {
+    const pkgJson = tryReadJson(pkgJsonPath);
+    const language = (0, import_fs3.existsSync)(tsconfigPath) ? "typescript" : "javascript";
+    const packageManager = detectPackageManager(cwd);
+    return {
+      type: "node",
+      name: pkgJson?.name,
+      packageManager,
+      language
+    };
+  }
+  if ((0, import_fs3.existsSync)(pyprojectPath) || (0, import_fs3.existsSync)((0, import_path3.join)(cwd, "setup.py"))) {
+    return {
+      type: "python",
+      language: "python"
+    };
+  }
+  if ((0, import_fs3.existsSync)(cargoPath)) {
+    return {
+      type: "rust",
+      language: "rust"
+    };
+  }
+  if ((0, import_fs3.existsSync)(goModPath)) {
+    return {
+      type: "go",
+      language: "go"
+    };
+  }
+  return {
+    type: "unknown",
+    language: "unknown"
+  };
+}
+
+// src/context/system-prompt-builder.ts
+var TRUST_LEVEL_DESCRIPTIONS = {
+  safe: "safe (read-only / plan mode \u2014 only read-access tools are available)",
+  moderate: "moderate (default mode \u2014 write and bash tools require approval)",
+  full: "full (acceptEdits mode \u2014 file writes are auto-approved; bash requires approval)"
+};
+function buildProjectSection(info) {
+  const lines = ["## Current Project"];
+  if (info.name !== void 0) {
+    lines.push(`- **Name:** ${info.name}`);
+  }
+  if (info.type !== "unknown") {
+    lines.push(`- **Type:** ${info.type}`);
+  }
+  if (info.language !== "unknown") {
+    lines.push(`- **Language:** ${info.language}`);
+  }
+  if (info.packageManager !== void 0) {
+    lines.push(`- **Package manager:** ${info.packageManager}`);
+  }
+  return lines.join("\n");
+}
+function buildToolsSection(descriptions) {
+  if (descriptions.length === 0) {
+    return "";
+  }
+  const lines = ["## Available Tools", ...descriptions.map((d) => `- ${d}`)];
+  return lines.join("\n");
+}
+function buildSystemPrompt(params) {
+  const { agentsMd, claudeMd, toolDescriptions, trustLevel, projectInfo } = params;
+  const sections = [];
+  sections.push(
+    [
+      "## Role",
+      "You are an AI coding assistant with access to tools that let you read and modify code.",
+      "You help developers understand, write, and improve their codebase.",
+      "Always be precise, follow existing code conventions, and prefer minimal changes."
+    ].join("\n")
+  );
+  sections.push(buildProjectSection(projectInfo));
+  sections.push(
+    [
+      "## Permission Mode",
+      `Your current trust level is **${TRUST_LEVEL_DESCRIPTIONS[trustLevel]}**.`
+    ].join("\n")
+  );
+  if (agentsMd.trim().length > 0) {
+    sections.push(["## Agent Instructions", agentsMd].join("\n"));
+  }
+  if (claudeMd.trim().length > 0) {
+    sections.push(["## Project Notes", claudeMd].join("\n"));
+  }
+  sections.push(
+    [
+      "## Web Search",
+      "You have access to web search. When the user asks to search, look up, or find current/latest information,",
+      "you MUST use the web_search tool. Do NOT answer from training data when the user explicitly asks to search.",
+      "Always prefer web search for: news, latest versions, current events, live documentation."
+    ].join("\n")
+  );
+  const toolsSection = buildToolsSection(toolDescriptions);
+  if (toolsSection.length > 0) {
+    sections.push(toolsSection);
+  }
+  return sections.join("\n\n");
+}
+
+// src/query.ts
+var import_agent_sessions3 = require("@robota-sdk/agent-sessions");
+
+// src/permissions/permission-prompt.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var PERMISSION_OPTIONS = ["Allow", "Deny"];
+var ALLOW_INDEX = 0;
+function formatArgs(toolArgs) {
+  const entries = Object.entries(toolArgs);
+  if (entries.length === 0) {
+    return "(no arguments)";
+  }
+  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
+}
+async function promptForApproval(terminal, toolName, toolArgs) {
+  terminal.writeLine("");
+  terminal.writeLine(import_chalk.default.yellow(`[Permission Required] Tool: ${toolName}`));
+  terminal.writeLine(import_chalk.default.dim(`  ${formatArgs(toolArgs)}`));
+  terminal.writeLine("");
+  const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
+  return selected === ALLOW_INDEX;
+}
+
+// src/query.ts
+async function query(prompt, options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const [config, context, projectInfo] = await Promise.all([
+    loadConfig(cwd),
+    loadContext(cwd),
+    detectProject(cwd)
+  ]);
+  const noopTerminal = {
+    write: () => {
+    },
+    writeLine: () => {
+    },
+    writeMarkdown: () => {
+    },
+    writeError: () => {
+    },
+    prompt: () => Promise.resolve(""),
+    select: () => Promise.resolve(0),
+    spinner: () => ({ stop: () => {
+    }, update: () => {
+    } })
+  };
+  const session = new import_agent_sessions3.Session({
+    config,
+    context,
+    terminal: noopTerminal,
+    projectInfo,
+    permissionMode: options?.permissionMode ?? "bypassPermissions",
+    maxTurns: options?.maxTurns,
+    provider: options?.provider,
+    permissionHandler: options?.permissionHandler,
+    onTextDelta: options?.onTextDelta,
+    onCompact: options?.onCompact,
+    compactInstructions: context.compactInstructions,
+    systemPromptBuilder: buildSystemPrompt,
+    promptForApproval
+  });
+  return session.run(prompt);
+}
+
+// src/permissions/permission-gate.ts
+var import_agent_core2 = require("@robota-sdk/agent-core");
+
+// src/hooks/hook-runner.ts
+var import_agent_core3 = require("@robota-sdk/agent-core");
+
+// src/tools/bash-tool.ts
+var import_agent_tools = require("@robota-sdk/agent-tools");
+
+// src/tools/read-tool.ts
+var import_agent_tools2 = require("@robota-sdk/agent-tools");
+
+// src/tools/write-tool.ts
+var import_agent_tools3 = require("@robota-sdk/agent-tools");
+
+// src/tools/edit-tool.ts
+var import_agent_tools4 = require("@robota-sdk/agent-tools");
+
+// src/tools/glob-tool.ts
+var import_agent_tools5 = require("@robota-sdk/agent-tools");
+
+// src/tools/grep-tool.ts
+var import_agent_tools6 = require("@robota-sdk/agent-tools");
+
+// src/tools/agent-tool.ts
+var import_zod2 = require("zod");
+var import_agent_tools7 = require("@robota-sdk/agent-tools");
+var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
+function asZodSchema(schema) {
+  return schema;
+}
+var AgentSchema = import_zod2.z.object({
+  prompt: import_zod2.z.string().describe("Task description for the sub-agent"),
+  description: import_zod2.z.string().optional().describe("Short description of what the sub-agent will do (3-5 words)")
+});
+var agentToolDeps;
+function setAgentToolDeps(deps) {
+  agentToolDeps = deps;
+}
+async function runAgent(args) {
+  if (!agentToolDeps) {
+    const result = {
+      success: false,
+      output: "",
+      error: "Agent tool not initialized \u2014 missing dependencies"
+    };
+    return JSON.stringify(result);
+  }
+  const subSession = new import_agent_sessions4.Session({
+    config: agentToolDeps.config,
+    context: agentToolDeps.context,
+    projectInfo: agentToolDeps.projectInfo,
+    // No terminal needed — sub-agents don't prompt for permissions
+    terminal: {
+      write: () => {
+      },
+      writeLine: () => {
+      },
+      writeMarkdown: () => {
+      },
+      writeError: () => {
+      },
+      prompt: () => Promise.resolve(""),
+      select: () => Promise.resolve(0),
+      spinner: () => ({ stop: () => {
+      }, update: () => {
+      } })
+    },
+    // Sub-agents bypass permissions — they inherit parent's trust
+    permissionMode: "bypassPermissions"
+  });
+  try {
+    const response = await subSession.run(args.prompt);
+    const result = {
+      success: true,
+      output: response
+    };
+    return JSON.stringify(result);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const result = {
+      success: false,
+      output: "",
+      error: `Sub-agent error: ${message}`
+    };
+    return JSON.stringify(result);
+  }
+}
+var agentTool = (0, import_agent_tools7.createZodFunctionTool)(
+  "Agent",
+  "Spawn a sub-agent with isolated context to handle a task. The sub-agent has its own conversation history and can use all tools.",
+  asZodSchema(AgentSchema),
+  async (params) => {
+    return runAgent(params);
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Session,
+  SessionStore,
+  TRUST_TO_MODE,
+  agentTool,
+  bashTool,
+  buildSystemPrompt,
+  detectProject,
+  editTool,
+  evaluatePermission,
+  globTool,
+  grepTool,
+  loadConfig,
+  loadContext,
+  promptForApproval,
+  query,
+  readTool,
+  runHooks,
+  setAgentToolDeps,
+  writeTool
+});