@jshookmcp/jshook 0.2.6 → 0.2.7

package/dist/src/server/macros/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/server/observability/InstrumentationContract.d.ts

@@ -1,37 +0,0 @@
-export type MetricType = 'counter' | 'gauge' | 'histogram';
-export interface SpanLike {
-    readonly name: string;
-    readonly startTime: number;
-    end(attrs?: Record<string, unknown>): void;
-    addEvent(name: string, attrs?: Record<string, unknown>): void;
-}
-export interface InstrumentationContract {
-    startSpan(name: string, attrs?: Record<string, unknown>): SpanLike;
-    emitMetric(name: string, value: number, type: MetricType, attrs?: Record<string, unknown>): void;
-    flush?(): Promise<void>;
-}
-export declare const SpanNames: {
-    readonly toolExecute: "tool.execute";
-    readonly toolValidateInput: "tool.validate_input";
-    readonly registryDiscovery: "registry.discovery";
-    readonly pluginLifecycle: "plugin.lifecycle";
-    readonly workflowRun: "workflow.run";
-    readonly workflowStep: "workflow.step";
-    readonly bridgeRequest: "bridge.request";
-    readonly captchaSolve: "captcha.solve";
-};
-export declare const MetricNames: {
-    readonly toolCallsTotal: "tool_calls_total";
-    readonly toolErrorsTotal: "tool_errors_total";
-    readonly toolDurationMs: "tool_duration_ms";
-    readonly workflowRunsTotal: "workflow_runs_total";
-    readonly workflowErrorsTotal: "workflow_errors_total";
-    readonly workflowDurationMs: "workflow_duration_ms";
-    readonly bridgeRequestsTotal: "bridge_requests_total";
-    readonly bridgeDurationMs: "bridge_duration_ms";
-    readonly pluginActiveTotal: "plugin_active_total";
-};
-export declare class NoopInstrumentation implements InstrumentationContract {
-    startSpan(name: string, _attrs?: Record<string, unknown>): SpanLike;
-    emitMetric(_name: string, _value: number, _type: MetricType, _attrs?: Record<string, unknown>): void;
-}

package/dist/src/server/observability/InstrumentationContract.js

@@ -1,36 +0,0 @@
-export const SpanNames = {
-    toolExecute: 'tool.execute',
-    toolValidateInput: 'tool.validate_input',
-    registryDiscovery: 'registry.discovery',
-    pluginLifecycle: 'plugin.lifecycle',
-    workflowRun: 'workflow.run',
-    workflowStep: 'workflow.step',
-    bridgeRequest: 'bridge.request',
-    captchaSolve: 'captcha.solve',
-};
-export const MetricNames = {
-    toolCallsTotal: 'tool_calls_total',
-    toolErrorsTotal: 'tool_errors_total',
-    toolDurationMs: 'tool_duration_ms',
-    workflowRunsTotal: 'workflow_runs_total',
-    workflowErrorsTotal: 'workflow_errors_total',
-    workflowDurationMs: 'workflow_duration_ms',
-    bridgeRequestsTotal: 'bridge_requests_total',
-    bridgeDurationMs: 'bridge_duration_ms',
-    pluginActiveTotal: 'plugin_active_total',
-};
-export class NoopInstrumentation {
-    startSpan(name, _attrs) {
-        const startTime = Date.now();
-        return {
-            name,
-            startTime,
-            end() {
-            },
-            addEvent() {
-            },
-        };
-    }
-    emitMetric(_name, _value, _type, _attrs) {
-    }
-}

package/dist/src/server/plugin-api.d.ts

@@ -1,5 +0,0 @@
-export type { ExtensionBuilder, PluginLifecycleContext } from './plugins/PluginContract.js';
-export type { ToolArgs } from './types.js';
-export { getPluginBooleanConfig, getPluginBoostTier } from './extensions/plugin-config.js';
-export { loadPluginEnv } from './extensions/plugin-env.js';
-export { createExtension, jsonResponse, errorResponse } from './plugins/PluginContract.js';

package/dist/src/server/plugin-api.js

@@ -1,3 +0,0 @@
-export { getPluginBooleanConfig, getPluginBoostTier } from './extensions/plugin-config.js';
-export { loadPluginEnv } from './extensions/plugin-env.js';
-export { createExtension, jsonResponse, errorResponse } from './plugins/PluginContract.js';

package/dist/src/server/plugins/PluginContract.d.ts

@@ -1 +0,0 @@
-export { type ToolProfileId, type ToolArgs, type ToolResponse, type PluginState, type PluginLifecycleContext, type ExtensionToolHandler, type ExtensionToolDefinition, type ExtensionWorkflowDefinition, ExtensionBuilder, createExtension, jsonResponse, errorResponse, } from '../../../packages/extension-sdk/src/plugin.js';

package/dist/src/server/plugins/PluginContract.js

@@ -1 +0,0 @@
-export { ExtensionBuilder, createExtension, jsonResponse, errorResponse, } from '../../../packages/extension-sdk/src/plugin.js';

package/dist/src/server/plugins/examples/minimal-plugin/manifest.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

package/dist/src/server/plugins/examples/minimal-plugin/manifest.js

@@ -1,17 +0,0 @@
-import { createExtension } from '@jshookmcp/extension-sdk';
-export default createExtension('example.minimal', '1.0.0')
-    .name('Minimal Example Plugin')
-    .description('A super basic plugin with a fluent builder')
-    .allowCommand(['echo', 'ping'])
-    .tool('echo', 'Echoes back the input', {
-    type: 'object',
-    properties: { text: { type: 'string' } },
-    required: ['text'],
-}, async (args) => {
-    return {
-        content: [{ type: 'text', text: `Echo: ${args.text}` }],
-    };
-})
-    .onLoad(async (ctx) => {
-    ctx.setRuntimeData('loaded', true);
-});

package/dist/src/server/registry/bind-helpers.d.ts

@@ -1,4 +0,0 @@
-import type { ToolArgs } from '../types.js';
-import type { ToolHandlerDeps } from '../registry/contracts.js';
-export declare function getDep<T>(deps: ToolHandlerDeps, key: string): T;
-export declare function bindByDepKey<THandler>(depKey: string, invoke: (handler: THandler, args: ToolArgs) => Promise<unknown>): (deps: ToolHandlerDeps) => (args: ToolArgs) => Promise<unknown>;

package/dist/src/server/registry/bind-helpers.js

@@ -1,10 +0,0 @@
-export function getDep(deps, key) {
-    const value = deps[key];
-    if (!value) {
-        throw new Error(`[registry] Missing dependency: "${key}". Is the domain enabled?`);
-    }
-    return value;
-}
-export function bindByDepKey(depKey, invoke) {
-    return (deps) => (args) => invoke(getDep(deps, depKey), args);
-}

package/dist/src/server/registry/contracts.d.ts

@@ -1,39 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { ToolArgs } from '../types.js';
-import type { MCPServerContext } from '../MCPServer.context.js';
-export type ToolProfileId = 'search' | 'workflow' | 'full' | 'restricted';
-export interface ToolHandlerDeps {
-    readonly [depKey: string]: unknown;
-}
-export interface ToolRegistration {
-    readonly tool: Tool;
-    readonly domain?: string;
-    readonly bind: (deps: ToolHandlerDeps) => (args: ToolArgs) => Promise<unknown>;
-    readonly profiles?: readonly ToolProfileId[];
-}
-export interface DomainManifest<TDepKey extends string = string, THandler = unknown, TDomain extends string = string> {
-    readonly kind: 'domain-manifest';
-    readonly version: 1;
-    readonly domain: TDomain;
-    readonly depKey: TDepKey;
-    readonly secondaryDepKeys?: readonly string[];
-    readonly profiles: readonly ToolProfileId[];
-    readonly registrations: readonly ToolRegistration[];
-    readonly ensure: (ctx: MCPServerContext) => THandler | Promise<THandler>;
-    readonly workflowRule?: {
-        readonly patterns: readonly RegExp[];
-        readonly priority: number;
-        readonly tools: readonly string[];
-        readonly hint: string;
-    };
-    readonly prerequisites?: Readonly<Record<string, ReadonlyArray<{
-        readonly condition: string;
-        readonly fix: string;
-    }>>>;
-    readonly toolDependencies?: ReadonlyArray<{
-        readonly from: string;
-        readonly to: string;
-        readonly relation: 'requires' | 'precedes' | 'suggests';
-        readonly weight?: number;
-    }>;
-}

package/dist/src/server/registry/contracts.js

@@ -1 +0,0 @@
-export {};

package/dist/src/server/registry/discovery.d.ts

@@ -1,2 +0,0 @@
-import type { DomainManifest } from '../registry/contracts.js';
-export declare function discoverDomainManifests(): Promise<DomainManifest[]>;

package/dist/src/server/registry/discovery.js

@@ -1,107 +0,0 @@
-import { readdir, stat } from 'node:fs/promises';
-import { join, relative, sep } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { logger } from '../../utils/logger.js';
-const registryDirUrl = new URL('.', import.meta.url);
-const registryDir = fileURLToPath(registryDirUrl);
-function isDomainManifest(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const m = value;
-    return (m['kind'] === 'domain-manifest' &&
-        m['version'] === 1 &&
-        typeof m['domain'] === 'string' &&
-        typeof m['depKey'] === 'string' &&
-        Array.isArray(m['profiles']) &&
-        Array.isArray(m['registrations']) &&
-        typeof m['ensure'] === 'function');
-}
-function extractManifest(mod) {
-    if (!mod || typeof mod !== 'object')
-        return null;
-    const m = mod;
-    for (const key of ['default', 'manifest', 'domainManifest']) {
-        const candidate = m[key];
-        if (isDomainManifest(candidate))
-            return candidate;
-    }
-    return null;
-}
-async function discoverManifestPaths() {
-    const domainsDir = fileURLToPath(new URL('../domains/', registryDirUrl));
-    let entries;
-    try {
-        entries = await readdir(domainsDir, { withFileTypes: true });
-    }
-    catch (err) {
-        logger.error('[discovery] Cannot read domains directory:', err);
-        return [];
-    }
-    const directories = entries.filter((e) => e.isDirectory());
-    const resolved = await Promise.all(directories.map(async (entry) => {
-        for (const ext of ['manifest.js', 'manifest.ts']) {
-            const manifestPath = join(domainsDir, entry.name, ext);
-            try {
-                const s = await stat(manifestPath);
-                if (s.isFile())
-                    return manifestPath;
-            }
-            catch {
-            }
-        }
-        return null;
-    }));
-    return resolved.filter((value) => value !== null);
-}
-function toImportSpecifier(absPath) {
-    const relPath = relative(registryDir, absPath).split(sep).join('/');
-    if (relPath.startsWith('.')) {
-        return relPath;
-    }
-    return `./${relPath}`;
-}
-export async function discoverDomainManifests() {
-    const files = await discoverManifestPaths();
-    const manifests = [];
-    const seenDomains = new Set();
-    const seenDepKeys = new Set();
-    for (const absPath of files) {
-        try {
-            const mod = await import(toImportSpecifier(absPath));
-            const manifest = extractManifest(mod);
-            if (!manifest) {
-                logger.warn('[discovery] Skipping ' + absPath + ': no valid DomainManifest export');
-                continue;
-            }
-            if (seenDomains.has(manifest.domain)) {
-                logger.warn('[discovery] Duplicate domain "' + manifest.domain + '" in ' + absPath + ' - skipping');
-                continue;
-            }
-            if (seenDepKeys.has(manifest.depKey)) {
-                logger.warn('[discovery] Duplicate depKey "' + manifest.depKey + '" in ' + absPath + ' - skipping');
-                continue;
-            }
-            seenDomains.add(manifest.domain);
-            seenDepKeys.add(manifest.depKey);
-            manifests.push(manifest);
-            logger.info('[discovery] Loaded domain "' +
-                manifest.domain +
-                '" (' +
-                String(manifest.registrations.length) +
-                ' tools)');
-        }
-        catch (err) {
-            logger.error('[discovery] Failed to load manifest: ' + absPath, err);
-            if (process.env.DISCOVERY_STRICT === 'true') {
-                throw err;
-            }
-        }
-    }
-    const totalTools = manifests.reduce((n, m) => n + m.registrations.length, 0);
-    logger.info('[discovery] Discovered ' +
-        String(manifests.length) +
-        ' domains, ' +
-        String(totalTools) +
-        ' tools total');
-    return manifests;
-}

package/dist/src/server/registry/ensure-browser-core.d.ts

@@ -1,2 +0,0 @@
-import type { MCPServerContext } from '../MCPServer.context.js';
-export declare function ensureBrowserCore(ctx: MCPServerContext): void;

package/dist/src/server/registry/ensure-browser-core.js

@@ -1,19 +0,0 @@
-import { CodeCollector } from '../../modules/collector/CodeCollector.js';
-import { PageController } from '../../modules/collector/PageController.js';
-import { DOMInspector } from '../../modules/collector/DOMInspector.js';
-import { ScriptManager } from '../../modules/debugger/ScriptManager.js';
-import { ConsoleMonitor } from '../../modules/monitor/ConsoleMonitor.js';
-export function ensureBrowserCore(ctx) {
-    if (!ctx.collector) {
-        ctx.collector = new CodeCollector(ctx.config.puppeteer);
-        void ctx.registerCaches();
-    }
-    if (!ctx.pageController)
-        ctx.pageController = new PageController(ctx.collector);
-    if (!ctx.domInspector)
-        ctx.domInspector = new DOMInspector(ctx.collector);
-    if (!ctx.scriptManager)
-        ctx.scriptManager = new ScriptManager(ctx.collector);
-    if (!ctx.consoleMonitor)
-        ctx.consoleMonitor = new ConsoleMonitor(ctx.collector);
-}

package/dist/src/server/registry/index.d.ts

@@ -1,14 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { DomainManifest, ToolHandlerDeps, ToolRegistration, ToolProfileId } from '../registry/contracts.js';
-import type { ToolHandler } from '../types.js';
-export declare function initRegistry(): Promise<void>;
-export declare function getAllManifests(): readonly DomainManifest[];
-export declare function getAllRegistrations(): readonly ToolRegistration[];
-export declare function getAllDomains(): ReadonlySet<string>;
-export declare function getAllToolNames(): ReadonlySet<string>;
-export declare function getRegistrationByName(name: string): ToolRegistration | undefined;
-export declare function buildToolGroups(): Record<string, Tool[]>;
-export declare function buildToolDomainMap(): ReadonlyMap<string, string>;
-export declare function buildAllTools(): Tool[];
-export declare function buildHandlerMapFromRegistry(deps: ToolHandlerDeps, selectedToolNames?: ReadonlySet<string>): Record<string, ToolHandler>;
-export declare function buildProfileDomains(): Record<ToolProfileId, string[]>;

package/dist/src/server/registry/index.js

@@ -1,123 +0,0 @@
-function isSubset(a, b) {
-    const bSet = new Set(b);
-    return a.every((x) => bSet.has(x));
-}
-import { discoverDomainManifests } from '../registry/discovery.js';
-import { logger } from '../../utils/logger.js';
-let _manifests = null;
-let _registrations = null;
-let _initPromise = null;
-let _domainsView = null;
-let _toolNamesView = null;
-let _registrationsByName = null;
-async function init() {
-    if (_manifests !== null)
-        return;
-    if (_initPromise) {
-        await _initPromise;
-        return;
-    }
-    _initPromise = (async () => {
-        const discovered = await discoverDomainManifests();
-        _manifests = discovered;
-        const uniqueByToolName = new Map();
-        for (const m of discovered) {
-            for (const r of m.registrations) {
-                const registration = r.domain ? r : { ...r, domain: m.domain };
-                const existing = uniqueByToolName.get(registration.tool.name);
-                if (existing) {
-                    logger.warn(`[registry] Duplicate tool name "${registration.tool.name}": domain "${registration.domain}" conflicts with "${existing.domain}" — keeping first`);
-                }
-                else {
-                    uniqueByToolName.set(registration.tool.name, registration);
-                }
-            }
-        }
-        _registrations = [...uniqueByToolName.values()];
-        _domainsView = new Set(_manifests.map((m) => m.domain));
-        _toolNamesView = new Set(_registrations.map((r) => r.tool.name));
-    })();
-    await _initPromise;
-}
-export async function initRegistry() {
-    await init();
-}
-function getManifests() {
-    if (!_manifests)
-        throw new Error('[registry] Not initialised - call initRegistry() first.');
-    return _manifests;
-}
-function getRegistrations() {
-    if (!_registrations)
-        throw new Error('[registry] Not initialised - call initRegistry() first.');
-    return _registrations;
-}
-export function getAllManifests() {
-    return getManifests();
-}
-export function getAllRegistrations() {
-    return getRegistrations();
-}
-export function getAllDomains() {
-    if (!_domainsView)
-        throw new Error('[registry] Not initialised - call initRegistry() first.');
-    return _domainsView;
-}
-export function getAllToolNames() {
-    if (!_toolNamesView)
-        throw new Error('[registry] Not initialised - call initRegistry() first.');
-    return _toolNamesView;
-}
-export function getRegistrationByName(name) {
-    if (!_registrationsByName) {
-        _registrationsByName = new Map(getRegistrations().map((r) => [r.tool.name, r]));
-    }
-    return _registrationsByName.get(name);
-}
-export function buildToolGroups() {
-    const groups = {};
-    for (const r of getRegistrations()) {
-        (groups[r.domain] ??= []).push(r.tool);
-    }
-    return groups;
-}
-export function buildToolDomainMap() {
-    const map = new Map();
-    for (const r of getRegistrations()) {
-        if (!map.has(r.tool.name))
-            map.set(r.tool.name, r.domain);
-    }
-    return map;
-}
-export function buildAllTools() {
-    return getRegistrations().map((r) => r.tool);
-}
-export function buildHandlerMapFromRegistry(deps, selectedToolNames) {
-    const regs = selectedToolNames
-        ? getRegistrations().filter((r) => selectedToolNames.has(r.tool.name))
-        : [...getRegistrations()];
-    return Object.fromEntries(regs.map((r) => [r.tool.name, r.bind(deps)]));
-}
-export function buildProfileDomains() {
-    const profiles = {
-        search: new Set(),
-        workflow: new Set(),
-        full: new Set(),
-    };
-    for (const m of getManifests()) {
-        for (const p of m.profiles) {
-            profiles[p]?.add(m.domain);
-        }
-    }
-    const result = {};
-    for (const [p, domains] of Object.entries(profiles)) {
-        result[p] = [...domains];
-    }
-    if (!isSubset(result['search'], result['workflow'])) {
-        logger.warn('[registry] Profile hierarchy: search not subset of workflow');
-    }
-    if (!isSubset(result['workflow'], result['full'])) {
-        logger.warn('[registry] Profile hierarchy: workflow not subset of full');
-    }
-    return result;
-}

package/dist/src/server/registry/tool-builder.d.ts

@@ -1,46 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array';
-interface PropertySchema {
-    type?: JsonSchemaType;
-    description?: string;
-    default?: unknown;
-    enum?: readonly string[];
-    items?: PropertySchema | Record<string, unknown>;
-    properties?: Record<string, PropertySchema>;
-    required?: string[];
-    [key: string]: unknown;
-}
-interface ParamOpts {
-    default?: unknown;
-}
-declare class ToolBuilder {
-    private readonly _name;
-    private _description;
-    private readonly _properties;
-    private readonly _required;
-    private _readOnlyHint;
-    private _destructiveHint;
-    private _idempotentHint;
-    private _openWorldHint;
-    constructor(name: string);
-    desc(description: string): this;
-    string(name: string, description: string, opts?: ParamOpts): this;
-    number(name: string, description: string, opts?: ParamOpts): this;
-    integer(name: string, description: string, opts?: ParamOpts): this;
-    boolean(name: string, description: string, opts?: ParamOpts): this;
-    enum(name: string, values: readonly string[], description: string, opts?: ParamOpts): this;
-    array(name: string, items: PropertySchema | Record<string, unknown>, description: string): this;
-    object(name: string, props: Record<string, PropertySchema>, description: string, opts?: {
-        required?: string[];
-    }): this;
-    prop(name: string, schema: PropertySchema): this;
-    required(...names: string[]): this;
-    readOnly(): this;
-    destructive(): this;
-    idempotent(): this;
-    openWorld(): this;
-    build(): Tool;
-    private defaults;
-}
-export declare function tool(name: string): ToolBuilder;
-export {};

package/dist/src/server/registry/tool-builder.js

@@ -1,105 +0,0 @@
-class ToolBuilder {
-    _name;
-    _description = '';
-    _properties = {};
-    _required = [];
-    _readOnlyHint = false;
-    _destructiveHint = false;
-    _idempotentHint = false;
-    _openWorldHint = false;
-    constructor(name) {
-        this._name = name;
-    }
-    desc(description) {
-        this._description = description;
-        return this;
-    }
-    string(name, description, opts) {
-        this._properties[name] = { type: 'string', description, ...this.defaults(opts) };
-        return this;
-    }
-    number(name, description, opts) {
-        this._properties[name] = { type: 'number', description, ...this.defaults(opts) };
-        return this;
-    }
-    integer(name, description, opts) {
-        this._properties[name] = { type: 'integer', description, ...this.defaults(opts) };
-        return this;
-    }
-    boolean(name, description, opts) {
-        this._properties[name] = { type: 'boolean', description, ...this.defaults(opts) };
-        return this;
-    }
-    enum(name, values, description, opts) {
-        this._properties[name] = {
-            type: 'string',
-            enum: values,
-            description,
-            ...this.defaults(opts),
-        };
-        return this;
-    }
-    array(name, items, description) {
-        this._properties[name] = { type: 'array', items, description };
-        return this;
-    }
-    object(name, props, description, opts) {
-        this._properties[name] = {
-            type: 'object',
-            properties: props,
-            description,
-            ...(opts?.required ? { required: opts.required } : {}),
-        };
-        return this;
-    }
-    prop(name, schema) {
-        this._properties[name] = schema;
-        return this;
-    }
-    required(...names) {
-        this._required.push(...names);
-        return this;
-    }
-    readOnly() {
-        this._readOnlyHint = true;
-        return this;
-    }
-    destructive() {
-        this._destructiveHint = true;
-        return this;
-    }
-    idempotent() {
-        this._idempotentHint = true;
-        return this;
-    }
-    openWorld() {
-        this._openWorldHint = true;
-        return this;
-    }
-    build() {
-        const result = {
-            name: this._name,
-            description: this._description,
-            inputSchema: {
-                type: 'object',
-                properties: this._properties,
-                ...(this._required.length > 0 ? { required: this._required } : {}),
-            },
-            annotations: {
-                readOnlyHint: this._readOnlyHint,
-                destructiveHint: this._destructiveHint,
-                idempotentHint: this._idempotentHint,
-                openWorldHint: this._openWorldHint,
-            },
-        };
-        return result;
-    }
-    defaults(opts) {
-        if (opts?.default === undefined)
-            return {};
-        return { default: opts.default };
-    }
-}
-export function tool(name) {
-    return new ToolBuilder(name);
-}

package/dist/src/server/registry/types.d.ts

@@ -1,5 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-export type { ToolRegistration, ToolHandlerDeps, ToolProfileId, DomainManifest, } from '../registry/contracts.js';
-export type ToolDomain = string;
-export type ToolHandlerMapDependencies = Record<string, unknown>;
-export declare function toolLookup(tools: readonly Tool[]): (name: string) => Tool;

package/dist/src/server/registry/types.js

@@ -1,9 +0,0 @@
-export function toolLookup(tools) {
-    const map = new Map(tools.map((t) => [t.name, t]));
-    return (name) => {
-        const tool = map.get(name);
-        if (!tool)
-            throw new Error(`[registry] Tool definition not found: "${name}"`);
-        return tool;
-    };
-}

package/dist/src/server/sandbox/AutoCorrectionLoop.d.ts

@@ -1,6 +0,0 @@
-import type { QuickJSSandbox } from '../sandbox/QuickJSSandbox.js';
-import type { SandboxOptions, SandboxResult } from '../sandbox/types.js';
-export interface AutoCorrectedResult extends SandboxResult {
-    retryCount: number;
-}
-export declare function executeWithRetry(sandbox: QuickJSSandbox, code: string, options?: SandboxOptions, maxRetries?: number): Promise<AutoCorrectedResult>;

package/dist/src/server/sandbox/AutoCorrectionLoop.js

@@ -1,17 +0,0 @@
-export async function executeWithRetry(sandbox, code, options = {}, maxRetries = 2) {
-    let lastResult = null;
-    let currentCode = code;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        lastResult = await sandbox.execute(currentCode, options);
-        if (lastResult.ok) {
-            return { ...lastResult, retryCount: attempt };
-        }
-        if (lastResult.timedOut) {
-            return { ...lastResult, retryCount: attempt };
-        }
-        if (attempt < maxRetries) {
-            currentCode = `/* Previous error (attempt ${attempt + 1}): ${lastResult.error ?? 'unknown error'} */\n${code}`;
-        }
-    }
-    return { ...lastResult, retryCount: maxRetries };
-}

package/dist/src/server/sandbox/DynamicToolRegistry.d.ts

@@ -1,17 +0,0 @@
-import type { MCPServerContext } from '../MCPServer.context.js';
-export interface DynamicToolEntry {
-    name: string;
-    prefixedName: string;
-    description: string;
-    handler: (args: Record<string, unknown>) => Promise<unknown>;
-}
-export declare class DynamicToolRegistry {
-    private readonly ctx;
-    private readonly tools;
-    constructor(ctx: MCPServerContext);
-    registerDynamicTool(name: string, description: string, handler: (args: Record<string, unknown>) => Promise<unknown>): string;
-    unregisterDynamicTool(prefixedName: string): boolean;
-    listDynamicTools(): DynamicToolEntry[];
-    getHandler(prefixedName: string): DynamicToolEntry | undefined;
-    clearAll(): void;
-}