@agent-api/sdk 1.1.5 → 1.2.1

package/dist/local/shell.js

@@ -0,0 +1,318 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+export class HostLocalShellRunner {
+    cwd;
+    shell;
+    timeoutMs;
+    maxOutputBytes;
+    env;
+    constructor(options = {}) {
+        this.cwd = path.resolve(options.cwd ?? process.cwd());
+        this.shell = options.shell ?? true;
+        this.timeoutMs = positiveInteger(options.timeoutMs, 2 * 60 * 1000, "timeoutMs");
+        this.maxOutputBytes = positiveInteger(options.maxOutputBytes, 128 * 1024, "maxOutputBytes");
+        this.env = { ...process.env, ...(options.env ?? {}) };
+    }
+    async run(request, context = {}) {
+        const command = requiredString(request.command, "command");
+        const cwd = resolveContainedPath(this.cwd, request.workdir);
+        const timeoutMs = request.timeoutMs == null
+            ? this.timeoutMs
+            : positiveInteger(request.timeoutMs, this.timeoutMs, "timeoutMs");
+        const started = Date.now();
+        const stdout = new BoundedText(this.maxOutputBytes);
+        const stderr = new BoundedText(this.maxOutputBytes);
+        let timedOut = false;
+        return await new Promise((resolve, reject) => {
+            const child = spawn(command, [], {
+                cwd,
+                env: { ...this.env, ...(request.env ?? {}) },
+                shell: this.shell,
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            let settled = false;
+            const finish = (exitCode, signal) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                context.signal?.removeEventListener("abort", abort);
+                const stdoutText = stdout.text();
+                const stderrText = stderr.text();
+                const output = [stdoutText, stderrText].filter(Boolean).join(stderrText ? "\n" : "");
+                resolve({
+                    ok: true,
+                    command,
+                    description: request.description,
+                    cwd,
+                    exit_code: exitCode,
+                    signal,
+                    stdout: stdoutText,
+                    stderr: stderrText,
+                    output: output || "(no output)",
+                    duration_ms: Date.now() - started,
+                    timed_out: timedOut,
+                    truncated: stdout.truncated || stderr.truncated,
+                });
+            };
+            const kill = () => {
+                if (child.killed)
+                    return;
+                child.kill(process.platform === "win32" ? undefined : "SIGTERM");
+                setTimeout(() => {
+                    if (!child.killed)
+                        child.kill(process.platform === "win32" ? undefined : "SIGKILL");
+                }, 3000).unref();
+            };
+            const abort = () => {
+                kill();
+            };
+            const timer = setTimeout(() => {
+                timedOut = true;
+                kill();
+            }, timeoutMs);
+            timer.unref();
+            if (context.signal?.aborted) {
+                abort();
+            }
+            else {
+                context.signal?.addEventListener("abort", abort, { once: true });
+            }
+            child.stdout?.on("data", (chunk) => stdout.append(chunk));
+            child.stderr?.on("data", (chunk) => stderr.append(chunk));
+            child.on("error", (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                context.signal?.removeEventListener("abort", abort);
+                reject(error);
+            });
+            child.on("close", finish);
+        });
+    }
+}
+export class LocalShellDriver {
+    accessMode;
+    runner;
+    constructor(options = {}) {
+        const cwd = options.workdir?.root ?? options.cwd;
+        this.accessMode = options.accessMode ?? "approval";
+        this.runner = options.runner ?? new HostLocalShellRunner({
+            cwd,
+            shell: options.shell,
+            timeoutMs: options.timeoutMs,
+            maxOutputBytes: options.maxOutputBytes,
+        });
+    }
+    async dispatch(args, context = {}) {
+        const request = shellRequest(args);
+        if (this.accessMode !== "full") {
+            return shellApprovalRequired(request);
+        }
+        return shellToolResult(await this.runner.run(request, context));
+    }
+    requiresApproval() {
+        return this.accessMode !== "full";
+    }
+}
+export function createLocalShellToolRegistry(options = {}) {
+    const toolName = options.toolName ?? "local_shell";
+    const driver = new LocalShellDriver(options);
+    const hostRunner = driver.runner instanceof HostLocalShellRunner ? driver.runner : undefined;
+    const definition = localShellToolDefinition(toolName, {
+        accessMode: driver.accessMode,
+        cwd: options.workdir?.root ?? hostRunner?.cwd ?? options.cwd,
+        shell: hostRunner?.shell ?? options.shell,
+        timeoutMs: hostRunner?.timeoutMs ?? options.timeoutMs,
+        maxOutputBytes: hostRunner?.maxOutputBytes ?? options.maxOutputBytes,
+    });
+    return {
+        accessMode: driver.accessMode,
+        toolName,
+        definitions: () => [{ ...definition }],
+        handlers: () => ({ [toolName]: (args) => driver.dispatch(args) }),
+        execute: async (name, args, context = {}) => {
+            if (name !== toolName) {
+                throw new Error(`unknown local shell tool: ${name}`);
+            }
+            return await driver.dispatch(args, context);
+        },
+        requiresApproval: (name) => name === toolName && driver.requiresApproval(),
+    };
+}
+export function localShellToolDefinition(name = "local_shell", options = {}) {
+    return {
+        type: "function",
+        name,
+        description: localShellToolDescription(options),
+        parameters: localShellToolParameters(),
+        strict: false,
+    };
+}
+export function localShellToolInstructions(options = {}) {
+    return localShellToolDescription(options);
+}
+function localShellToolDescription(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const shell = shellDisplayName(options.shell);
+    const accessMode = options.accessMode ?? "approval";
+    const cwd = options.cwd ? path.resolve(options.cwd) : undefined;
+    const timeoutMs = options.timeoutMs ?? 2 * 60 * 1000;
+    const maxOutputBytes = options.maxOutputBytes ?? 128 * 1024;
+    return [
+        "Run a local shell command through one model-facing primitive.",
+        "Prefer local_workdir for file discovery, reading, and editing. Use local_shell for package managers, tests, build commands, git, and other process-level tasks.",
+        `Execution environment: platform=${platform}; shell=${shell}; access_mode=${accessMode}; default_timeout_ms=${timeoutMs}; max_output_bytes=${maxOutputBytes}.`,
+        cwd ? `Default cwd: ${cwd}. Relative command paths resolve from this cwd unless workdir is set.` : "Relative command paths resolve from the configured cwd unless workdir is set.",
+        "The workdir parameter must be a relative child path of the configured cwd. Use workdir instead of cd when possible.",
+        "Absolute paths inside the command are permitted by the host OS if the user/process has permission; this tool is not a filesystem sandbox or security sandbox.",
+        "Captured stdout/stderr may be truncated when output exceeds the advertised max_output_bytes.",
+        "In approval mode, calls return requires_approval instead of executing. In full mode, commands execute immediately.",
+        shellGuidance(platform, options.shell),
+    ].filter(Boolean).join(" ");
+}
+function localShellToolParameters() {
+    return {
+        type: "object",
+        properties: {
+            command: {
+                type: "string",
+                description: "Shell command to execute. Keep it focused and quote paths containing spaces.",
+            },
+            description: {
+                type: "string",
+                description: "Short human-readable description of why this command is being run.",
+            },
+            workdir: {
+                type: "string",
+                description: "Optional relative working directory. Use this instead of cd. Absolute paths are rejected by the default host runner.",
+            },
+            timeout_ms: {
+                type: "integer",
+                description: "Optional timeout in milliseconds.",
+            },
+        },
+        required: ["command"],
+        additionalProperties: false,
+    };
+}
+function shellRequest(args) {
+    return {
+        command: requiredString(args.command, "command"),
+        description: optionalString(args.description, "description"),
+        workdir: optionalString(args.workdir, "workdir"),
+        timeoutMs: optionalNumber(args.timeoutMs ?? args.timeout_ms, "timeout_ms"),
+    };
+}
+function shellApprovalRequired(request) {
+    return {
+        ok: false,
+        requires_approval: true,
+        action: "run",
+        command: request.command,
+        description: request.description,
+        workdir: request.workdir,
+        timeout_ms: request.timeoutMs,
+        message: "local_shell command execution requires approval",
+    };
+}
+function shellToolResult(result) {
+    return {
+        ...result,
+        action: "run",
+    };
+}
+function resolveContainedPath(root, child) {
+    if (!child)
+        return root;
+    if (path.isAbsolute(child)) {
+        throw new Error("workdir must be relative to the configured local shell cwd");
+    }
+    const resolved = path.resolve(root, child);
+    const relative = path.relative(root, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("workdir must stay inside the configured local shell cwd");
+    }
+    return resolved;
+}
+function requiredString(value, name) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${name} must be a non-empty string`);
+    }
+    return value;
+}
+function optionalString(value, name) {
+    if (value == null || value === "")
+        return undefined;
+    if (typeof value !== "string") {
+        throw new Error(`${name} must be a string`);
+    }
+    return value;
+}
+function optionalNumber(value, name) {
+    if (value == null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`${name} must be a number`);
+    }
+    return Math.trunc(value);
+}
+function positiveInteger(value, fallback, name) {
+    if (value == null)
+        return fallback;
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        throw new Error(`${name} must be a positive number`);
+    }
+    return Math.trunc(value);
+}
+function shellDisplayName(shell) {
+    if (typeof shell === "string" && shell.trim())
+        return shell;
+    if (shell === false)
+        return "direct process execution";
+    if (process.platform === "win32")
+        return "cmd.exe";
+    return "/bin/sh";
+}
+function shellGuidance(platform, shell) {
+    const name = typeof shell === "string" ? path.basename(shell).toLowerCase() : shellDisplayName(shell).toLowerCase();
+    if (platform === "win32" || name.includes("powershell") || name === "pwsh") {
+        return "On Windows/PowerShell, prefer PowerShell-compatible commands and quote paths with spaces.";
+    }
+    if (name.includes("cmd.exe") || name === "cmd") {
+        return "On cmd.exe, prefer cmd-compatible syntax and use && only for dependent command chaining.";
+    }
+    return "On POSIX shells, prefer portable shell syntax, quote paths with spaces, and use && only when later commands depend on earlier success.";
+}
+class BoundedText {
+    maxBytes;
+    chunks = [];
+    size = 0;
+    truncated = false;
+    constructor(maxBytes) {
+        this.maxBytes = maxBytes;
+    }
+    append(chunk) {
+        this.chunks.push(chunk);
+        this.size += chunk.byteLength;
+        while (this.size > this.maxBytes && this.chunks.length > 1) {
+            const removed = this.chunks.shift();
+            if (!removed)
+                break;
+            this.size -= removed.byteLength;
+            this.truncated = true;
+        }
+        if (this.size > this.maxBytes && this.chunks.length === 1) {
+            const current = this.chunks[0];
+            this.chunks[0] = current.subarray(current.byteLength - this.maxBytes);
+            this.size = this.chunks[0].byteLength;
+            this.truncated = true;
+        }
+    }
+    text() {
+        const value = Buffer.concat(this.chunks, this.size).toString("utf8");
+        return this.truncated ? `...output truncated...\n${value}` : value;
+    }
+}

package/dist/local/tools.d.ts

@@ -1,27 +1,27 @@
 import type { FunctionTool } from "../types/tools.js";
-import type { LocalWorkspace } from "./core.js";
-export type LocalWorkspaceAccessMode = "approval" | "full";
-export type LocalWorkspaceAction = "summarize" | "list" | "search" | "grep" | "read" | "read_lines" | "context" | "snapshot" | "classify_path" | "preview_edits" | "apply_edits" | "write" | "mkdir" | "delete";
-export interface LocalWorkspaceToolRegistryOptions {
-    accessMode?: LocalWorkspaceAccessMode;
+import type { LocalWorkdir } from "./core.js";
+export type LocalWorkdirAccessMode = "approval" | "full";
+export type LocalWorkdirAction = "summarize" | "list" | "search" | "grep" | "read" | "read_lines" | "context" | "snapshot" | "classify_path" | "preview_edits" | "apply_edits" | "write" | "mkdir" | "delete";
+export interface LocalWorkdirToolRegistryOptions {
+    accessMode?: LocalWorkdirAccessMode;
     toolName?: string;
 }
-export interface LocalWorkspaceToolRegistry {
-    readonly workspace: LocalWorkspace;
-    readonly accessMode: LocalWorkspaceAccessMode;
+export interface LocalWorkdirToolRegistry {
+    readonly workdir: LocalWorkdir;
+    readonly accessMode: LocalWorkdirAccessMode;
     readonly toolName: string;
     definitions(): FunctionTool[];
     handlers(): Record<string, (args: Record<string, unknown>) => Promise<Record<string, unknown>>>;
     execute(name: string, args: Record<string, unknown>): Promise<Record<string, unknown>>;
     requiresApproval(name: string, args?: Record<string, unknown>): boolean;
 }
-export interface LocalWorkspaceDriverOptions {
-    accessMode?: LocalWorkspaceAccessMode;
+export interface LocalWorkdirDriverOptions {
+    accessMode?: LocalWorkdirAccessMode;
 }
-export declare class LocalWorkspaceDriver {
-    readonly workspace: LocalWorkspace;
-    readonly accessMode: LocalWorkspaceAccessMode;
-    constructor(workspace: LocalWorkspace, options?: LocalWorkspaceDriverOptions);
+export declare class LocalWorkdirDriver {
+    readonly workdir: LocalWorkdir;
+    readonly accessMode: LocalWorkdirAccessMode;
+    constructor(workdir: LocalWorkdir, options?: LocalWorkdirDriverOptions);
     dispatch(args: Record<string, unknown>): Promise<Record<string, unknown>>;
     requiresApproval(args: Record<string, unknown>): boolean;
     private dispatchApplyEdits;
@@ -29,6 +29,6 @@ export declare class LocalWorkspaceDriver {
     private dispatchMkdir;
     private dispatchDelete;
 }
-export declare function createLocalWorkspaceToolRegistry(workspace: LocalWorkspace, options?: LocalWorkspaceToolRegistryOptions): LocalWorkspaceToolRegistry;
-export declare function localWorkspaceToolDefinition(name?: string): FunctionTool;
-export declare function localWorkspaceToolInstructions(): string;
+export declare function createLocalWorkdirToolRegistry(workdir: LocalWorkdir, options?: LocalWorkdirToolRegistryOptions): LocalWorkdirToolRegistry;
+export declare function localWorkdirToolDefinition(name?: string): FunctionTool;
+export declare function localWorkdirToolInstructions(): string;

package/dist/local/tools.js

@@ -1,34 +1,34 @@
 import { createLocalContextPackage } from "./context.js";
-export class LocalWorkspaceDriver {
-    workspace;
+export class LocalWorkdirDriver {
+    workdir;
     accessMode;
-    constructor(workspace, options = {}) {
-        this.workspace = workspace;
+    constructor(workdir, options = {}) {
+        this.workdir = workdir;
         this.accessMode = options.accessMode ?? "approval";
     }
     async dispatch(args) {
-        const action = workspaceAction(args);
+        const action = workdirAction(args);
         switch (action) {
             case "summarize":
-                return localToolResult(action, localSummaryResult(await this.workspace.summarize(summaryArgs(args))));
+                return localToolResult(action, localSummaryResult(await this.workdir.summarize(summaryArgs(args))));
             case "list":
-                return localToolResult(action, await this.workspace.listEntries(optionalStringArg(args, "path") ?? ".", listArgs(args)));
+                return localToolResult(action, await this.workdir.listEntries(optionalStringArg(args, "path") ?? ".", listArgs(args)));
             case "search":
-                return localToolResult(action, await this.workspace.searchEntries(searchEntriesArgs(args)));
+                return localToolResult(action, await this.workdir.searchEntries(searchEntriesArgs(args)));
             case "grep":
-                return localToolResult(action, await this.workspace.grep(grepArgs(args)));
+                return localToolResult(action, await this.workdir.grep(grepArgs(args)));
             case "read":
-                return localToolResult(action, await this.workspace.readFile(stringArg(args, "path"), readFileArgs(args)));
+                return localToolResult(action, await this.workdir.readFile(stringArg(args, "path"), readFileArgs(args)));
             case "read_lines":
-                return localToolResult(action, await this.workspace.readLines(stringArg(args, "path"), readLinesArgs(args)));
+                return localToolResult(action, await this.workdir.readLines(stringArg(args, "path"), readLinesArgs(args)));
             case "context":
-                return localToolResult(action, await createLocalContextPackage(this.workspace, contextPackageArgs(args)));
+                return localToolResult(action, await createLocalContextPackage(this.workdir, contextPackageArgs(args)));
             case "snapshot":
-                return localToolResult(action, await this.workspace.snapshot(snapshotArgs(args)));
+                return localToolResult(action, await this.workdir.snapshot(snapshotArgs(args)));
             case "classify_path":
-                return localToolResult(action, this.workspace.classifyPath(stringArg(args, "path")));
+                return localToolResult(action, this.workdir.classifyPath(stringArg(args, "path")));
             case "preview_edits":
-                return localToolResult(action, await this.workspace.previewEdits(editsArg(args)));
+                return localToolResult(action, await this.workdir.previewEdits(editsArg(args)));
             case "apply_edits":
                 return await this.dispatchApplyEdits(args);
             case "write":
@@ -38,73 +38,73 @@ export class LocalWorkspaceDriver {
             case "delete":
                 return await this.dispatchDelete(args);
             default:
-                throw new Error(`unsupported local_workspace action: ${action}`);
+                throw new Error(`unsupported local_workdir action: ${action}`);
         }
     }
     requiresApproval(args) {
         if (this.accessMode === "full") {
             return false;
         }
-        return mutatingLocalWorkspaceActions.has(workspaceAction(args));
+        return mutatingLocalWorkdirActions.has(workdirAction(args));
     }
     async dispatchApplyEdits(args) {
         const edits = editsArg(args);
         if (this.accessMode !== "full") {
-            return approvalRequired("apply_edits", args, await this.workspace.previewEdits(edits));
+            return approvalRequired("apply_edits", args, await this.workdir.previewEdits(edits));
         }
-        return localToolResult("apply_edits", await this.workspace.applyEdits(edits));
+        return localToolResult("apply_edits", await this.workdir.applyEdits(edits));
     }
     async dispatchWrite(args) {
         if (this.accessMode !== "full") {
             return approvalRequired("write", args);
         }
-        return localToolResult("write", await this.workspace.writeText(stringArg(args, "path"), stringArg(args, "content")));
+        return localToolResult("write", await this.workdir.writeText(stringArg(args, "path"), stringArg(args, "content")));
     }
     async dispatchMkdir(args) {
         if (this.accessMode !== "full") {
             return approvalRequired("mkdir", args);
         }
-        return localToolResult("mkdir", await this.workspace.createDirectory(stringArg(args, "path")));
+        return localToolResult("mkdir", await this.workdir.createDirectory(stringArg(args, "path")));
     }
     async dispatchDelete(args) {
         if (this.accessMode !== "full") {
             return approvalRequired("delete", args);
         }
-        return localToolResult("delete", await this.workspace.deletePath(stringArg(args, "path")));
+        return localToolResult("delete", await this.workdir.deletePath(stringArg(args, "path")));
     }
 }
-export function createLocalWorkspaceToolRegistry(workspace, options = {}) {
-    const toolName = options.toolName ?? "local_workspace";
-    const driver = new LocalWorkspaceDriver(workspace, { accessMode: options.accessMode });
-    const definition = localWorkspaceToolDefinition(toolName);
+export function createLocalWorkdirToolRegistry(workdir, options = {}) {
+    const toolName = options.toolName ?? "local_workdir";
+    const driver = new LocalWorkdirDriver(workdir, { accessMode: options.accessMode });
+    const definition = localWorkdirToolDefinition(toolName);
     return {
-        workspace,
+        workdir,
         accessMode: driver.accessMode,
         toolName,
         definitions: () => [{ ...definition }],
         handlers: () => ({ [toolName]: (args) => driver.dispatch(args) }),
         execute: async (name, args) => {
             if (name !== toolName) {
-                throw new Error(`unknown local workspace tool: ${name}`);
+                throw new Error(`unknown local workdir tool: ${name}`);
             }
             return await driver.dispatch(args);
         },
         requiresApproval: (name, args = {}) => name === toolName && driver.requiresApproval(args),
     };
 }
-export function localWorkspaceToolDefinition(name = "local_workspace") {
+export function localWorkdirToolDefinition(name = "local_workdir") {
     return {
         type: "function",
         name,
-        description: localWorkspaceToolDescription,
-        parameters: localWorkspaceToolParameters(),
+        description: localWorkdirToolDescription,
+        parameters: localWorkdirToolParameters(),
         strict: false,
     };
 }
-export function localWorkspaceToolInstructions() {
-    return localWorkspaceToolDescription;
+export function localWorkdirToolInstructions() {
+    return localWorkdirToolDescription;
 }
-const localWorkspaceActions = [
+const localWorkdirActions = [
     "summarize",
     "list",
     "search",
@@ -120,24 +120,24 @@ const localWorkspaceActions = [
     "mkdir",
     "delete",
 ];
-const mutatingLocalWorkspaceActions = new Set([
+const mutatingLocalWorkdirActions = new Set([
     "apply_edits",
     "write",
     "mkdir",
     "delete",
 ]);
-const localWorkspaceToolDescription = [
-    "Inspect and modify the selected local workspace through one model-facing primitive.",
+const localWorkdirToolDescription = [
+    "Inspect and modify the selected local workdir through one model-facing primitive.",
     "Use action=list/search/grep/summarize/context to discover files, read/read_lines for file content, preview_edits before edits, and apply_edits/write/mkdir/delete only when mutation is intended.",
     "In approval mode, mutating actions return requires_approval with a safe preview instead of changing files. In full mode, mutating actions execute immediately.",
-    "Paths are relative to the selected local workspace; never use absolute paths.",
+    "Paths are relative to the selected local workdir; never use absolute paths.",
 ].join(" ");
-function localWorkspaceToolParameters() {
+function localWorkdirToolParameters() {
     return objectSchema({
         action: {
             type: "string",
-            enum: localWorkspaceActions,
-            description: "Workspace operation. Prefer summarize/list/search/grep before reading or editing. Prefer read_lines and apply_edits for source changes.",
+            enum: localWorkdirActions,
+            description: "Workdir operation. Prefer summarize/list/search/grep before reading or editing. Prefer read_lines and apply_edits for source changes.",
         },
         path: stringSchema("Relative path. File path for read/write/delete/edit actions; directory base for list/search/grep/summarize/context/snapshot."),
         query: stringSchema("Path/name query for search, or optional context query."),
@@ -168,17 +168,17 @@ function localWorkspaceToolParameters() {
             max_bytes_per_file: integerSchema("Maximum bytes per file."),
             max_previews: integerSchema("Maximum summary previews."),
             include_content: booleanSchema("Include file contents in context packages."),
-            include_summary: booleanSchema("Include workspace summary in context packages."),
+            include_summary: booleanSchema("Include workdir summary in context packages."),
             include_search: booleanSchema("Include grep results in context packages when query is set."),
             include_secrets: booleanSchema("Include likely secret file contents in context packages."),
             hash: booleanSchema("Include SHA-256 hashes in snapshots."),
         }),
     }, ["action"]);
 }
-function workspaceAction(args) {
+function workdirAction(args) {
     const value = stringArg(args, "action").trim().toLowerCase();
-    if (!localWorkspaceActions.includes(value)) {
-        throw new Error(`unsupported local_workspace action: ${value}`);
+    if (!localWorkdirActions.includes(value)) {
+        throw new Error(`unsupported local_workdir action: ${value}`);
     }
     return value;
 }
@@ -345,7 +345,7 @@ function approvalRequired(action, args, preview) {
         requires_approval: true,
         arguments: args,
         preview,
-        message: `local_workspace action ${action} requires approval`,
+        message: `local_workdir action ${action} requires approval`,
     };
 }
 function objectSchema(properties, required = []) {

package/dist/node.d.ts

@@ -1,8 +1,8 @@
 export * from "./index.js";
 export { NodeAgentAPI } from "./node-client.js";
 export { NodeSkillsResource } from "./resources/skills-node.js";
-export { LocalWorkspaceDriver, createLocalWorkspaceToolRegistry, localWorkspaceToolDefinition, localWorkspaceToolInstructions, } from "./local/tools.js";
-export type { LocalWorkspaceAction, LocalWorkspaceAccessMode, LocalWorkspaceToolRegistry, LocalWorkspaceToolRegistryOptions, } from "./local/tools.js";
+export { createLocalShellToolRegistry, LocalWorkdirDriver, HostLocalShellRunner, LocalShellDriver, localShellToolDefinition, localShellToolInstructions, createLocalWorkdirToolRegistry, localWorkdirToolDefinition, localWorkdirToolInstructions, } from "./local/index.js";
+export type { LocalCommandRunner, LocalShellAccessMode, LocalShellContext, LocalShellRequest, LocalShellResult, LocalShellToolRegistry, LocalShellToolRegistryOptions, LocalWorkdirAction, LocalWorkdirAccessMode, LocalWorkdirToolRegistry, LocalWorkdirToolRegistryOptions, } from "./local/index.js";
 export { localSkillFromDirectory, pendingLocalSkillCalls, runLocalSkillHandlers } from "./local-skills.js";
 export type { LocalSkillDirectoryOptions } from "./local-skills.js";
 export * from "./local/index.js";

package/dist/node.js

@@ -1,6 +1,6 @@
 export * from "./index.js";
 export { NodeAgentAPI } from "./node-client.js";
 export { NodeSkillsResource } from "./resources/skills-node.js";
-export { LocalWorkspaceDriver, createLocalWorkspaceToolRegistry, localWorkspaceToolDefinition, localWorkspaceToolInstructions, } from "./local/tools.js";
+export { createLocalShellToolRegistry, LocalWorkdirDriver, HostLocalShellRunner, LocalShellDriver, localShellToolDefinition, localShellToolInstructions, createLocalWorkdirToolRegistry, localWorkdirToolDefinition, localWorkdirToolInstructions, } from "./local/index.js";
 export { localSkillFromDirectory, pendingLocalSkillCalls, runLocalSkillHandlers } from "./local-skills.js";
 export * from "./local/index.js";

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "1.1.5";
-export declare const USER_AGENT = "@agent-api/sdk/1.1.5";
+export declare const VERSION = "1.2.1";
+export declare const USER_AGENT = "@agent-api/sdk/1.2.1";

package/dist/version.js

@@ -1,2 +1,2 @@
-export const VERSION = "1.1.5";
+export const VERSION = "1.2.1";
 export const USER_AGENT = `@agent-api/sdk/${VERSION}`;