@modelprofile.com/flexharness 6.1.0 → 7.0.0

package/dist_ts_tools/tool.json.js

@@ -0,0 +1,47 @@
+import * as plugins from './plugins.js';
+export function jsonTool() {
+    return {
+        json_validate: plugins.tool({
+            description: 'Validate a JSON string and optionally check for required fields.',
+            inputSchema: plugins.z.object({
+                jsonString: plugins.z.string().describe('JSON string to validate'),
+                requiredFields: plugins.z
+                    .array(plugins.z.string())
+                    .optional()
+                    .describe('Fields that must exist at the top level'),
+            }),
+            execute: async ({ jsonString, requiredFields, }) => {
+                try {
+                    const parsed = JSON.parse(jsonString);
+                    if (requiredFields?.length) {
+                        const missing = requiredFields.filter((f) => !(f in parsed));
+                        if (missing.length) {
+                            return `Invalid: missing required fields: ${missing.join(', ')}`;
+                        }
+                    }
+                    const type = Array.isArray(parsed) ? 'array' : typeof parsed;
+                    return `Valid JSON (${type})`;
+                }
+                catch (e) {
+                    return `Invalid JSON: ${e.message}`;
+                }
+            },
+        }),
+        json_transform: plugins.tool({
+            description: 'Parse a JSON string and return it pretty-printed.',
+            inputSchema: plugins.z.object({
+                jsonString: plugins.z.string().describe('JSON string to format'),
+            }),
+            execute: async ({ jsonString }) => {
+                try {
+                    const parsed = JSON.parse(jsonString);
+                    return JSON.stringify(parsed, null, 2);
+                }
+                catch (e) {
+                    return `Error parsing JSON: ${e.message}`;
+                }
+            },
+        }),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tools/tool.shell.d.ts

@@ -0,0 +1,15 @@
+import * as plugins from './plugins.js';
+import { type IToolExecutionContext } from './tool.context.js';
+export interface ICreateShellToolsOptions {
+    /**
+     * Exact executable allowlist for structured execution. Raw command filtering is advisory.
+     */
+    allowedCommands?: string[];
+    /** Maximum output lines before truncating. */
+    maxLines?: number;
+    /** Maximum output bytes before truncating. */
+    maxBytes?: number;
+    /** Expose start_shell when context.jobs exists. Default: true. */
+    includeBackground?: boolean;
+}
+export declare function createShellTools(context: IToolExecutionContext, options?: ICreateShellToolsOptions): plugins.ToolSet;

package/dist_ts_tools/tool.shell.js

@@ -0,0 +1,329 @@
+import * as plugins from './plugins.js';
+import { formatShellResult, } from './tool.context.js';
+const DEFAULT_FOREGROUND_PREVIEW_BYTES = 50 * 1024;
+const MAX_FOREGROUND_PRELIMINARY_CHUNKS = 64;
+const MAX_FOREGROUND_PRELIMINARY_BYTES = 256 * 1024;
+const singleShellOutput = async function* (output) {
+    yield output;
+};
+const foregroundPreviewByteLimit = (configuredMaxBytes) => (Number.isSafeInteger(configuredMaxBytes) && configuredMaxBytes > 0
+    ? Math.min(configuredMaxBytes, DEFAULT_FOREGROUND_PREVIEW_BYTES)
+    : DEFAULT_FOREGROUND_PREVIEW_BYTES);
+const formatForegroundShellPreview = (stdout, stderr, captureTruncated) => {
+    const output = stderr
+        ? stdout
+            ? `stdout:\n${stdout}\nstderr:\n${stderr}`
+            : `stderr:\n${stderr}`
+        : stdout;
+    return captureTruncated
+        ? `${output}${output ? '\n' : ''}[Live output preview truncated; final output will follow.]`
+        : output;
+};
+class ForegroundShellResultStream {
+    options;
+    abortController = new AbortController();
+    abortSignal;
+    previewByteLimit;
+    queue = [];
+    waiters = [];
+    completion;
+    stdout = '';
+    stderr = '';
+    previewBytes = 0;
+    captureTruncated = false;
+    lastPreview = '';
+    preliminaryChunks = 0;
+    preliminaryBytes = 0;
+    previewsDisabled = false;
+    settled = false;
+    returned = false;
+    terminalError;
+    constructor(options) {
+        this.options = options;
+        this.abortSignal = options.abortSignal
+            ? AbortSignal.any([options.abortSignal, this.abortController.signal])
+            : this.abortController.signal;
+        this.previewByteLimit = foregroundPreviewByteLimit(options.maxBytes);
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    next() {
+        if (this.returned)
+            return Promise.resolve({ done: true, value: undefined });
+        this.ensureStarted();
+        const queued = this.queue.shift();
+        if (queued)
+            return Promise.resolve(this.deliver(queued));
+        if (this.settled) {
+            return this.terminalError === undefined
+                ? Promise.resolve({ done: true, value: undefined })
+                : Promise.reject(this.terminalError);
+        }
+        return new Promise((resolve, reject) => {
+            this.waiters.push({ resolve, reject });
+        });
+    }
+    async return() {
+        if (!this.returned) {
+            this.returned = true;
+            this.abortController.abort(new DOMException('Foreground shell iteration stopped.', 'AbortError'));
+            this.queue.length = 0;
+            this.flushWaiters();
+        }
+        if (this.completion) {
+            try {
+                await this.completion;
+            }
+            catch {
+                // Iterator cancellation owns the abort; the cancelled command result is not a tool failure.
+            }
+        }
+        return { done: true, value: undefined };
+    }
+    async throw(error) {
+        if (!this.returned) {
+            this.returned = true;
+            this.abortController.abort(error);
+            this.queue.length = 0;
+            while (this.waiters.length > 0)
+                this.waiters.shift().reject(error);
+        }
+        if (this.completion) {
+            try {
+                await this.completion;
+            }
+            catch {
+                // The caller-provided iterator error remains authoritative.
+            }
+        }
+        throw error;
+    }
+    async handleOutput(stream, chunk) {
+        if (this.returned || this.settled || this.previewsDisabled || !chunk)
+            return;
+        let accepted = '';
+        let acceptedBytes = 0;
+        for (const character of chunk) {
+            const characterBytes = Buffer.byteLength(character);
+            if (this.previewBytes + acceptedBytes + characterBytes > this.previewByteLimit)
+                break;
+            accepted += character;
+            acceptedBytes += characterBytes;
+        }
+        if (acceptedBytes < Buffer.byteLength(chunk))
+            this.captureTruncated = true;
+        if (accepted) {
+            if (stream === 'stdout')
+                this.stdout += accepted;
+            else
+                this.stderr += accepted;
+            this.previewBytes += acceptedBytes;
+        }
+        const preview = plugins.truncateOutput(formatForegroundShellPreview(this.stdout, this.stderr, this.captureTruncated), { maxLines: this.options.maxLines, maxBytes: this.options.maxBytes }).content;
+        if (!preview || preview === this.lastPreview)
+            return;
+        const bytes = Buffer.byteLength(JSON.stringify(preview));
+        if (this.preliminaryChunks + 1 > MAX_FOREGROUND_PRELIMINARY_CHUNKS
+            || this.preliminaryBytes + bytes > MAX_FOREGROUND_PRELIMINARY_BYTES) {
+            this.previewsDisabled = true;
+            return;
+        }
+        this.lastPreview = preview;
+        for (let index = this.queue.length - 1; index >= 0; index--) {
+            if (this.queue[index].kind === 'preliminary')
+                this.queue.splice(index, 1);
+        }
+        this.queue.push({ kind: 'preliminary', content: preview, bytes });
+        if (this.captureTruncated)
+            this.previewsDisabled = true;
+        this.flushWaiters();
+    }
+    ensureStarted() {
+        if (this.completion)
+            return;
+        const completion = Promise.resolve().then(() => this.options.start(this.abortSignal, async (stream, chunk) => this.handleOutput(stream, chunk)));
+        this.completion = completion;
+        void completion.then((result) => this.finish(result), (error) => this.fail(error));
+    }
+    finish(result) {
+        this.settled = true;
+        if (this.returned)
+            return;
+        const content = plugins.truncateOutput(formatShellResult(result), {
+            maxLines: this.options.maxLines,
+            maxBytes: this.options.maxBytes,
+        }).content;
+        this.queue.push({ kind: 'final', content, bytes: Buffer.byteLength(content) });
+        this.flushWaiters();
+    }
+    fail(error) {
+        this.settled = true;
+        this.terminalError = error;
+        this.flushWaiters();
+    }
+    deliver(output) {
+        if (output.kind === 'preliminary') {
+            this.preliminaryChunks++;
+            this.preliminaryBytes += output.bytes;
+        }
+        return { done: false, value: output.content };
+    }
+    flushWaiters() {
+        while (this.waiters.length > 0 && this.queue.length > 0) {
+            this.waiters.shift().resolve(this.deliver(this.queue.shift()));
+        }
+        if (!this.settled && !this.returned)
+            return;
+        while (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            if (!this.returned && this.terminalError !== undefined)
+                waiter.reject(this.terminalError);
+            else
+                waiter.resolve({ done: true, value: undefined });
+        }
+    }
+}
+export function createShellTools(context, options = {}) {
+    const tools = {
+        run_command: plugins.tool({
+            description: 'Execute a raw shell command through bash -lc. Shell composition is supported. Prefer run_shell when direct structured execution is sufficient.',
+            inputSchema: plugins.z.object({
+                command: plugins.z.string().describe('The shell command to execute'),
+                cwd: plugins.z
+                    .string()
+                    .optional()
+                    .describe('Working directory for the command'),
+                timeout: plugins.z
+                    .number()
+                    .optional()
+                    .describe('Timeout in milliseconds'),
+                timeoutMs: plugins.z
+                    .number()
+                    .optional()
+                    .describe('Timeout in milliseconds'),
+            }),
+            execute: ({ command, cwd, timeout, timeoutMs, }, invocationOptions) => {
+                const shell = context.shell;
+                if (!shell) {
+                    throw new Error('Shell tool is not available in this execution context.');
+                }
+                if (options.allowedCommands?.length) {
+                    const baseCommand = command.trim().split(/\s+/)[0];
+                    if (!options.allowedCommands.includes(baseCommand)) {
+                        return singleShellOutput(`Raw command "${baseCommand}" is not in the advisory allowed commands list: ${options.allowedCommands.join(', ')}`);
+                    }
+                }
+                const abortSignal = invocationOptions?.abortSignal ?? context.abortSignal;
+                return new ForegroundShellResultStream({
+                    abortSignal,
+                    maxLines: options.maxLines,
+                    maxBytes: options.maxBytes,
+                    start: async (executionSignal, onOutput) => {
+                        await context.requestPermission?.({
+                            type: 'shell',
+                            title: 'Run shell command',
+                            metadata: { command, cwd: cwd ?? context.cwd },
+                            toolCallId: invocationOptions?.toolCallId,
+                            abortSignal: executionSignal,
+                        });
+                        executionSignal.throwIfAborted();
+                        return shell.run(command, {
+                            cwd: cwd ?? context.cwd,
+                            timeoutMs: timeoutMs ?? timeout,
+                            toolCallId: invocationOptions?.toolCallId,
+                            abortSignal: executionSignal,
+                            onOutput,
+                        });
+                    },
+                });
+            },
+        }),
+    };
+    if (context.shell?.runStructured) {
+        tools.run_shell = plugins.tool({
+            description: 'Execute an executable directly with a literal argument array. No shell parsing or shell composition is performed.',
+            inputSchema: plugins.z.object({
+                executable: plugins.z.string().describe('Exact executable name or path'),
+                args: plugins.z.array(plugins.z.string()).default([]).describe('Literal argument array'),
+                cwd: plugins.z.string().optional().describe('Working directory for the command'),
+                timeoutMs: plugins.z.number().optional().describe('Timeout in milliseconds'),
+            }),
+            execute: (input, invocationOptions) => {
+                const runStructured = context.shell?.runStructured;
+                if (!runStructured) {
+                    throw new Error('Structured shell execution is not available in this execution context.');
+                }
+                if (options.allowedCommands?.length && !options.allowedCommands.includes(input.executable)) {
+                    return singleShellOutput({
+                        error: `Executable "${input.executable}" is not in the allowed commands list.`,
+                        allowedCommands: options.allowedCommands,
+                    });
+                }
+                const abortSignal = invocationOptions?.abortSignal ?? context.abortSignal;
+                return new ForegroundShellResultStream({
+                    abortSignal,
+                    maxLines: options.maxLines,
+                    maxBytes: options.maxBytes,
+                    start: async (executionSignal, onOutput) => {
+                        await context.requestPermission?.({
+                            type: 'shell',
+                            title: 'Run structured command',
+                            metadata: { executable: input.executable, args: input.args, cwd: input.cwd ?? context.cwd },
+                            toolCallId: invocationOptions?.toolCallId,
+                            abortSignal: executionSignal,
+                        });
+                        executionSignal.throwIfAborted();
+                        return runStructured({ executable: input.executable, args: input.args }, {
+                            cwd: input.cwd ?? context.cwd,
+                            timeoutMs: input.timeoutMs,
+                            toolCallId: invocationOptions?.toolCallId,
+                            abortSignal: executionSignal,
+                            onOutput,
+                        });
+                    },
+                });
+            },
+        });
+    }
+    if (context.jobs && options.includeBackground !== false) {
+        tools.start_shell = plugins.tool({
+            description: 'Start a structured shell command as an independent background execution and return its execution ID immediately.',
+            inputSchema: plugins.z.object({
+                executable: plugins.z.string().describe('Exact executable name or path'),
+                args: plugins.z.array(plugins.z.string()).default([]).describe('Literal argument array'),
+                cwd: plugins.z.string().optional().describe('Working directory for the command'),
+                timeoutMs: plugins.z.number().optional().describe('Background execution timeout in milliseconds'),
+            }),
+            execute: async (input, invocationOptions) => {
+                if (!context.jobs)
+                    throw new Error('Background jobs are not available in this execution context.');
+                if (options.allowedCommands?.length && !options.allowedCommands.includes(input.executable)) {
+                    throw new Error(`Executable "${input.executable}" is not in the allowed commands list.`);
+                }
+                const admissionSignal = invocationOptions?.abortSignal ?? context.abortSignal;
+                await context.requestPermission?.({
+                    type: 'shell-background',
+                    title: 'Start background shell command',
+                    metadata: { executable: input.executable, args: input.args, cwd: input.cwd ?? context.cwd },
+                    toolCallId: invocationOptions?.toolCallId,
+                    abortSignal: admissionSignal,
+                });
+                admissionSignal?.throwIfAborted();
+                const handle = await context.jobs.start({
+                    type: 'shell',
+                    command: { executable: input.executable, args: input.args },
+                    cwd: input.cwd ?? context.cwd,
+                    timeoutMs: input.timeoutMs,
+                    metadata: { toolCallId: invocationOptions?.toolCallId },
+                }, {
+                    toolCallId: invocationOptions?.toolCallId,
+                    abortSignal: admissionSignal,
+                });
+                return { executionId: handle.executionId, state: 'running' };
+            },
+        });
+    }
+    return tools;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tool.shell.js","sourceRoot":"","sources":["../ts_tools/tool.shell.ts"],"names":[],"mappings":"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"}

package/dist_ts_tools/utils.truncation.d.ts

@@ -0,0 +1,10 @@
+export interface ITruncateResult {
+    content: string;
+    truncated: boolean;
+    /** Set when truncated: describes what was dropped */
+    notice?: string;
+}
+export declare function truncateOutput(text: string, options?: {
+    maxLines?: number;
+    maxBytes?: number;
+}): ITruncateResult;

package/dist_ts_tools/utils.truncation.js

@@ -0,0 +1,26 @@
+// Truncation logic derived from opencode (MIT) — https://github.com/sst/opencode
+const MAX_LINES = 2000;
+const MAX_BYTES = 50 * 1024; // 50 KB
+export function truncateOutput(text, options) {
+    const maxLines = options?.maxLines ?? MAX_LINES;
+    const maxBytes = options?.maxBytes ?? MAX_BYTES;
+    const lines = text.split('\n');
+    const totalBytes = Buffer.byteLength(text, 'utf-8');
+    if (lines.length <= maxLines && totalBytes <= maxBytes) {
+        return { content: text, truncated: false };
+    }
+    const out = [];
+    let bytes = 0;
+    for (let i = 0; i < lines.length && i < maxLines; i++) {
+        const size = Buffer.byteLength(lines[i], 'utf-8') + (i > 0 ? 1 : 0);
+        if (bytes + size > maxBytes)
+            break;
+        out.push(lines[i]);
+        bytes += size;
+    }
+    const kept = out.length;
+    const dropped = lines.length - kept;
+    const notice = `\n[Output truncated: showing ${kept}/${lines.length} lines. ${dropped} lines omitted.]`;
+    return { content: out.join('\n') + notice, truncated: true, notice };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMudHJ1bmNhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3Rvb2xzL3V0aWxzLnRydW5jYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsaUZBQWlGO0FBRWpGLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQztBQUN2QixNQUFNLFNBQVMsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLENBQUMsUUFBUTtBQVNyQyxNQUFNLFVBQVUsY0FBYyxDQUM1QixJQUFZLEVBQ1osT0FBa0Q7SUFFbEQsTUFBTSxRQUFRLEdBQUcsT0FBTyxFQUFFLFFBQVEsSUFBSSxTQUFTLENBQUM7SUFDaEQsTUFBTSxRQUFRLEdBQUcsT0FBTyxFQUFFLFFBQVEsSUFBSSxTQUFTLENBQUM7SUFDaEQsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUMvQixNQUFNLFVBQVUsR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRSxPQUFPLENBQUMsQ0FBQztJQUVwRCxJQUFJLEtBQUssQ0FBQyxNQUFNLElBQUksUUFBUSxJQUFJLFVBQVUsSUFBSSxRQUFRLEVBQUUsQ0FBQztRQUN2RCxPQUFPLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLENBQUM7SUFDN0MsQ0FBQztJQUVELE1BQU0sR0FBRyxHQUFhLEVBQUUsQ0FBQztJQUN6QixJQUFJLEtBQUssR0FBRyxDQUFDLENBQUM7SUFDZCxLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsS0FBSyxDQUFDLE1BQU0sSUFBSSxDQUFDLEdBQUcsUUFBUSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUM7UUFDdEQsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3BFLElBQUksS0FBSyxHQUFHLElBQUksR0FBRyxRQUFRO1lBQUUsTUFBTTtRQUNuQyxHQUFHLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ25CLEtBQUssSUFBSSxJQUFJLENBQUM7SUFDaEIsQ0FBQztJQUVELE1BQU0sSUFBSSxHQUFHLEdBQUcsQ0FBQyxNQUFNLENBQUM7SUFDeEIsTUFBTSxPQUFPLEdBQUcsS0FBSyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUM7SUFDcEMsTUFBTSxNQUFNLEdBQUcsZ0NBQWdDLElBQUksSUFBSSxLQUFLLENBQUMsTUFBTSxXQUFXLE9BQU8sa0JBQWtCLENBQUM7SUFDeEcsT0FBTyxFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLE1BQU0sRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBQ3ZFLENBQUMifQ==

package/dist_ts_tools_node/index.d.ts

@@ -0,0 +1,5 @@
+export { createLocalToolExecutionContext } from './tool.context.js';
+export type { ILocalToolExecutionContextOptions } from './tool.context.js';
+export { FileToolJobStore } from './tool.persistence.js';
+export type { IFileToolJobStoreOptions } from './tool.persistence.js';
+export * from './tools.local.js';

package/dist_ts_tools_node/index.js

@@ -0,0 +1,4 @@
+export { createLocalToolExecutionContext } from './tool.context.js';
+export { FileToolJobStore } from './tool.persistence.js';
+export * from './tools.local.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190b29sc19ub2RlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXBFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXpELGNBQWMsa0JBQWtCLENBQUMifQ==

package/dist_ts_tools_node/plugins.d.ts

@@ -0,0 +1,13 @@
+import * as childProcess from 'node:child_process';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import * as v8 from 'node:v8';
+export { childProcess, crypto, fs, path, StringDecoder, v8 };
+import { createToolJobSnapshot, JOB_SNAPSHOT_SCHEMA_VERSION, ToolJobStoreConflictError } from '@modelprofile.com/flexharness-agent';
+export { createToolJobSnapshot, JOB_SNAPSHOT_SCHEMA_VERSION, ToolJobStoreConflictError };
+import { createFilesystemTools, createShellTools } from '@modelprofile.com/flexharness/tools';
+export { createFilesystemTools, createShellTools };
+export type { ICreateFilesystemToolsOptions, ICreateShellToolsOptions, ToolSet } from '@modelprofile.com/flexharness/tools';
+export type { IToolExecutionContext } from '@modelprofile.com/flexharness-agent';

package/dist_ts_tools_node/plugins.js

@@ -0,0 +1,13 @@
+// node native
+import * as childProcess from 'node:child_process';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import * as v8 from 'node:v8';
+export { childProcess, crypto, fs, path, StringDecoder, v8 };
+import { createToolJobSnapshot, JOB_SNAPSHOT_SCHEMA_VERSION, ToolJobStoreConflictError } from '@modelprofile.com/flexharness-agent';
+export { createToolJobSnapshot, JOB_SNAPSHOT_SCHEMA_VERSION, ToolJobStoreConflictError };
+import { createFilesystemTools, createShellTools } from '@modelprofile.com/flexharness/tools';
+export { createFilesystemTools, createShellTools };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3Rvb2xzX25vZGUvcGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsT0FBTyxLQUFLLFlBQVksTUFBTSxvQkFBb0IsQ0FBQztBQUNuRCxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUN0QyxPQUFPLEtBQUssRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUM5QixPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxLQUFLLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFFOUIsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxhQUFhLEVBQUUsRUFBRSxFQUFFLENBQUM7QUFFN0QsT0FBTyxFQUFFLHFCQUFxQixFQUFFLDJCQUEyQixFQUFFLHlCQUF5QixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDcEksT0FBTyxFQUFFLHFCQUFxQixFQUFFLDJCQUEyQixFQUFFLHlCQUF5QixFQUFFLENBQUM7QUFDekYsT0FBTyxFQUFFLHFCQUFxQixFQUFFLGdCQUFnQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDOUYsT0FBTyxFQUFFLHFCQUFxQixFQUFFLGdCQUFnQixFQUFFLENBQUMifQ==

package/dist_ts_tools_node/tool.context.d.ts

@@ -0,0 +1,31 @@
+import type { IToolJobStore } from '@modelprofile.com/flexharness-agent';
+import type { IToolPermissionRequest, IToolJobState, IToolExecutionContext } from '@modelprofile.com/flexharness-agent';
+export interface ILocalToolExecutionContextOptions {
+    cwd?: string;
+    rootDir?: string;
+    /** Additional canonical roots available to filesystem read/list operations only. */
+    additionalReadOnlyRoots?: string[];
+    abortSignal?: AbortSignal;
+    /** Guards each local filesystem operation or shell side effect. */
+    beforeOperation?: () => Promise<void> | void;
+    /** Hard combined stdout/stderr capture limit for each local shell command. Default: 1 MiB. */
+    maxShellOutputBytes?: number;
+    /** Number of terminal background job snapshots retained for get/list. Default: 100. */
+    maxRetainedJobs?: number;
+    /** Optional durable store used to restore terminal jobs after host restarts. */
+    jobStore?: IToolJobStore;
+    /** Maximum wait for each local shell output listener before its process is terminated. Default: 30 seconds. */
+    outputListenerTimeoutMs?: number;
+    /** Maximum wait for job-store load/save operations. Defaults to outputListenerTimeoutMs. */
+    jobStoreOperationTimeoutMs?: number;
+    /** Reconciles a persisted running job whose original process ownership was lost. */
+    settleOrphanedJob?: (job: IToolJobState, abortSignal: AbortSignal) => Promise<IToolJobState> | IToolJobState;
+    requestPermission?: (request: IToolPermissionRequest) => Promise<void>;
+}
+export declare const createLocalToolExecutionContext: (options?: ILocalToolExecutionContextOptions) => IToolExecutionContext;
+/** @internal */
+export declare const handleLocalShellChildError: (error: Error, childPid: number | undefined, handlers: {
+    settleSpawnFailure: (error: Error) => void;
+    retainError: (error: Error) => void;
+    requestTermination: () => void;
+}) => void;