@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/tools/fetch/runtime.js

@@ -0,0 +1,395 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { FETCH_TOOL_SCHEMA } from '@pellux/goodvibes-sdk/platform/tools/fetch/schema';
+import { applySanitizer, resolveSanitizeMode } from '@pellux/goodvibes-sdk/platform/tools/fetch/sanitizer';
+import { classifyHostTrustTier, emitSsrfDeny, emitHostTrustTier, extractHostname, } from '@pellux/goodvibes-sdk/platform/tools/fetch/trust-tiers';
+import { applyExtract, sniffContentType } from '@pellux/goodvibes-sdk/platform/tools/fetch/extract';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const MAX_CACHE_SIZE = 500;
+const DEFAULT_TIMEOUT_MS = 30_000;
+export class FetchRuntimeService {
+    responseCache = new Map();
+    cacheWriteCount = 0;
+    getCached(key, cacheTtlSeconds) {
+        const entry = this.responseCache.get(key);
+        if (!entry)
+            return null;
+        if ((Date.now() - entry.timestamp) / 1000 >= cacheTtlSeconds)
+            return null;
+        return { ...entry.data, from_cache: true };
+    }
+    cacheSet(key, entry) {
+        this.cacheWriteCount++;
+        if (this.cacheWriteCount % 50 === 0) {
+            const now = Date.now();
+            for (const [cachedKey, cachedValue] of this.responseCache) {
+                if (now - cachedValue.timestamp > cachedValue.ttl * 1000) {
+                    this.responseCache.delete(cachedKey);
+                }
+            }
+        }
+        if (this.responseCache.size >= MAX_CACHE_SIZE) {
+            const oldest = this.responseCache.keys().next().value;
+            if (oldest !== undefined)
+                this.responseCache.delete(oldest);
+        }
+        this.responseCache.set(key, entry);
+    }
+    async execute(input, deps = {}) {
+        const globalExtract = input.extract ?? 'raw';
+        const parallel = input.parallel !== false;
+        const verbosity = input.verbosity ?? 'standard';
+        const cacheTtlSeconds = input.cache_ttl_seconds ?? 0;
+        const rateLimitMs = input.rate_limit_ms ?? 0;
+        const maxContentLength = input.max_content_length;
+        const sanitizeMode = resolveSanitizeMode(input.sanitize_mode);
+        const trustTierConfig = {
+            trustedHosts: input.trusted_hosts,
+            blockedHosts: input.blocked_hosts,
+        };
+        const fetchOpts = {
+            globalExtract,
+            verbosity,
+            cacheTtlSeconds,
+            maxContentLength,
+            sanitizeMode,
+            trustTierConfig,
+            deps,
+        };
+        const wallStart = performance.now();
+        let results;
+        if (parallel) {
+            if (rateLimitMs > 0) {
+                logger.debug('fetch tool: rate_limit_ms is ignored in parallel mode; set parallel: false to enforce rate limiting');
+            }
+            results = await Promise.all(input.urls.map((urlInput) => fetchOne(urlInput, fetchOpts, this)));
+        }
+        else {
+            results = [];
+            for (let i = 0; i < input.urls.length; i++) {
+                if (i > 0 && rateLimitMs > 0) {
+                    await delay(rateLimitMs);
+                }
+                results.push(await fetchOne(input.urls[i], fetchOpts, this));
+            }
+        }
+        const totalMs = Math.round(performance.now() - wallStart);
+        const succeeded = results.filter((result) => result.error === undefined).length;
+        const failed = results.filter((result) => result.error !== undefined).length;
+        const output = {
+            success: true,
+            summary: {
+                total: results.length,
+                succeeded,
+                failed,
+                total_ms: totalMs,
+            },
+        };
+        if (verbosity !== 'count_only') {
+            output.results = results;
+        }
+        return output;
+    }
+}
+export async function executeFetchInput(input, deps = {}) {
+    return new FetchRuntimeService().execute(input, deps);
+}
+function buildUrl(base, params) {
+    if (!params || Object.keys(params).length === 0)
+        return base;
+    let u;
+    try {
+        u = new URL(base);
+    }
+    catch {
+        throw new Error(`Invalid URL: ${base}`);
+    }
+    for (const [k, v] of Object.entries(params)) {
+        u.searchParams.set(k, v);
+    }
+    return u.toString();
+}
+function cacheKey(url, params, extract, verbosity) {
+    const base = params && Object.keys(params).length > 0
+        ? `${url}?${new URLSearchParams(params).toString()}`
+        : url;
+    return `${base}|${extract}|${verbosity}`;
+}
+function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function applyAuthHeaders(headers, auth) {
+    switch (auth.type) {
+        case 'bearer':
+            if (auth.token) {
+                headers['Authorization'] = `Bearer ${auth.token}`;
+            }
+            break;
+        case 'basic': {
+            const user = auth.username ?? '';
+            const pass = auth.password ?? '';
+            const encoded = Buffer.from(`${user}:${pass}`).toString('base64');
+            headers['Authorization'] = `Basic ${encoded}`;
+            break;
+        }
+        case 'api-key': {
+            const headerName = auth.header ?? 'X-API-Key';
+            if (auth.key) {
+                headers[headerName] = auth.key;
+            }
+            break;
+        }
+    }
+}
+function encodeFormBodyData(bodyData) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(bodyData)) {
+        params.append(key, value);
+    }
+    return params.toString();
+}
+async function fetchOneRaw(urlInput, headers, method, body, effectiveUrl) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), urlInput.timeout_ms ?? DEFAULT_TIMEOUT_MS);
+    try {
+        const response = await fetch(effectiveUrl, {
+            method,
+            headers: Object.keys(headers).length > 0 ? headers : undefined,
+            body,
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        return response;
+    }
+    catch (err) {
+        clearTimeout(timer);
+        throw err;
+    }
+}
+function prepareFetchHeaders(urlInput) {
+    const headers = { ...(urlInput.headers ?? {}) };
+    if (urlInput.auth) {
+        applyAuthHeaders(headers, urlInput.auth);
+    }
+    return headers;
+}
+async function prepareFetchRequest(urlInput, deps) {
+    const headers = prepareFetchHeaders(urlInput);
+    if (!urlInput.auth && urlInput.service) {
+        const serviceHeaders = await deps.serviceRegistry?.resolveAuth(urlInput.service);
+        if (serviceHeaders) {
+            Object.assign(headers, serviceHeaders);
+        }
+    }
+    try {
+        const effectiveUrl = buildUrl(urlInput.url, urlInput.params);
+        if (/\/api\/|\/v\d+\/|\/graphql/i.test(effectiveUrl)) {
+            if (!Object.keys(headers).some((h) => h.toLowerCase() === 'accept')) {
+                headers['Accept'] = 'application/json';
+            }
+        }
+    }
+    catch {
+        // malformed URL, skip auto-negotiation
+    }
+    const hasContentType = Object.keys(headers).some((k) => k.toLowerCase() === 'content-type');
+    let body;
+    if (urlInput.body_type === 'multipart' && urlInput.body_data) {
+        const form = new FormData();
+        for (const [k, v] of Object.entries(urlInput.body_data)) {
+            form.append(k, v);
+        }
+        body = form;
+    }
+    else if (urlInput.body_type === 'form' && urlInput.body_data) {
+        body = encodeFormBodyData(urlInput.body_data);
+        if (!hasContentType) {
+            headers['Content-Type'] = 'application/x-www-form-urlencoded';
+        }
+    }
+    else if (urlInput.body_base64 !== undefined) {
+        body = Buffer.from(urlInput.body_base64, 'base64').toString();
+        if (!hasContentType) {
+            headers['Content-Type'] = urlInput.body_type === 'form'
+                ? 'application/x-www-form-urlencoded'
+                : 'application/json';
+        }
+    }
+    else if (urlInput.body !== undefined) {
+        body = urlInput.body;
+        if (!hasContentType) {
+            headers['Content-Type'] = urlInput.body_type === 'form'
+                ? 'application/x-www-form-urlencoded'
+                : 'application/json';
+        }
+    }
+    return { headers, body };
+}
+function buildFetchResultBase(urlInput, response, durationMs) {
+    return {
+        url: urlInput.url,
+        status: response.status,
+        statusText: response.statusText,
+        duration_ms: durationMs,
+    };
+}
+async function fetchOne(urlInput, opts, runtime) {
+    const { globalExtract, verbosity, cacheTtlSeconds, maxContentLength, sanitizeMode, trustTierConfig, deps } = opts;
+    const extractMode = urlInput.extract ?? globalExtract;
+    const method = urlInput.method ?? 'GET';
+    const effectiveMaxContent = urlInput.max_content_length ?? maxContentLength;
+    const effectiveUrl = buildUrl(urlInput.url, urlInput.params);
+    const sanitizationEnabled = deps.featureFlags?.isEnabled('fetch-sanitization') ?? false;
+    const effectiveSanitizeModeForBlocked = sanitizationEnabled ? sanitizeMode : 'none';
+    const hostname = extractHostname(urlInput.url);
+    let initialTrustResult = null;
+    if (hostname !== null) {
+        initialTrustResult = classifyHostTrustTier(hostname, trustTierConfig);
+        emitHostTrustTier(hostname, urlInput.url, initialTrustResult);
+        if (sanitizationEnabled && initialTrustResult.tier === 'blocked') {
+            if (initialTrustResult.isSsrf) {
+                emitSsrfDeny(hostname, urlInput.url, initialTrustResult.reason);
+            }
+            return {
+                url: urlInput.url,
+                error: `Request blocked: ${initialTrustResult.reason}`,
+                host_trust_tier: 'blocked',
+                sanitization_tier: effectiveSanitizeModeForBlocked,
+            };
+        }
+    }
+    if (cacheTtlSeconds > 0 && method === 'GET') {
+        const key = cacheKey(urlInput.url, urlInput.params, extractMode, verbosity);
+        const cached = runtime.getCached(key, cacheTtlSeconds);
+        if (cached) {
+            return cached;
+        }
+    }
+    const { headers, body: requestBody } = await prepareFetchRequest(urlInput, deps);
+    const startTime = performance.now();
+    try {
+        let response = await fetchOneRaw(urlInput, headers, method, requestBody, effectiveUrl);
+        const retryOnAuth = urlInput.retry_on_auth ?? (urlInput.service !== undefined);
+        if (response.status === 401 && retryOnAuth && urlInput.service && !(requestBody instanceof FormData)) {
+            const refreshedHeaders = await deps.serviceRegistry?.resolveAuth(urlInput.service);
+            if (refreshedHeaders) {
+                const retryHeaders = { ...headers };
+                Object.assign(retryHeaders, refreshedHeaders);
+                response = await fetchOneRaw(urlInput, retryHeaders, method, requestBody, effectiveUrl);
+            }
+        }
+        const durationMs = Math.round(performance.now() - startTime);
+        let contentType = response.headers.get('content-type') ?? '';
+        let rawBody = await response.text();
+        contentType = sniffContentType(contentType, rawBody);
+        let truncated = false;
+        if (effectiveMaxContent !== undefined) {
+            const buf = Buffer.from(rawBody, 'utf-8');
+            if (buf.length > effectiveMaxContent) {
+                rawBody = buf.subarray(0, effectiveMaxContent).toString('utf-8');
+                truncated = true;
+            }
+        }
+        const byteSize = Buffer.byteLength(rawBody, 'utf-8');
+        const result = buildFetchResultBase(urlInput, response, durationMs);
+        if (verbosity === 'count_only') {
+            cacheSuccessfulGet(runtime, cacheTtlSeconds, method, cacheKey(urlInput.url, urlInput.params, extractMode, verbosity), result);
+            return result;
+        }
+        result.contentType = contentType;
+        result.byteSize = byteSize;
+        if (truncated)
+            result.truncated = true;
+        result.redirected = response.redirected;
+        result.final_url = response.url !== effectiveUrl ? response.url : undefined;
+        let effectiveSanitizeMode = sanitizationEnabled ? sanitizeMode : 'none';
+        if (sanitizationEnabled && hostname !== null) {
+            const hostTrustResult = initialTrustResult ?? classifyHostTrustTier(hostname, trustTierConfig);
+            result.host_trust_tier = hostTrustResult.tier;
+            if (hostTrustResult.tier === 'unknown' && effectiveSanitizeMode === 'none') {
+                effectiveSanitizeMode = 'safe-text';
+            }
+        }
+        else if (hostname !== null && initialTrustResult !== null) {
+            result.host_trust_tier = initialTrustResult.tier;
+        }
+        if (verbosity === 'minimal') {
+            result.sanitization_tier = 'skipped';
+        }
+        else {
+            result.sanitization_tier = effectiveSanitizeMode;
+        }
+        if (verbosity !== 'minimal') {
+            const extracted = applyExtract(rawBody, contentType, extractMode, { selectors: urlInput.selectors });
+            const sanitized = applySanitizer(extracted, effectiveSanitizeMode);
+            logger.debug('SANITIZE_MODE_APPLIED', {
+                event: 'SANITIZE_MODE_APPLIED',
+                url: urlInput.url,
+                mode: effectiveSanitizeMode,
+                modified: sanitized.modified,
+            });
+            result.content = sanitized.content;
+            result.tokens_used = Math.ceil(sanitized.content.length / 4);
+        }
+        if (verbosity === 'verbose') {
+            const respHeaders = {};
+            response.headers.forEach((value, key) => {
+                respHeaders[key] = value;
+            });
+            result.metadata = {
+                headers: respHeaders,
+                redirected: response.redirected,
+                finalUrl: response.url,
+            };
+        }
+        cacheSuccessfulGet(runtime, cacheTtlSeconds, method, cacheKey(urlInput.url, urlInput.params, extractMode, verbosity), result);
+        return result;
+    }
+    catch (err) {
+        const durationMs = Math.round(performance.now() - startTime);
+        const isTimeout = err instanceof Error && err.name === 'AbortError';
+        const message = isTimeout
+            ? `Timeout after ${urlInput.timeout_ms ?? DEFAULT_TIMEOUT_MS}ms`
+            : err instanceof Error
+                ? err.message
+                : summarizeError(err);
+        logger.debug('fetch tool: request failed', { url: urlInput.url, error: message });
+        return { url: urlInput.url, error: message, duration_ms: durationMs };
+    }
+}
+function cacheSuccessfulGet(runtime, cacheTtlSeconds, method, key, result) {
+    if (cacheTtlSeconds > 0 && method === 'GET') {
+        runtime.cacheSet(key, { data: result, timestamp: Date.now(), ttl: cacheTtlSeconds });
+    }
+}
+export function createFetchTool(deps = {}, runtime = new FetchRuntimeService()) {
+    return {
+        definition: {
+            name: 'fetch',
+            description: 'Fetch one or more URLs via HTTP. Supports batch parallel/sequential requests,'
+                + ' per-URL method/headers/body/params, extraction modes (raw, text, json, markdown,'
+                + ' readable, code_blocks, links, metadata, structured, tables, pdf, summary),'
+                + ' per-URL timeouts, caching, rate limiting, auth refresh, content-length limits,'
+                + ' redirect tracking, timing metrics, token estimation, and verbosity control.',
+            parameters: FETCH_TOOL_SCHEMA,
+            sideEffects: ['network'],
+            concurrency: 'parallel',
+            supportsProgress: true,
+            supportsStreamingOutput: true,
+        },
+        async execute(args) {
+            if (!Array.isArray(args.urls) || args.urls.length === 0) {
+                return { success: false, error: 'Missing or empty "urls" array' };
+            }
+            try {
+                const input = { ...args, urls: args.urls };
+                const output = await runtime.execute(input, deps);
+                return { success: true, output: JSON.stringify(output) };
+            }
+            catch (err) {
+                const message = summarizeError(err);
+                logger.error('fetch tool: unexpected error', { error: message });
+                return { success: false, error: `Unexpected error: ${message}` };
+            }
+        },
+    };
+}

package/dist/_internal/platform/tools/fetch/schema.d.ts

@@ -84,7 +84,7 @@ export declare const FETCH_TOOL_SCHEMA: {
                     };
                     readonly service: {
                         readonly type: "string";
-                        readonly description: "Named service for automatic credential lookup from the service registry. Services are configured in .goodvibes/tui/services.json. Use the registry tool or check .goodvibes/tui/services.json to discover available service names.";
+                        readonly description: "Named service for automatic credential lookup from the service registry. Services are configured in .goodvibes/goodvibes/services.json. Use the registry tool or check .goodvibes/goodvibes/services.json to discover available service names.";
                     };
                     readonly auth: {
                         readonly type: "object";

package/dist/_internal/platform/tools/fetch/schema.js

@@ -90,7 +90,7 @@ export const FETCH_TOOL_SCHEMA = {
                     },
                     service: {
                         type: 'string',
-                        description: 'Named service for automatic credential lookup from the service registry. Services are configured in .goodvibes/tui/services.json. Use the registry tool or check .goodvibes/tui/services.json to discover available service names.',
+                        description: 'Named service for automatic credential lookup from the service registry. Services are configured in .goodvibes/goodvibes/services.json. Use the registry tool or check .goodvibes/goodvibes/services.json to discover available service names.',
                     },
                     auth: {
                         type: 'object',

package/dist/_internal/platform/tools/index.d.ts

@@ -0,0 +1,58 @@
+import { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools/registry';
+import { FileStateCache } from '@pellux/goodvibes-sdk/platform/state/file-cache';
+import { ProjectIndex } from '@pellux/goodvibes-sdk/platform/state/project-index';
+import { ModeManager } from '@pellux/goodvibes-sdk/platform/state/mode-manager';
+import { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state/file-undo';
+import type { ConfigManager } from '../config/manager.js';
+import type { ProviderRegistry } from '../providers/registry.js';
+import type { ToolLLM } from '../config/tool-llm.js';
+import { createWorkflowServices } from '@pellux/goodvibes-sdk/platform/tools/workflow/index';
+import { ProcessManager } from '@pellux/goodvibes-sdk/platform/tools/shared/process-manager';
+import type { AgentManager } from './agent/index.js';
+import { AgentMessageBus } from '../agents/message-bus.js';
+import type { WrfcController } from '../agents/wrfc-controller.js';
+import type { WebSearchService } from '../web-search/index.js';
+import type { ChannelPluginRegistry } from '../channels/index.js';
+import type { RemoteRunnerRegistry } from '../runtime/remote/index.js';
+import { CrossSessionTaskRegistry } from '@pellux/goodvibes-sdk/platform/sessions/orchestration/index';
+import type { SandboxSessionRegistry } from '../runtime/sandbox/session-registry.js';
+import type { FeatureFlagManager } from '@pellux/goodvibes-sdk/platform/runtime/feature-flags/index';
+import type { ServiceRegistry } from '../config/service-registry.js';
+import { OverflowHandler } from '@pellux/goodvibes-sdk/platform/tools/shared/overflow';
+import type { SessionChangeTracker } from '@pellux/goodvibes-sdk/platform/sessions/change-tracker';
+import type { ArchetypeLoader } from '@pellux/goodvibes-sdk/platform/agents/archetypes';
+/**
+ * Register all built-in tools into the given registry.
+ * Creates shared FileStateCache and ProjectIndex instances so read/write/edit
+ * tools share cache state within a session.
+ */
+export declare function registerAllTools(registry: ToolRegistry, deps?: {
+    fileCache?: FileStateCache;
+    projectIndex?: ProjectIndex;
+    fileUndoManager: FileUndoManager;
+    modeManager: ModeManager;
+    processManager: ProcessManager;
+    agentManager?: AgentManager;
+    agentMessageBus: AgentMessageBus;
+    wrfcController?: WrfcController;
+    webSearchService?: WebSearchService;
+    channelRegistry?: ChannelPluginRegistry | null;
+    remoteRunnerRegistry?: RemoteRunnerRegistry;
+    workflowServices: ReturnType<typeof createWorkflowServices>;
+    mcpRegistry?: import('../mcp/registry.js').McpRegistry;
+    sessionOrchestration?: CrossSessionTaskRegistry;
+    sandboxSessionRegistry?: SandboxSessionRegistry;
+    workingDirectory: string;
+    archetypeLoader?: Pick<ArchetypeLoader, 'loadArchetype'>;
+    configManager?: ConfigManager;
+    providerRegistry?: ProviderRegistry;
+    toolLLM?: ToolLLM;
+    featureFlags?: Pick<FeatureFlagManager, 'isEnabled'> | null;
+    serviceRegistry?: Pick<ServiceRegistry, 'resolveAuth'> | null;
+    overflowHandler?: OverflowHandler;
+    changeTracker?: SessionChangeTracker;
+}): {
+    fileCache: FileStateCache;
+    projectIndex: ProjectIndex;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/tools/index.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/tools/index.js

@@ -0,0 +1,143 @@
+import { join } from 'node:path';
+import { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools/registry';
+import { FileStateCache } from '@pellux/goodvibes-sdk/platform/state/file-cache';
+import { ProjectIndex } from '@pellux/goodvibes-sdk/platform/state/project-index';
+import { ModeManager } from '@pellux/goodvibes-sdk/platform/state/mode-manager';
+import { HookDispatcher } from '../hooks/dispatcher.js';
+import { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state/file-undo';
+import { ReadTool } from '@pellux/goodvibes-sdk/platform/tools/read/index';
+import { createWriteTool } from './write/index.js';
+import { createEditTool } from './edit/index.js';
+import { createFindTool } from '@pellux/goodvibes-sdk/platform/tools/find/index';
+import { createExecTool } from '@pellux/goodvibes-sdk/platform/tools/exec/index';
+import { createAnalyzeTool } from './analyze/index.js';
+import { InspectTool } from '@pellux/goodvibes-sdk/platform/tools/inspect/index';
+import { createAgentTool } from './agent/index.js';
+import { createFetchTool } from './fetch/index.js';
+import { createStateTool } from './state/index.js';
+import { createWorkflowServices, createWorkflowTool } from '@pellux/goodvibes-sdk/platform/tools/workflow/index';
+import { createRegistryTool } from '@pellux/goodvibes-sdk/platform/tools/registry-tool/index';
+import { KVState } from '@pellux/goodvibes-sdk/platform/state/kv-state';
+import { createTaskTool } from '@pellux/goodvibes-sdk/platform/tools/task/index';
+import { teamTool } from '@pellux/goodvibes-sdk/platform/tools/team/index';
+import { worklistTool } from '@pellux/goodvibes-sdk/platform/tools/worklist/index';
+import { createMcpTool } from './mcp/index.js';
+import { createPacketTool } from '@pellux/goodvibes-sdk/platform/tools/packet/index';
+import { createQueryTool } from '@pellux/goodvibes-sdk/platform/tools/query/index';
+import { createRemoteTool } from './remote-trigger/index.js';
+import { createReplTool } from './repl/index.js';
+import { controlTool } from './control/index.js';
+import { createChannelTool } from './channel/index.js';
+import { createWebSearchTool } from './web-search/index.js';
+import { ProcessManager } from '@pellux/goodvibes-sdk/platform/tools/shared/process-manager';
+import { AgentMessageBus } from '../agents/message-bus.js';
+import { CrossSessionTaskRegistry } from '@pellux/goodvibes-sdk/platform/sessions/orchestration/index';
+import { OverflowHandler } from '@pellux/goodvibes-sdk/platform/tools/shared/overflow';
+/**
+ * Register all built-in tools into the given registry.
+ * Creates shared FileStateCache and ProjectIndex instances so read/write/edit
+ * tools share cache state within a session.
+ */
+export function registerAllTools(registry, deps) {
+    const fileCache = deps?.fileCache ?? new FileStateCache();
+    if (!deps?.fileUndoManager || !deps?.modeManager || !deps?.processManager || !deps?.agentMessageBus || !deps?.workflowServices) {
+        throw new Error('registerAllTools requires explicit fileUndoManager, modeManager, processManager, agentMessageBus, and workflowServices ownership.');
+    }
+    const fileUndoManager = deps.fileUndoManager;
+    const modeManager = deps.modeManager;
+    const processManager = deps.processManager;
+    const agentManager = deps?.agentManager
+        ?? (deps?.remoteRunnerRegistry
+            ? deps.remoteRunnerRegistry.agentManager ?? null
+            : null);
+    if (!agentManager) {
+        throw new Error('registerAllTools requires agentManager');
+    }
+    const agentMessageBus = deps.agentMessageBus;
+    const wrfcController = deps?.wrfcController;
+    const archetypeLoader = deps?.archetypeLoader;
+    const webSearchService = deps?.webSearchService;
+    const channelRegistry = deps?.channelRegistry ?? null;
+    const remoteRunnerRegistry = deps?.remoteRunnerRegistry;
+    const workflowServices = deps.workflowServices;
+    const mcpRegistry = deps?.mcpRegistry;
+    if (!deps?.configManager || !deps?.providerRegistry || !deps?.toolLLM) {
+        throw new Error('registerAllTools requires configManager, providerRegistry, and toolLLM');
+    }
+    if (!deps?.sandboxSessionRegistry) {
+        throw new Error('registerAllTools requires sandboxSessionRegistry');
+    }
+    if (!deps?.sessionOrchestration) {
+        throw new Error('registerAllTools requires sessionOrchestration');
+    }
+    const sessionOrchestration = deps.sessionOrchestration;
+    const workingDirectory = deps?.workingDirectory;
+    if (!workingDirectory) {
+        throw new Error('registerAllTools requires workingDirectory');
+    }
+    const projectIndex = deps?.projectIndex ?? new ProjectIndex(workingDirectory);
+    registry.register(new ReadTool(projectIndex, fileCache));
+    registry.register(createWriteTool({
+        projectRoot: workingDirectory,
+        fileCache,
+        projectIndex,
+        fileUndoManager,
+        configManager: deps.configManager,
+        toolLLM: deps.toolLLM,
+        changeTracker: deps?.changeTracker,
+    }));
+    registry.register(createEditTool(fileCache, {
+        fileUndoManager,
+        configManager: deps.configManager,
+        toolLLM: deps.toolLLM,
+        changeTracker: deps?.changeTracker,
+    }));
+    registry.register(createFindTool(workingDirectory, deps.featureFlags));
+    registry.register(createExecTool(processManager, {
+        featureFlags: deps.featureFlags,
+        overflowHandler: deps.overflowHandler,
+    }));
+    registry.register(createAnalyzeTool(deps.toolLLM, deps.featureFlags, workingDirectory));
+    registry.register(new InspectTool(deps.featureFlags, workingDirectory));
+    registry.register(createAgentTool({
+        manager: agentManager,
+        messageBus: agentMessageBus,
+        configManager: deps.configManager,
+        ...(archetypeLoader ? { archetypeLoader } : {}),
+        ...(wrfcController ? { wrfcController } : {}),
+    }));
+    const kvState = new KVState(undefined, workingDirectory);
+    const hookDispatcher = new HookDispatcher();
+    registry.register(createStateTool(kvState, projectIndex, {
+        memoryDir: join(workingDirectory, '.goodvibes', 'memory'),
+        hookDispatcher,
+        modeManager,
+    }));
+    registry.register(createWorkflowTool(workflowServices));
+    registry.register(createFetchTool({
+        serviceRegistry: deps.serviceRegistry,
+        featureFlags: deps.featureFlags,
+    }));
+    if (webSearchService) {
+        registry.register(createWebSearchTool(webSearchService));
+    }
+    registry.register(createRegistryTool(registry, {
+        workingDirectory,
+        homeDirectory: deps.configManager.getHomeDirectory() ?? undefined,
+    }));
+    registry.register(createTaskTool(sessionOrchestration));
+    registry.register(teamTool);
+    registry.register(worklistTool);
+    if (mcpRegistry) {
+        registry.register(createMcpTool(mcpRegistry));
+    }
+    registry.register(createPacketTool(workingDirectory));
+    registry.register(createQueryTool(workingDirectory));
+    if (remoteRunnerRegistry) {
+        registry.register(createRemoteTool(remoteRunnerRegistry));
+    }
+    registry.register(createReplTool(deps.configManager, deps.sandboxSessionRegistry));
+    registry.register(controlTool);
+    registry.register(createChannelTool(channelRegistry));
+    return { fileCache, projectIndex };
+}

package/dist/_internal/platform/tools/mcp/index.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types/tools';
+import type { McpRegistry } from '../../mcp/registry.js';
+export declare function createMcpTool(mcpRegistry: McpRegistry): Tool;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/tools/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/mcp/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4CAA4C,CAAC;AAEvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAqCzD,wBAAgB,aAAa,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAsJ5D"}