@agent-api/sdk 1.2.3 → 1.3.1

package/dist/local/tools.js

@@ -7,6 +7,15 @@ export class LocalWorkdirDriver {
         this.accessMode = options.accessMode ?? "approval";
     }
     async dispatch(args) {
+        const action = safeWorkdirAction(args);
+        try {
+            return await this.dispatchUnsafe(args);
+        }
+        catch (error) {
+            return localToolErrorResult(action, error);
+        }
+    }
+    async dispatchUnsafe(args) {
         const action = workdirAction(args);
         switch (action) {
             case "summarize":
@@ -45,7 +54,8 @@ export class LocalWorkdirDriver {
         if (this.accessMode === "full") {
             return false;
         }
-        return mutatingLocalWorkdirActions.has(workdirAction(args));
+        const action = safeWorkdirAction(args);
+        return action !== "unknown" && mutatingLocalWorkdirActions.has(action);
     }
     async dispatchApplyEdits(args) {
         const edits = editsArg(args);
@@ -129,6 +139,7 @@ const mutatingLocalWorkdirActions = new Set([
 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.",
+    "grep searches file contents for a literal substring; path may be omitted, a file path, or a directory subtree.",
     "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 workdir; never use absolute paths.",
 ].join(" ");
@@ -139,7 +150,7 @@ function localWorkdirToolParameters() {
             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."),
+        path: stringSchema("Relative path. File path for read/write/delete/edit actions. For grep, path may be a file or a directory subtree. For list/search/summarize/context/snapshot, path is a directory base."),
         query: stringSchema("Path/name query for search, or optional context query."),
         pattern: stringSchema("Literal text pattern for grep."),
         content: stringSchema("Text content for write."),
@@ -182,6 +193,10 @@ function workdirAction(args) {
     }
     return value;
 }
+function safeWorkdirAction(args) {
+    const value = typeof args.action === "string" ? args.action.trim().toLowerCase() : "";
+    return localWorkdirActions.includes(value) ? value : "unknown";
+}
 function summaryArgs(args) {
     return {
         path: optionalStringArg(args, "path"),
@@ -277,6 +292,27 @@ function localToolResult(action, value) {
     }
     return { ok: true, action, result };
 }
+function localToolErrorResult(action, error) {
+    const details = errorDetails(error);
+    return {
+        ok: false,
+        action,
+        error: details.message,
+        code: details.code,
+        path: details.path,
+    };
+}
+function errorDetails(error) {
+    if (error instanceof Error) {
+        const record = error;
+        return {
+            code: typeof record.code === "string" ? record.code : undefined,
+            message: error.message || "local_workdir action failed",
+            path: typeof record.path === "string" ? record.path : undefined,
+        };
+    }
+    return { message: String(error || "local_workdir action failed") };
+}
 function stringArg(args, key, alternateKey) {
     const direct = args[key] ?? (alternateKey ? args[alternateKey] : undefined);
     const fromOptions = args.options && typeof args.options === "object"

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 { 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 { createLocalShellToolRegistry, LocalWorkdirDriver, HostLocalShellRunner, IsolatorLocalShellRunner, LocalShellDriver, localShellToolDefinition, localShellToolInstructions, createLocalWorkdirToolRegistry, localWorkdirToolDefinition, localWorkdirToolInstructions, } from "./local/index.js";
+export type { LocalCommandRunner, LocalShellAccessMode, LocalShellContext, LocalShellIsolationGuarantees, LocalShellIsolationMode, LocalShellIsolationOptions, LocalShellIsolationResourceOptions, LocalShellIsolationStatus, LocalShellIsolatorStatusResult, LocalShellRequest, LocalShellResult, LocalShellToolRegistry, LocalShellToolRegistryOptions, IsolatorLocalShellRunnerOptions, 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 { createLocalShellToolRegistry, LocalWorkdirDriver, HostLocalShellRunner, LocalShellDriver, localShellToolDefinition, localShellToolInstructions, createLocalWorkdirToolRegistry, localWorkdirToolDefinition, localWorkdirToolInstructions, } from "./local/index.js";
+export { createLocalShellToolRegistry, LocalWorkdirDriver, HostLocalShellRunner, IsolatorLocalShellRunner, 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.2.3";
-export declare const USER_AGENT = "@agent-api/sdk/1.2.3";
+export declare const VERSION = "1.3.1";
+export declare const USER_AGENT = "@agent-api/sdk/1.3.1";

package/dist/version.js

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

package/dist-cjs/local/core.js

@@ -325,7 +325,7 @@ class LocalFileStore {
         const maxFiles = positiveInt(params.maxFiles, 500);
         const maxBytesPerFile = positiveInt(params.maxBytesPerFile, 512 * 1024);
         const maxLineLength = positiveInt(params.maxLineLength, 500);
-        const stats = await this.list(params.path ?? ".", { recursive: true, ignore: params.ignore });
+        const stats = await this.grepCandidates(params.path ?? ".", params.ignore);
         const matches = [];
         let filesScanned = 0;
         let scanTruncated = false;
@@ -363,6 +363,27 @@ class LocalFileStore {
         }
         return { object: "list", matches, files_scanned: filesScanned, scan_truncated: scanTruncated };
     }
+    async grepCandidates(relativePath, ignore) {
+        const fullPath = this.resolvePath(relativePath);
+        const info = await (0, promises_1.stat)(fullPath);
+        const portablePath = toPortablePath(node_path_1.default.relative(this.root, fullPath)) || ".";
+        if (ignored(portablePath, ignore)) {
+            return [];
+        }
+        if (info.isFile()) {
+            return [{
+                    path: portablePath,
+                    fullPath,
+                    type: "file",
+                    size: info.size,
+                    modifiedAt: info.mtime,
+                }];
+        }
+        if (info.isDirectory()) {
+            return await this.list(relativePath, { recursive: true, ignore });
+        }
+        return [];
+    }
     async summarize(params = {}) {
         const maxFiles = positiveInt(params.maxFiles, 2000);
         const maxPreviews = positiveInt(params.maxPreviews, 20);

package/dist-cjs/local/shell.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalShellDriver = exports.HostLocalShellRunner = void 0;
+exports.LocalShellDriver = exports.IsolatorLocalShellRunner = exports.HostLocalShellRunner = void 0;
 exports.createLocalShellToolRegistry = createLocalShellToolRegistry;
 exports.localShellToolDefinition = localShellToolDefinition;
 exports.localShellToolInstructions = localShellToolInstructions;
@@ -15,12 +15,14 @@ class HostLocalShellRunner {
     timeoutMs;
     maxOutputBytes;
     env;
+    isolationStatus;
     constructor(options = {}) {
         this.cwd = node_path_1.default.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 ?? {}) };
+        this.isolationStatus = directIsolationStatus(false, options.isolationOptions);
     }
     async run(request, context = {}) {
         const command = requiredString(request.command, "command");
@@ -63,6 +65,7 @@ class HostLocalShellRunner {
                     duration_ms: Date.now() - started,
                     timed_out: timedOut,
                     truncated: stdout.truncated || stderr.truncated,
+                    shell_isolation: this.isolationStatus,
                 });
             };
             const kill = () => {
@@ -103,23 +106,62 @@ class HostLocalShellRunner {
     }
 }
 exports.HostLocalShellRunner = HostLocalShellRunner;
+class IsolatorLocalShellRunner {
+    executablePath;
+    driver;
+    cwd;
+    timeoutMs;
+    maxOutputBytes;
+    isolationOptions;
+    isolationStatus;
+    statusResult;
+    constructor(options = {}) {
+        this.executablePath = resolveIsolatorExecutablePath(options.executablePath);
+        this.driver = options.driver ?? "auto";
+        this.cwd = node_path_1.default.resolve(options.cwd ?? process.cwd());
+        this.timeoutMs = positiveInteger(options.timeoutMs, 2 * 60 * 1000, "timeoutMs");
+        this.maxOutputBytes = positiveInteger(options.maxOutputBytes, 128 * 1024, "maxOutputBytes");
+        this.isolationOptions = options.isolationOptions ?? {};
+        this.statusResult = isolatorStatusSync(this.executablePath, this.driver);
+        this.isolationStatus = this.statusResult.status;
+    }
+    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 response = await isolatorRequest(this.executablePath, this.driver, {
+            id: `run_${Date.now().toString(36)}`,
+            method: "run",
+            params: {
+                command,
+                description: request.description,
+                cwd,
+                timeout_ms: timeoutMs,
+                max_output_bytes: this.maxOutputBytes,
+                env: request.env,
+                isolation: this.isolationOptions,
+            },
+        }, context);
+        return isolatorRunResult(response.result);
+    }
+}
+exports.IsolatorLocalShellRunner = IsolatorLocalShellRunner;
 class LocalShellDriver {
     accessMode;
     runner;
+    isolationStatus;
     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,
-        });
+        this.runner = resolveShellRunner(options, cwd);
+        this.isolationStatus = this.runner.isolationStatus ?? directIsolationStatus(options.isolation === "auto", options.isolationOptions);
     }
     async dispatch(args, context = {}) {
         const request = shellRequest(args);
         if (this.accessMode !== "full") {
-            return shellApprovalRequired(request);
+            return shellApprovalRequired(request, this.isolationStatus);
         }
         return shellToolResult(await this.runner.run(request, context));
     }
@@ -128,16 +170,80 @@ class LocalShellDriver {
     }
 }
 exports.LocalShellDriver = LocalShellDriver;
+function resolveShellRunner(options, cwd) {
+    if (options.runner) {
+        if (options.isolation === "required" && options.runner.isolationStatus?.isolated !== true) {
+            throw new Error("local_shell isolation is required, but the configured runner does not report isolation");
+        }
+        return options.runner;
+    }
+    let isolatorFallbackWarning;
+    if (options.isolation === "auto" || options.isolation === "required" || options.isolator) {
+        const isolatorOptions = typeof options.isolator === "object" ? options.isolator : {};
+        try {
+            const runner = new IsolatorLocalShellRunner({
+                cwd,
+                timeoutMs: options.timeoutMs,
+                maxOutputBytes: options.maxOutputBytes,
+                isolationOptions: options.isolationOptions,
+                ...isolatorOptions,
+            });
+            if (options.isolation === "required" && runner.isolationStatus.isolated !== true) {
+                throw new Error(`local_shell isolation is required, but agent-isolator selected non-isolated driver ${runner.isolationStatus.driver}`);
+            }
+            if (options.isolation !== "none" || options.isolator) {
+                return runner;
+            }
+        }
+        catch (error) {
+            if (options.isolation === "required") {
+                throw error;
+            }
+            isolatorFallbackWarning = errorMessage(error);
+        }
+    }
+    const runner = new HostLocalShellRunner({
+        cwd,
+        shell: options.shell,
+        timeoutMs: options.timeoutMs,
+        maxOutputBytes: options.maxOutputBytes,
+        isolationOptions: options.isolationOptions,
+    });
+    if (options.isolation === "auto") {
+        let status = directIsolationStatus(true, options.isolationOptions);
+        if (isolatorFallbackWarning) {
+            status = {
+                ...status,
+                warnings: [...status.warnings, `Isolator unavailable: ${isolatorFallbackWarning}`],
+            };
+        }
+        return withIsolationStatus(runner, status);
+    }
+    return runner;
+}
+function resolveIsolatorExecutablePath(explicitPath) {
+    const configured = (explicitPath?.trim() || process.env.AGENT_ISOLATOR_PATH?.trim() || "");
+    if (!configured) {
+        throw new Error("agent-isolator executable path is not configured; pass isolator.executablePath or set AGENT_ISOLATOR_PATH");
+    }
+    return configured;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function createLocalShellToolRegistry(options = {}) {
     const toolName = options.toolName ?? "local_shell";
     const driver = new LocalShellDriver(options);
     const hostRunner = driver.runner instanceof HostLocalShellRunner ? driver.runner : undefined;
+    const isolatorRunner = driver.runner instanceof IsolatorLocalShellRunner ? driver.runner : undefined;
     const definition = localShellToolDefinition(toolName, {
         accessMode: driver.accessMode,
-        cwd: options.workdir?.root ?? hostRunner?.cwd ?? options.cwd,
+        cwd: options.workdir?.root ?? hostRunner?.cwd ?? isolatorRunner?.cwd ?? options.cwd,
         shell: hostRunner?.shell ?? options.shell,
-        timeoutMs: hostRunner?.timeoutMs ?? options.timeoutMs,
-        maxOutputBytes: hostRunner?.maxOutputBytes ?? options.maxOutputBytes,
+        timeoutMs: hostRunner?.timeoutMs ?? isolatorRunner?.timeoutMs ?? options.timeoutMs,
+        maxOutputBytes: hostRunner?.maxOutputBytes ?? isolatorRunner?.maxOutputBytes ?? options.maxOutputBytes,
+        isolationStatus: driver.isolationStatus,
+        isolationOptions: options.isolationOptions,
     });
     return {
         accessMode: driver.accessMode,
@@ -169,13 +275,16 @@ function localShellToolDescription(options = {}) {
     const platform = options.platform ?? process.platform;
     const shell = shellDisplayName(options.shell);
     const accessMode = options.accessMode ?? "approval";
+    const isolation = options.isolationStatus ?? directIsolationStatus(false, options.isolationOptions);
     const cwd = options.cwd ? node_path_1.default.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}.`,
+        `Execution environment: platform=${platform}; shell=${shell}; access_mode=${accessMode}; isolation_driver=${isolation.driver}; isolated=${isolation.isolated}; fallback=${isolation.fallback}; default_timeout_ms=${timeoutMs}; max_output_bytes=${maxOutputBytes}.`,
+        isolationRequestDescription(isolation.requested),
+        isolation.warnings.length > 0 ? `Isolation warning: ${isolation.warnings.join(" ")}` : "",
         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.",
@@ -217,7 +326,7 @@ function shellRequest(args) {
         timeoutMs: optionalNumber(args.timeoutMs ?? args.timeout_ms, "timeout_ms"),
     };
 }
-function shellApprovalRequired(request) {
+function shellApprovalRequired(request, isolationStatus) {
     return {
         ok: false,
         requires_approval: true,
@@ -226,9 +335,235 @@ function shellApprovalRequired(request) {
         description: request.description,
         workdir: request.workdir,
         timeout_ms: request.timeoutMs,
+        shell_isolation: isolationStatus,
         message: "local_shell command execution requires approval",
     };
 }
+function directIsolationStatus(fallback, options = {}) {
+    const requested = normalizeIsolationOptions(options);
+    const warnings = directIsolationWarnings(fallback, requested);
+    return {
+        executor: "direct",
+        driver: "direct",
+        isolated: false,
+        fallback,
+        requested,
+        guarantees: {
+            filesystem: "none",
+            network: "allowed",
+            user: "host-user",
+            process: "host-process-tree",
+            resources: "timeout-only",
+        },
+        warnings,
+    };
+}
+function normalizeIsolationOptions(options = {}) {
+    return {
+        filesystem: options.filesystem ?? "host",
+        network: options.network ?? "allowed",
+        env: options.env ?? "inherit",
+        resources: {
+            memoryMb: options.resources?.memoryMb,
+            cpuCount: options.resources?.cpuCount,
+        },
+    };
+}
+function directIsolationWarnings(fallback, requested) {
+    const warnings = [
+        fallback
+            ? "No local shell isolator is configured; falling back to direct host execution."
+            : "Direct host execution has no OS-level isolation.",
+    ];
+    if (requested.filesystem !== "host") {
+        warnings.push(`Requested filesystem isolation (${requested.filesystem}) is not enforced by direct execution.`);
+    }
+    if (requested.network === "blocked") {
+        warnings.push("Requested network blocking is not enforced by direct execution.");
+    }
+    if (requested.env === "minimal") {
+        warnings.push("Requested minimal environment is not enforced by direct execution.");
+    }
+    if (requested.resources.memoryMb != null || requested.resources.cpuCount != null) {
+        warnings.push("Requested CPU or memory limits are not enforced by direct execution.");
+    }
+    return warnings;
+}
+function isolationRequestDescription(options) {
+    const resources = [
+        options.resources.memoryMb == null ? "" : `memory_mb=${options.resources.memoryMb}`,
+        options.resources.cpuCount == null ? "" : `cpu_count=${options.resources.cpuCount}`,
+    ].filter(Boolean).join("; ");
+    return `Requested isolation: filesystem=${options.filesystem}; network=${options.network}; env=${options.env}${resources ? `; ${resources}` : ""}.`;
+}
+function withIsolationStatus(runner, status) {
+    Object.defineProperty(runner, "isolationStatus", {
+        configurable: true,
+        enumerable: true,
+        value: status,
+    });
+    return runner;
+}
+function isolatorStatusSync(executablePath, driver) {
+    const request = JSON.stringify({ id: "status", method: "status", params: {} });
+    const result = (0, node_child_process_1.spawnSync)(executablePath, ["--once", `--driver=${driver}`], {
+        input: request,
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+        windowsHide: true,
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        throw new Error((result.stderr || result.stdout || `agent-isolator exited with status ${result.status}`).trim());
+    }
+    const envelope = parseIsolatorEnvelope(result.stdout);
+    if (envelope.error) {
+        throw new Error(envelope.error.message || envelope.error.code || "agent-isolator status failed");
+    }
+    return isolatorStatusResult(envelope.result);
+}
+async function isolatorRequest(executablePath, driver, envelope, context) {
+    return await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(executablePath, ["--once", `--driver=${driver}`], {
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        const stdout = new BoundedText(1024 * 1024);
+        const stderr = new BoundedText(1024 * 1024);
+        let settled = false;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            context.signal?.removeEventListener("abort", abort);
+            if (error) {
+                reject(error);
+                return;
+            }
+            try {
+                const parsed = parseIsolatorEnvelope(stdout.text());
+                if (parsed.error) {
+                    reject(new Error(parsed.error.message || parsed.error.code || "agent-isolator request failed"));
+                    return;
+                }
+                resolve({ result: parsed.result });
+            }
+            catch (parseError) {
+                const details = stderr.text();
+                reject(new Error(`${parseError instanceof Error ? parseError.message : String(parseError)}${details ? `: ${details}` : ""}`));
+            }
+        };
+        const abort = () => {
+            if (!child.killed)
+                child.kill(process.platform === "win32" ? undefined : "SIGTERM");
+        };
+        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", finish);
+        child.on("close", (code) => {
+            if (code !== 0) {
+                finish(new Error((stderr.text() || stdout.text() || `agent-isolator exited with status ${code}`).trim()));
+                return;
+            }
+            finish();
+        });
+        child.stdin?.end(JSON.stringify(envelope));
+    });
+}
+function parseIsolatorEnvelope(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        throw new Error("agent-isolator returned an empty response");
+    }
+    return JSON.parse(trimmed);
+}
+function isolatorStatusResult(value) {
+    if (!isRecord(value)) {
+        throw new Error("agent-isolator status result must be an object");
+    }
+    return {
+        version: typeof value.version === "string" ? value.version : undefined,
+        driver: requiredString(value.driver, "driver"),
+        status: isolationStatusFromUnknown(value.status),
+        drivers: Array.isArray(value.drivers)
+            ? value.drivers.filter(isRecord).map((item) => ({
+                name: String(item.name ?? ""),
+                platform: String(item.platform ?? ""),
+                available: item.available === true,
+                warnings: Array.isArray(item.warnings) ? item.warnings.map(String) : undefined,
+            }))
+            : undefined,
+    };
+}
+function isolatorRunResult(value) {
+    if (!isRecord(value)) {
+        throw new Error("agent-isolator run result must be an object");
+    }
+    return {
+        ok: value.ok === true,
+        command: requiredString(value.command, "command"),
+        description: optionalString(value.description, "description"),
+        cwd: requiredString(value.cwd, "cwd"),
+        exit_code: typeof value.exit_code === "number" ? value.exit_code : null,
+        signal: typeof value.signal === "string" ? value.signal : null,
+        stdout: typeof value.stdout === "string" ? value.stdout : "",
+        stderr: typeof value.stderr === "string" ? value.stderr : "",
+        output: typeof value.output === "string" ? value.output : "(no output)",
+        duration_ms: typeof value.duration_ms === "number" ? value.duration_ms : 0,
+        timed_out: value.timed_out === true,
+        truncated: value.truncated === true,
+        shell_isolation: isolationStatusFromUnknown(value.shell_isolation),
+    };
+}
+function isolationStatusFromUnknown(value) {
+    if (!isRecord(value)) {
+        throw new Error("shell isolation status must be an object");
+    }
+    return {
+        executor: value.executor === "isolator" ? "isolator" : "direct",
+        driver: requiredString(value.driver, "shell_isolation.driver"),
+        isolated: value.isolated === true,
+        fallback: value.fallback === true,
+        requested: normalizeIsolationOptions(isRecord(value.requested) ? isolationOptionsFromUnknown(value.requested) : {}),
+        guarantees: isolationGuaranteesFromUnknown(value.guarantees),
+        warnings: Array.isArray(value.warnings) ? value.warnings.map(String) : [],
+    };
+}
+function isolationOptionsFromUnknown(value) {
+    const resources = isRecord(value.resources) ? value.resources : {};
+    return {
+        filesystem: value.filesystem === "workdir-readonly" || value.filesystem === "workdir-readwrite" || value.filesystem === "host"
+            ? value.filesystem
+            : undefined,
+        network: value.network === "blocked" || value.network === "allowed" ? value.network : undefined,
+        env: value.env === "minimal" || value.env === "inherit" ? value.env : undefined,
+        resources: {
+            memoryMb: typeof resources.memoryMb === "number" ? resources.memoryMb : undefined,
+            cpuCount: typeof resources.cpuCount === "number" ? resources.cpuCount : undefined,
+        },
+    };
+}
+function isolationGuaranteesFromUnknown(value) {
+    const record = isRecord(value) ? value : {};
+    return {
+        filesystem: record.filesystem === "workdir-mounted" || record.filesystem === "policy-enforced" ? record.filesystem : "none",
+        network: record.network === "blocked" || record.network === "configurable" ? record.network : "allowed",
+        user: record.user === "unprivileged-user" || record.user === "namespace-user" ? record.user : "host-user",
+        process: record.process === "child-contained" || record.process === "pid-namespace" ? record.process : "host-process-tree",
+        resources: record.resources === "cpu-memory-limits" ? "cpu-memory-limits" : record.resources === "timeout-only" ? "timeout-only" : "none",
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function shellToolResult(result) {
     return {
         ...result,