@modelprofile.com/flexharness 6.1.0 → 7.0.0

package/dist_ts_ocr/ocr.mistral.d.ts

@@ -0,0 +1,75 @@
+export type TSmartAiOcrImageMimeType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif' | string;
+export type TSmartAiMistralOcrTableFormat = 'markdown' | 'html';
+export type TSmartAiMistralOcrConfidenceScoresGranularity = 'page' | 'word';
+export interface ISmartAiOcrImageInput {
+    dataBase64: string;
+    mimeType: TSmartAiOcrImageMimeType;
+}
+export interface ISmartAiOcrPageResult {
+    index: number;
+    text: string;
+    confidence?: number;
+}
+export interface ISmartAiOcrResult<TRaw = unknown> {
+    text: string;
+    confidence?: number;
+    pages: ISmartAiOcrPageResult[];
+    raw: TRaw;
+}
+export interface ISmartAiOcrEngine {
+    recognizeImage: (input: ISmartAiOcrImageInput, options?: ISmartAiMistralOcrRecognizeOptions) => Promise<ISmartAiOcrResult<IMistralOcrResponse>>;
+}
+export interface IMistralOcrPageConfidenceScores {
+    average_page_confidence_score?: number;
+    averagePageConfidenceScore?: number;
+    minimum_page_confidence_score?: number;
+    minimumPageConfidenceScore?: number;
+}
+export interface IMistralOcrPageResponse {
+    index: number;
+    markdown: string;
+    confidence_scores?: IMistralOcrPageConfidenceScores | null;
+    confidenceScores?: IMistralOcrPageConfidenceScores | null;
+}
+export interface IMistralOcrResponse {
+    pages: IMistralOcrPageResponse[];
+    model: string;
+    document_annotation?: unknown;
+    documentAnnotation?: unknown;
+    usage_info?: unknown;
+    usageInfo?: unknown;
+}
+export interface IMistralOcrRequest {
+    model: string;
+    document: {
+        type: 'image_url';
+        image_url: string;
+    };
+    include_image_base64?: boolean;
+    table_format?: TSmartAiMistralOcrTableFormat;
+    extract_header?: boolean;
+    extract_footer?: boolean;
+    confidence_scores_granularity?: TSmartAiMistralOcrConfidenceScoresGranularity;
+}
+export interface ISmartAiMistralOcrTransport {
+    process: (request: IMistralOcrRequest) => Promise<IMistralOcrResponse>;
+}
+export interface ISmartAiMistralOcrOptions {
+    apiKey?: string;
+    model?: string;
+    endpointUrl?: string;
+    transport?: ISmartAiMistralOcrTransport;
+    includeImageBase64?: boolean;
+    tableFormat?: TSmartAiMistralOcrTableFormat;
+    extractHeader?: boolean;
+    extractFooter?: boolean;
+    confidenceScoresGranularity?: TSmartAiMistralOcrConfidenceScoresGranularity;
+}
+export interface ISmartAiMistralOcrRecognizeOptions {
+    includeImageBase64?: boolean;
+    tableFormat?: TSmartAiMistralOcrTableFormat;
+    extractHeader?: boolean;
+    extractFooter?: boolean;
+    confidenceScoresGranularity?: TSmartAiMistralOcrConfidenceScoresGranularity;
+}
+export declare const createMistralOcrEngine: (options?: ISmartAiMistralOcrOptions) => ISmartAiOcrEngine;

package/dist_ts_ocr/ocr.mistral.js

@@ -0,0 +1,77 @@
+const defaultMistralOcrModel = 'mistral-ocr-latest';
+const defaultMistralOcrEndpointUrl = 'https://api.mistral.ai/v1/ocr';
+const createMistralOcrHttpTransport = (options) => {
+    return {
+        process: async (request) => {
+            if (!options.apiKey) {
+                throw new Error('Mistral OCR requires an apiKey when no custom transport is provided.');
+            }
+            const response = await fetch(options.endpointUrl ?? defaultMistralOcrEndpointUrl, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${options.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(request),
+            });
+            if (!response.ok) {
+                const errorBody = await response.text();
+                throw new Error(`Mistral OCR request failed with status ${response.status}: ${errorBody}`);
+            }
+            return (await response.json());
+        },
+    };
+};
+const getPageConfidence = (page) => {
+    const confidenceScores = page.confidence_scores ?? page.confidenceScores;
+    return (confidenceScores?.average_page_confidence_score ??
+        confidenceScores?.averagePageConfidenceScore);
+};
+export const createMistralOcrEngine = (options = {}) => {
+    const transport = options.transport ??
+        createMistralOcrHttpTransport({
+            apiKey: options.apiKey,
+            endpointUrl: options.endpointUrl,
+        });
+    const model = options.model ?? defaultMistralOcrModel;
+    return {
+        recognizeImage: async (input, recognizeOptions = {}) => {
+            if (!input.dataBase64) {
+                throw new Error('Mistral OCR image input requires dataBase64.');
+            }
+            if (!input.mimeType) {
+                throw new Error('Mistral OCR image input requires mimeType.');
+            }
+            const response = await transport.process({
+                model,
+                document: {
+                    type: 'image_url',
+                    image_url: `data:${input.mimeType};base64,${input.dataBase64}`,
+                },
+                include_image_base64: recognizeOptions.includeImageBase64 ?? options.includeImageBase64 ?? false,
+                table_format: recognizeOptions.tableFormat ?? options.tableFormat,
+                extract_header: recognizeOptions.extractHeader ?? options.extractHeader,
+                extract_footer: recognizeOptions.extractFooter ?? options.extractFooter,
+                confidence_scores_granularity: recognizeOptions.confidenceScoresGranularity ?? options.confidenceScoresGranularity,
+            });
+            const pages = response.pages.map((page) => ({
+                index: page.index,
+                text: page.markdown,
+                confidence: getPageConfidence(page),
+            }));
+            const pageConfidences = pages
+                .map((page) => page.confidence)
+                .filter((confidence) => typeof confidence === 'number');
+            const confidence = pageConfidences.length
+                ? pageConfidences.reduce((sum, value) => sum + value, 0) / pageConfidences.length
+                : undefined;
+            return {
+                text: pages.map((page) => page.text).join('\n\n').trim(),
+                confidence,
+                pages,
+                raw: response,
+            };
+        },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tools/index.d.ts

@@ -0,0 +1,17 @@
+export { createBrowserTools } from './tool.browser.js';
+export { acquireToolExecutionContext, ToolExecutionAdapterCleanupError, } from '@modelprofile.com/flexharness-agent';
+export type { IToolExecutionAdapter, IToolExecutionAdapterRequest, IToolExecutionContextLease, } from '@modelprofile.com/flexharness-agent';
+export type { ICreateBrowserToolsOptions } from './tool.browser.js';
+export { createFilesystemTools } from './tool.filesystem.js';
+export type { ICreateFilesystemToolsOptions } from './tool.filesystem.js';
+export { createShellTools } from './tool.shell.js';
+export type { ICreateShellToolsOptions } from './tool.shell.js';
+export type { ToolSet } from 'ai';
+export { formatShellResult, formatToolOutput } from './tool.context.js';
+export type { IBrowserToolInput, IShellCommand, IShellFinishedResult, IShellStartedResult, IToolBrowserContext, IToolBrowserRunOptions, IToolExecutionContext, IToolFilesystemContext, IToolFilesystemListOptions, IToolFilesystemReadOptions, IToolInvocationOptions, IToolJobContext, IToolJobEvent, IToolJobOutputEvent, IToolJobHandle, IToolJobRequest, IToolJobState, IToolPermissionRequest, IToolRunOptions, IToolShellContext, IToolShellResult, TBrowserToolAction, TToolJobEvent, TToolJobEventListener, } from './tool.context.js';
+export { InMemoryToolJobStore, ToolJobStoreConflictError } from '@modelprofile.com/flexharness-agent';
+export type { IToolJobSnapshot, IToolJobStore } from '@modelprofile.com/flexharness-agent';
+export { httpTool } from './tool.http.js';
+export { jsonTool } from './tool.json.js';
+export { truncateOutput } from './plugins.js';
+export type { ITruncateResult } from './plugins.js';

package/dist_ts_tools/index.js

@@ -0,0 +1,10 @@
+export { createBrowserTools } from './tool.browser.js';
+export { acquireToolExecutionContext, ToolExecutionAdapterCleanupError, } from '@modelprofile.com/flexharness-agent';
+export { createFilesystemTools } from './tool.filesystem.js';
+export { createShellTools } from './tool.shell.js';
+export { formatShellResult, formatToolOutput } from './tool.context.js';
+export { InMemoryToolJobStore, ToolJobStoreConflictError } from '@modelprofile.com/flexharness-agent';
+export { httpTool } from './tool.http.js';
+export { jsonTool } from './tool.json.js';
+export { truncateOutput } from './plugins.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190b29scy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN2RCxPQUFPLEVBQ0wsMkJBQTJCLEVBQzNCLGdDQUFnQyxHQUNqQyxNQUFNLHFDQUFxQyxDQUFDO0FBTzdDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRTdELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBR25ELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBMkJ4RSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUV0RyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDMUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzFDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxjQUFjLENBQUMifQ==

package/dist_ts_tools/plugins.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { tool } from 'ai';
+import * as smartrequest from '@push.rocks/smartrequest';
+import { truncateOutput } from './utils.truncation.js';
+export { z, tool, smartrequest, truncateOutput };
+export type { ToolExecutionOptions, ToolSet } from 'ai';
+export type { ITruncateResult } from './utils.truncation.js';

package/dist_ts_tools/plugins.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { tool } from 'ai';
+import * as smartrequest from '@push.rocks/smartrequest';
+import { truncateOutput } from './utils.truncation.js';
+export { z, tool, smartrequest, truncateOutput };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3Rvb2xzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUN4QixPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQzFCLE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxDQUFDLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSxjQUFjLEVBQUUsQ0FBQyJ9

package/dist_ts_tools/tool.browser.d.ts

@@ -0,0 +1,11 @@
+import * as plugins from './plugins.js';
+import { type IToolExecutionContext, type TBrowserToolAction } from './tool.context.js';
+export interface ICreateBrowserToolsOptions {
+    /** Maximum output lines before truncating. */
+    maxLines?: number;
+    /** Maximum output bytes before truncating. */
+    maxBytes?: number;
+    /** Browser actions exposed by the tool. Defaults to every supported action. */
+    allowedActions?: readonly TBrowserToolAction[];
+}
+export declare function createBrowserTools(context: IToolExecutionContext, options?: ICreateBrowserToolsOptions): plugins.ToolSet;

package/dist_ts_tools/tool.browser.js

@@ -0,0 +1,128 @@
+import * as plugins from './plugins.js';
+import { formatToolOutput, } from './tool.context.js';
+const browserActions = [
+    'navigate',
+    'snapshot',
+    'screenshot',
+    'click',
+    'fill',
+    'press',
+    'evaluate',
+    'close',
+];
+export function createBrowserTools(context, options = {}) {
+    const allowedActions = normalizeAllowedBrowserActions(options.allowedActions);
+    const allowedActionList = [...allowedActions].join(', ');
+    const defaultAction = allowedActions.has('snapshot')
+        ? 'snapshot'
+        : allowedActions.values().next().value;
+    const description = [
+        'Control a browser supplied by the host execution context for web UI inspection and interaction.',
+        `Actions: ${allowedActionList}.`,
+        ...(allowedActions.has('snapshot')
+            ? ['Use snapshot after navigation or interaction to inspect page text and interactive selectors before choosing the next action.']
+            : []),
+        ...(hasBrowserSideEffectAction(allowedActions)
+            ? ['Actions that navigate or modify page state require host permission when configured.']
+            : []),
+    ].join(' ');
+    const inputSchema = plugins.z.object({
+        action: plugins.z.string().default(defaultAction).describe(`Action: ${allowedActionList}`),
+        url: plugins.z.string().optional().describe('Optional target URL'),
+        selector: plugins.z.string().optional().describe('Optional element selector'),
+        text: plugins.z.string().optional().describe('Optional text, key, or mode hint'),
+        script: plugins.z.string().optional().describe('Optional host-defined script input'),
+        timeoutMs: plugins.z.number().optional().describe('Optional action timeout in milliseconds'),
+    });
+    return {
+        browser: plugins.tool({
+            description,
+            inputSchema,
+            execute: async (input, invocationOptions) => {
+                if (!context.browser) {
+                    throw new Error('Browser tool is not available in this execution context.');
+                }
+                const action = normalizeBrowserAction(input.action, allowedActions, defaultAction);
+                const abortSignal = invocationOptions?.abortSignal ?? context.abortSignal;
+                await requestBrowserPermission(context, { ...input, action }, {
+                    toolCallId: invocationOptions?.toolCallId,
+                    abortSignal,
+                });
+                const result = await context.browser.execute({ ...input, action }, {
+                    timeoutMs: input.timeoutMs,
+                    toolCallId: invocationOptions?.toolCallId,
+                    abortSignal,
+                });
+                return plugins.truncateOutput(formatToolOutput(result), {
+                    maxLines: options.maxLines,
+                    maxBytes: options.maxBytes,
+                }).content;
+            },
+        }),
+    };
+}
+const normalizeAllowedBrowserActions = (actionsArg) => {
+    const actions = actionsArg ?? browserActions;
+    if (!Array.isArray(actions) || actions.length === 0) {
+        throw new Error('allowedActions must contain at least one supported browser action.');
+    }
+    const allowedActions = new Set();
+    for (const action of actions) {
+        if (!browserActions.includes(action)) {
+            throw new Error(`Unsupported allowed browser action: ${String(action)}.`);
+        }
+        allowedActions.add(action);
+    }
+    return allowedActions;
+};
+const hasBrowserSideEffectAction = (actionsArg) => {
+    for (const action of ['navigate', 'click', 'fill', 'press', 'evaluate', 'close']) {
+        if (actionsArg.has(action))
+            return true;
+    }
+    return false;
+};
+const normalizeBrowserAction = (input, allowedActions, defaultAction) => {
+    const action = typeof input === 'string' && input.trim()
+        ? input.trim().toLowerCase()
+        : defaultAction;
+    if (allowedActions.has(action)) {
+        return action;
+    }
+    throw new Error(`Unsupported browser action: ${String(input)}. Use one of: ${[...allowedActions].join(', ')}.`);
+};
+const requestBrowserPermission = async (context, input, invocationOptions) => {
+    if (!context.requestPermission)
+        return;
+    if (input.action === 'snapshot' || input.action === 'screenshot')
+        return;
+    const titleByAction = {
+        navigate: 'Navigate browser',
+        snapshot: 'Inspect browser',
+        screenshot: 'Capture browser screenshot',
+        click: 'Click browser element',
+        fill: 'Fill browser element',
+        press: 'Press browser key',
+        evaluate: 'Evaluate browser JavaScript',
+        close: 'Close browser session',
+    };
+    await context.requestPermission({
+        type: 'browser',
+        title: titleByAction[input.action],
+        toolCallId: invocationOptions.toolCallId,
+        abortSignal: invocationOptions.abortSignal,
+        metadata: {
+            action: input.action,
+            url: input.url,
+            selector: input.selector,
+            key: input.action === 'press' ? input.text : undefined,
+            textLength: input.action === 'fill' ? input.text?.length ?? 0 : undefined,
+            scriptPreview: input.action === 'evaluate' && input.script ? compactMetadataText(input.script) : undefined,
+        },
+    });
+};
+const compactMetadataText = (text) => {
+    const compacted = text.replace(/\s+/g, ' ').trim();
+    return compacted.length > 160 ? `${compacted.slice(0, 157)}...` : compacted;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tools/tool.context.d.ts

@@ -0,0 +1,4 @@
+import type { IToolShellResult } from '@modelprofile.com/flexharness-agent';
+export type * from '@modelprofile.com/flexharness-agent';
+export declare const formatShellResult: (result: IToolShellResult | string) => string;
+export declare const formatToolOutput: (output: unknown) => string;

package/dist_ts_tools/tool.context.js

@@ -0,0 +1,23 @@
+export const formatShellResult = (result) => {
+    if (typeof result === 'string')
+        return result;
+    if (result.exitCode === 0)
+        return result.stdout;
+    return [
+        `Exit code: ${result.exitCode}`,
+        result.signal ? `Signal: ${result.signal}` : '',
+        `stdout:\n${result.stdout}`,
+        `stderr:\n${result.stderr ?? ''}`,
+    ].filter(Boolean).join('\n');
+};
+export const formatToolOutput = (output) => {
+    if (typeof output === 'string')
+        return output;
+    try {
+        return JSON.stringify(output, undefined, 2);
+    }
+    catch {
+        return String(output);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbC5jb250ZXh0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfdG9vbHMvdG9vbC5jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLENBQUMsTUFBaUMsRUFBVSxFQUFFO0lBQzdFLElBQUksT0FBTyxNQUFNLEtBQUssUUFBUTtRQUFFLE9BQU8sTUFBTSxDQUFDO0lBQzlDLElBQUksTUFBTSxDQUFDLFFBQVEsS0FBSyxDQUFDO1FBQUUsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ2hELE9BQU87UUFDTCxjQUFjLE1BQU0sQ0FBQyxRQUFRLEVBQUU7UUFDL0IsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsV0FBVyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUU7UUFDL0MsWUFBWSxNQUFNLENBQUMsTUFBTSxFQUFFO1FBQzNCLFlBQVksTUFBTSxDQUFDLE1BQU0sSUFBSSxFQUFFLEVBQUU7S0FDbEMsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQy9CLENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsTUFBZSxFQUFVLEVBQUU7SUFDMUQsSUFBSSxPQUFPLE1BQU0sS0FBSyxRQUFRO1FBQUUsT0FBTyxNQUFNLENBQUM7SUFDOUMsSUFBSSxDQUFDO1FBQ0gsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDOUMsQ0FBQztJQUFDLE1BQU0sQ0FBQztRQUNQLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3hCLENBQUM7QUFDSCxDQUFDLENBQUMifQ==

package/dist_ts_tools/tool.filesystem.d.ts

@@ -0,0 +1,11 @@
+import * as plugins from './plugins.js';
+import { type IToolExecutionContext } from './tool.context.js';
+export interface ICreateFilesystemToolsOptions {
+    /** Include delete_file. Default: true. */
+    includeDelete?: boolean;
+    /** Maximum output lines before truncating. */
+    maxLines?: number;
+    /** Maximum output bytes before truncating. */
+    maxBytes?: number;
+}
+export declare function createFilesystemTools(context: IToolExecutionContext, options?: ICreateFilesystemToolsOptions): plugins.ToolSet;

package/dist_ts_tools/tool.filesystem.js

@@ -0,0 +1,106 @@
+import * as plugins from './plugins.js';
+import { formatToolOutput, } from './tool.context.js';
+export function createFilesystemTools(context, options = {}) {
+    const truncate = (output) => plugins.truncateOutput(formatToolOutput(output), {
+        maxLines: options.maxLines,
+        maxBytes: options.maxBytes,
+    }).content;
+    const tools = {
+        read_file: plugins.tool({
+            description: 'Read a UTF-8 file in the active workspace. Paths may be absolute or relative to the workspace root.',
+            inputSchema: plugins.z.object({
+                path: plugins.z.string().describe('File path'),
+                startLine: plugins.z
+                    .number()
+                    .optional()
+                    .describe('First line (1-indexed, inclusive)'),
+                endLine: plugins.z
+                    .number()
+                    .optional()
+                    .describe('Last line (1-indexed, inclusive)'),
+            }),
+            execute: async ({ path: filePath, startLine, endLine, }, invocationOptions) => {
+                if (!context.fs) {
+                    throw new Error('Filesystem tools are not available in this execution context.');
+                }
+                return truncate(await context.fs.readFile(filePath, { startLine, endLine }, {
+                    toolCallId: invocationOptions?.toolCallId,
+                    abortSignal: invocationOptions?.abortSignal ?? context.abortSignal,
+                }));
+            },
+        }),
+        write_file: plugins.tool({
+            description: 'Write UTF-8 content to a file in the active workspace. Creates parent directories and overwrites existing content. Requires host permission when configured.',
+            inputSchema: plugins.z.object({
+                path: plugins.z.string().describe('File path'),
+                content: plugins.z.string().describe('Complete file content to write'),
+            }),
+            execute: async ({ path: filePath, content }, invocationOptions) => {
+                if (!context.fs) {
+                    throw new Error('Filesystem tools are not available in this execution context.');
+                }
+                const abortSignal = invocationOptions?.abortSignal ?? context.abortSignal;
+                await context.requestPermission?.({
+                    type: 'write',
+                    title: 'Write file',
+                    metadata: { path: filePath, bytes: Buffer.byteLength(content, 'utf8') },
+                    toolCallId: invocationOptions?.toolCallId,
+                    abortSignal,
+                });
+                const result = await context.fs.writeFile(filePath, content, {
+                    toolCallId: invocationOptions?.toolCallId,
+                    abortSignal,
+                });
+                return truncate(result ?? `Written ${Buffer.byteLength(content, 'utf8')} bytes to ${filePath}`);
+            },
+        }),
+        list_directory: plugins.tool({
+            description: 'List files and directories in the active workspace. Paths may be absolute or relative to the workspace root.',
+            inputSchema: plugins.z.object({
+                path: plugins.z.string().default('.').describe('Directory path to list'),
+                recursive: plugins.z
+                    .boolean()
+                    .optional()
+                    .describe('List recursively. Default: false'),
+            }),
+            execute: async ({ path: directoryPath, recursive }, invocationOptions) => {
+                if (!context.fs) {
+                    throw new Error('Filesystem tools are not available in this execution context.');
+                }
+                const result = await context.fs.listDirectory(directoryPath, { recursive }, {
+                    toolCallId: invocationOptions?.toolCallId,
+                    abortSignal: invocationOptions?.abortSignal ?? context.abortSignal,
+                });
+                return truncate(Array.isArray(result) ? result.join('\n') : result);
+            },
+        }),
+    };
+    if (options.includeDelete !== false) {
+        tools.delete_file = plugins.tool({
+            description: 'Delete a file or empty directory in the active workspace. Requires host permission when configured.',
+            inputSchema: plugins.z.object({
+                path: plugins.z.string().describe('Path to delete'),
+            }),
+            execute: async ({ path: targetPath }, invocationOptions) => {
+                if (!context.fs?.deletePath) {
+                    throw new Error('Deleting files is not available in this execution context.');
+                }
+                const abortSignal = invocationOptions?.abortSignal ?? context.abortSignal;
+                await context.requestPermission?.({
+                    type: 'delete',
+                    title: 'Delete file',
+                    metadata: { path: targetPath },
+                    toolCallId: invocationOptions?.toolCallId,
+                    abortSignal,
+                });
+                const result = await context.fs.deletePath(targetPath, {
+                    toolCallId: invocationOptions?.toolCallId,
+                    abortSignal,
+                });
+                return truncate(result ?? `Deleted ${targetPath}`);
+            },
+        });
+    }
+    return tools;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tools/tool.http.d.ts

@@ -0,0 +1,2 @@
+import * as plugins from './plugins.js';
+export declare function httpTool(): plugins.ToolSet;

package/dist_ts_tools/tool.http.js

@@ -0,0 +1,65 @@
+import * as plugins from './plugins.js';
+export function httpTool() {
+    return {
+        http_get: plugins.tool({
+            description: 'Make an HTTP GET request and return the response.',
+            inputSchema: plugins.z.object({
+                url: plugins.z.string().describe('URL to request'),
+                headers: plugins.z
+                    .record(plugins.z.string(), plugins.z.string())
+                    .optional()
+                    .describe('Request headers'),
+            }),
+            execute: async ({ url, headers, }) => {
+                let req = plugins.smartrequest.default.create().url(url);
+                if (headers) {
+                    req = req.headers(headers);
+                }
+                const response = await req.get();
+                let body;
+                try {
+                    const json = await response.json();
+                    body = JSON.stringify(json, null, 2);
+                }
+                catch {
+                    body = await response.text();
+                }
+                return plugins.truncateOutput(`HTTP ${response.status}\n${body}`).content;
+            },
+        }),
+        http_post: plugins.tool({
+            description: 'Make an HTTP POST request with a JSON body.',
+            inputSchema: plugins.z.object({
+                url: plugins.z.string().describe('URL to request'),
+                body: plugins.z
+                    .record(plugins.z.string(), plugins.z.unknown())
+                    .optional()
+                    .describe('JSON body to send'),
+                headers: plugins.z
+                    .record(plugins.z.string(), plugins.z.string())
+                    .optional()
+                    .describe('Request headers'),
+            }),
+            execute: async ({ url, body, headers, }) => {
+                let req = plugins.smartrequest.default.create().url(url);
+                if (headers) {
+                    req = req.headers(headers);
+                }
+                if (body) {
+                    req = req.json(body);
+                }
+                const response = await req.post();
+                let responseBody;
+                try {
+                    const json = await response.json();
+                    responseBody = JSON.stringify(json, null, 2);
+                }
+                catch {
+                    responseBody = await response.text();
+                }
+                return plugins.truncateOutput(`HTTP ${response.status}\n${responseBody}`).content;
+            },
+        }),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tools/tool.json.d.ts

@@ -0,0 +1,2 @@
+import * as plugins from './plugins.js';
+export declare function jsonTool(): plugins.ToolSet;