windows-exe-decompiler-mcp-server 0.1.0

package/dist/selection-diff.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { ArtifactSelectionProvenanceSchema } from './analysis-provenance.js';
+export const ArtifactSelectionDiffSchema = z.object({
+    label: z.enum(['runtime', 'semantic_names', 'semantic_explanations']),
+    current: ArtifactSelectionProvenanceSchema,
+    baseline: ArtifactSelectionProvenanceSchema,
+    added_artifact_ids: z.array(z.string()),
+    removed_artifact_ids: z.array(z.string()),
+    added_session_tags: z.array(z.string()),
+    removed_session_tags: z.array(z.string()),
+    artifact_count_delta: z.number().int(),
+    summary: z.string(),
+});
+export const AnalysisSelectionDiffSchema = z.object({
+    runtime: ArtifactSelectionDiffSchema.optional(),
+    semantic_names: ArtifactSelectionDiffSchema.optional(),
+    semantic_explanations: ArtifactSelectionDiffSchema.optional(),
+});
+function diffStrings(current, baseline) {
+    const currentSet = new Set(current);
+    const baselineSet = new Set(baseline);
+    return {
+        added: current.filter((item) => !baselineSet.has(item)),
+        removed: baseline.filter((item) => !currentSet.has(item)),
+    };
+}
+export function buildArtifactSelectionDiff(label, current, baseline) {
+    const artifactDiff = diffStrings(current.artifact_ids, baseline.artifact_ids);
+    const sessionDiff = diffStrings(current.session_tags, baseline.session_tags);
+    const artifactCountDelta = current.artifact_count - baseline.artifact_count;
+    const targetLabel = label === 'runtime'
+        ? 'runtime selection'
+        : label === 'semantic_names'
+            ? 'semantic naming selection'
+            : 'semantic explanation selection';
+    const summary = `Compared ${targetLabel} against baseline scope=${baseline.scope}` +
+        `${baseline.session_selector ? ` selector=${baseline.session_selector}` : ''}: ` +
+        `artifact_delta=${artifactCountDelta >= 0 ? '+' : ''}${artifactCountDelta}, ` +
+        `added=${artifactDiff.added.length}, removed=${artifactDiff.removed.length}, ` +
+        `session_tag_delta=${sessionDiff.added.length}/${sessionDiff.removed.length}.`;
+    return {
+        label,
+        current,
+        baseline,
+        added_artifact_ids: artifactDiff.added,
+        removed_artifact_ids: artifactDiff.removed,
+        added_session_tags: sessionDiff.added,
+        removed_session_tags: sessionDiff.removed,
+        artifact_count_delta: artifactCountDelta,
+        summary,
+    };
+}
+//# sourceMappingURL=selection-diff.js.map

package/dist/semantic-name-suggestion-artifacts.d.ts

@@ -0,0 +1,116 @@
+import type { ArtifactRef } from './types.js';
+import type { WorkspaceManager } from './workspace-manager.js';
+import type { DatabaseManager } from './database.js';
+export declare const SEMANTIC_NAME_SUGGESTIONS_ARTIFACT_TYPE = "semantic_name_suggestions";
+export declare const SEMANTIC_NAME_PREPARE_BUNDLE_ARTIFACT_TYPE = "semantic_name_prepare_bundle";
+export declare const SEMANTIC_EXPLANATION_PREPARE_BUNDLE_ARTIFACT_TYPE = "semantic_explanation_prepare_bundle";
+export declare const SEMANTIC_FUNCTION_EXPLANATIONS_ARTIFACT_TYPE = "semantic_function_explanations";
+export interface SemanticNameSuggestionEntry {
+    address?: string | null;
+    function?: string | null;
+    candidate_name: string;
+    normalized_candidate_name?: string | null;
+    confidence: number;
+    why: string;
+    required_assumptions?: string[];
+    evidence_used?: string[];
+}
+export interface SemanticNameSuggestionArtifactPayload {
+    schema_version: 1;
+    sample_id: string;
+    created_at: string;
+    session_tag?: string | null;
+    client_name?: string | null;
+    model_name?: string | null;
+    prepare_artifact_id?: string | null;
+    suggestions: SemanticNameSuggestionEntry[];
+}
+export interface LoadedSemanticNameSuggestion {
+    address: string | null;
+    function: string | null;
+    candidate_name: string;
+    normalized_candidate_name: string | null;
+    confidence: number;
+    why: string;
+    required_assumptions: string[];
+    evidence_used: string[];
+    artifact_id: string;
+    created_at: string;
+    client_name: string | null;
+    model_name: string | null;
+    session_tag: string | null;
+    prepare_artifact_id: string | null;
+}
+export interface SemanticNameSuggestionIndex {
+    byAddress: Map<string, LoadedSemanticNameSuggestion>;
+    byFunction: Map<string, LoadedSemanticNameSuggestion>;
+    marker: string;
+    artifact_ids: string[];
+    session_tags: string[];
+    earliest_created_at: string | null;
+    latest_created_at: string | null;
+    scope_note: string;
+}
+export type SemanticArtifactScope = 'all' | 'latest' | 'session';
+export interface LoadSemanticArtifactOptions {
+    scope?: SemanticArtifactScope;
+    sessionTag?: string;
+}
+export interface SemanticFunctionExplanationEntry {
+    address?: string | null;
+    function?: string | null;
+    summary: string;
+    behavior: string;
+    confidence: number;
+    assumptions?: string[];
+    evidence_used?: string[];
+    rewrite_guidance?: string[];
+}
+export interface SemanticFunctionExplanationArtifactPayload {
+    schema_version: 1;
+    sample_id: string;
+    created_at: string;
+    session_tag?: string | null;
+    client_name?: string | null;
+    model_name?: string | null;
+    prepare_artifact_id?: string | null;
+    explanations: SemanticFunctionExplanationEntry[];
+}
+export interface LoadedSemanticFunctionExplanation {
+    address: string | null;
+    function: string | null;
+    summary: string;
+    behavior: string;
+    confidence: number;
+    assumptions: string[];
+    evidence_used: string[];
+    rewrite_guidance: string[];
+    artifact_id: string;
+    created_at: string;
+    client_name: string | null;
+    model_name: string | null;
+    session_tag: string | null;
+    prepare_artifact_id: string | null;
+}
+export interface SemanticFunctionExplanationIndex {
+    byAddress: Map<string, LoadedSemanticFunctionExplanation>;
+    byFunction: Map<string, LoadedSemanticFunctionExplanation>;
+    marker: string;
+    artifact_ids: string[];
+    session_tags: string[];
+    earliest_created_at: string | null;
+    latest_created_at: string | null;
+    scope_note: string;
+}
+export declare function normalizeFunctionKey(value: string | null | undefined): string | null;
+export declare function normalizeAddressKey(value: string | null | undefined): string | null;
+export declare function sanitizeSemanticName(value: string | null | undefined): string | null;
+export declare function persistSemanticNamePrepareBundleArtifact(workspaceManager: WorkspaceManager, database: DatabaseManager, sampleId: string, payload: unknown, sessionTag?: string | null): Promise<ArtifactRef>;
+export declare function persistSemanticExplanationPrepareBundleArtifact(workspaceManager: WorkspaceManager, database: DatabaseManager, sampleId: string, payload: unknown, sessionTag?: string | null): Promise<ArtifactRef>;
+export declare function persistSemanticFunctionExplanationsArtifact(workspaceManager: WorkspaceManager, database: DatabaseManager, payload: SemanticFunctionExplanationArtifactPayload): Promise<ArtifactRef>;
+export declare function persistSemanticNameSuggestionsArtifact(workspaceManager: WorkspaceManager, database: DatabaseManager, payload: SemanticNameSuggestionArtifactPayload): Promise<ArtifactRef>;
+export declare function loadSemanticNameSuggestionIndex(workspaceManager: WorkspaceManager, database: DatabaseManager, sampleId: string, options?: LoadSemanticArtifactOptions): Promise<SemanticNameSuggestionIndex>;
+export declare function loadSemanticFunctionExplanationIndex(workspaceManager: WorkspaceManager, database: DatabaseManager, sampleId: string, options?: LoadSemanticArtifactOptions): Promise<SemanticFunctionExplanationIndex>;
+export declare function findSemanticNameSuggestion(index: SemanticNameSuggestionIndex | null | undefined, address: string | null | undefined, funcName: string | null | undefined): LoadedSemanticNameSuggestion | null;
+export declare function findSemanticFunctionExplanation(index: SemanticFunctionExplanationIndex | null | undefined, address: string | null | undefined, funcName: string | null | undefined): LoadedSemanticFunctionExplanation | null;
+//# sourceMappingURL=semantic-name-suggestion-artifacts.d.ts.map

package/dist/semantic-name-suggestion-artifacts.js

@@ -0,0 +1,314 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { createHash, randomUUID } from 'crypto';
+import { deriveArtifactSessionTag } from './artifact-inventory.js';
+export const SEMANTIC_NAME_SUGGESTIONS_ARTIFACT_TYPE = 'semantic_name_suggestions';
+export const SEMANTIC_NAME_PREPARE_BUNDLE_ARTIFACT_TYPE = 'semantic_name_prepare_bundle';
+export const SEMANTIC_EXPLANATION_PREPARE_BUNDLE_ARTIFACT_TYPE = 'semantic_explanation_prepare_bundle';
+export const SEMANTIC_FUNCTION_EXPLANATIONS_ARTIFACT_TYPE = 'semantic_function_explanations';
+const LATEST_SEMANTIC_ARTIFACT_WINDOW_MS = 10 * 1000;
+function sanitizePathSegment(value, fallback) {
+    const normalized = (value || fallback)
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    return normalized.length > 0 ? normalized.slice(0, 64) : fallback;
+}
+export function normalizeFunctionKey(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+}
+export function normalizeAddressKey(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = value.trim().replace(/^0x/i, '').toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+}
+export function sanitizeSemanticName(value) {
+    if (!value) {
+        return null;
+    }
+    const collapsed = value
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/[^A-Za-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toLowerCase();
+    if (!collapsed) {
+        return null;
+    }
+    if (/^[0-9]/.test(collapsed)) {
+        return `fn_${collapsed}`;
+    }
+    return collapsed;
+}
+async function persistSemanticNamingJsonArtifact(workspaceManager, database, sampleId, artifactType, filePrefix, payload, sessionTag) {
+    const workspace = await workspaceManager.createWorkspace(sampleId);
+    const sessionSegment = sanitizePathSegment(sessionTag || undefined, 'default');
+    const reportDir = path.join(workspace.reports, 'semantic_naming', sessionSegment);
+    await fs.mkdir(reportDir, { recursive: true });
+    const fileName = `${filePrefix}_${Date.now()}.json`;
+    const absolutePath = path.join(reportDir, fileName);
+    const serialized = JSON.stringify(payload, null, 2);
+    await fs.writeFile(absolutePath, serialized, 'utf-8');
+    const artifactId = randomUUID();
+    const artifactSha256 = createHash('sha256').update(serialized).digest('hex');
+    const relativePath = path.relative(workspace.root, absolutePath).replace(/\\/g, '/');
+    const createdAt = new Date().toISOString();
+    database.insertArtifact({
+        id: artifactId,
+        sample_id: sampleId,
+        type: artifactType,
+        path: relativePath,
+        sha256: artifactSha256,
+        mime: 'application/json',
+        created_at: createdAt,
+    });
+    return {
+        id: artifactId,
+        type: artifactType,
+        path: relativePath,
+        sha256: artifactSha256,
+        mime: 'application/json',
+    };
+}
+export async function persistSemanticNamePrepareBundleArtifact(workspaceManager, database, sampleId, payload, sessionTag) {
+    return persistSemanticNamingJsonArtifact(workspaceManager, database, sampleId, SEMANTIC_NAME_PREPARE_BUNDLE_ARTIFACT_TYPE, 'prepare_bundle', payload, sessionTag);
+}
+export async function persistSemanticExplanationPrepareBundleArtifact(workspaceManager, database, sampleId, payload, sessionTag) {
+    return persistSemanticNamingJsonArtifact(workspaceManager, database, sampleId, SEMANTIC_EXPLANATION_PREPARE_BUNDLE_ARTIFACT_TYPE, 'explain_bundle', payload, sessionTag);
+}
+export async function persistSemanticFunctionExplanationsArtifact(workspaceManager, database, payload) {
+    return persistSemanticNamingJsonArtifact(workspaceManager, database, payload.sample_id, SEMANTIC_FUNCTION_EXPLANATIONS_ARTIFACT_TYPE, 'semantic_function_explanations', payload, payload.session_tag);
+}
+export async function persistSemanticNameSuggestionsArtifact(workspaceManager, database, payload) {
+    return persistSemanticNamingJsonArtifact(workspaceManager, database, payload.sample_id, SEMANTIC_NAME_SUGGESTIONS_ARTIFACT_TYPE, 'semantic_name_suggestions', payload, payload.session_tag);
+}
+async function readArtifactJson(workspaceManager, database, sampleId, artifactId) {
+    const artifact = database.findArtifacts(sampleId).find((item) => item.id === artifactId);
+    if (!artifact) {
+        return null;
+    }
+    try {
+        const workspace = await workspaceManager.getWorkspace(sampleId);
+        const absolutePath = workspaceManager.normalizePath(workspace.root, artifact.path);
+        const content = await fs.readFile(absolutePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function collectSemanticArtifactSessionTags(artifactPath, payloadSessionTag) {
+    const sessionTags = new Set();
+    const derivedSessionTag = deriveArtifactSessionTag(artifactPath);
+    if (derivedSessionTag) {
+        sessionTags.add(derivedSessionTag);
+    }
+    if (typeof payloadSessionTag === 'string' && payloadSessionTag.trim().length > 0) {
+        sessionTags.add(payloadSessionTag.trim());
+    }
+    const basename = path.basename(artifactPath, path.extname(artifactPath)).trim();
+    if (basename.length > 0) {
+        sessionTags.add(basename);
+    }
+    return Array.from(sessionTags);
+}
+function filterSemanticArtifactsByScope(artifacts, options = {}) {
+    const scope = options.scope || 'all';
+    const normalizedSelector = options.sessionTag?.trim().toLowerCase() || null;
+    let selectedArtifacts = artifacts;
+    if (normalizedSelector) {
+        selectedArtifacts = selectedArtifacts.filter(({ artifact, payload }) => {
+            if (artifact.path.toLowerCase().includes(normalizedSelector)) {
+                return true;
+            }
+            return collectSemanticArtifactSessionTags(artifact.path, payload?.session_tag).some((tag) => tag.toLowerCase() === normalizedSelector);
+        });
+    }
+    if (scope === 'latest' && selectedArtifacts.length > 1) {
+        const latestTimestamp = selectedArtifacts.reduce((maxValue, { artifact }) => {
+            const timestamp = new Date(artifact.created_at).getTime();
+            return Number.isFinite(timestamp) && timestamp > maxValue ? timestamp : maxValue;
+        }, Number.NEGATIVE_INFINITY);
+        if (Number.isFinite(latestTimestamp)) {
+            selectedArtifacts = selectedArtifacts.filter(({ artifact }) => {
+                const timestamp = new Date(artifact.created_at).getTime();
+                return Number.isFinite(timestamp) && latestTimestamp - timestamp <= LATEST_SEMANTIC_ARTIFACT_WINDOW_MS;
+            });
+        }
+    }
+    return selectedArtifacts;
+}
+export async function loadSemanticNameSuggestionIndex(workspaceManager, database, sampleId, options = {}) {
+    const byAddress = new Map();
+    const byFunction = new Map();
+    const artifacts = database.findArtifactsByType(sampleId, SEMANTIC_NAME_SUGGESTIONS_ARTIFACT_TYPE);
+    const loadedArtifacts = [];
+    for (const artifact of artifacts) {
+        const payload = (await readArtifactJson(workspaceManager, database, sampleId, artifact.id));
+        loadedArtifacts.push({ artifact, payload });
+    }
+    const filteredArtifacts = filterSemanticArtifactsByScope(loadedArtifacts, options);
+    for (const { artifact, payload } of filteredArtifacts) {
+        if (!payload || !Array.isArray(payload.suggestions)) {
+            continue;
+        }
+        for (const suggestion of payload.suggestions) {
+            const normalizedCandidateName = suggestion.normalized_candidate_name || sanitizeSemanticName(suggestion.candidate_name);
+            const loaded = {
+                address: suggestion.address || null,
+                function: suggestion.function || null,
+                candidate_name: suggestion.candidate_name,
+                normalized_candidate_name: normalizedCandidateName,
+                confidence: suggestion.confidence,
+                why: suggestion.why,
+                required_assumptions: suggestion.required_assumptions || [],
+                evidence_used: suggestion.evidence_used || [],
+                artifact_id: artifact.id,
+                created_at: artifact.created_at,
+                client_name: payload.client_name || null,
+                model_name: payload.model_name || null,
+                session_tag: payload.session_tag || null,
+                prepare_artifact_id: payload.prepare_artifact_id || null,
+            };
+            const addressKey = normalizeAddressKey(suggestion.address);
+            if (addressKey && !byAddress.has(addressKey)) {
+                byAddress.set(addressKey, loaded);
+            }
+            const functionKey = normalizeFunctionKey(suggestion.function);
+            if (functionKey && !byFunction.has(functionKey)) {
+                byFunction.set(functionKey, loaded);
+            }
+        }
+    }
+    return {
+        byAddress,
+        byFunction,
+        marker: filteredArtifacts.length > 0
+            ? filteredArtifacts.map(({ artifact }) => `${artifact.id}:${artifact.sha256}`).join('|')
+            : 'none',
+        artifact_ids: filteredArtifacts.map(({ artifact }) => artifact.id),
+        session_tags: Array.from(new Set(filteredArtifacts.flatMap(({ artifact, payload }) => collectSemanticArtifactSessionTags(artifact.path, payload?.session_tag)))),
+        earliest_created_at: filteredArtifacts.length > 0
+            ? filteredArtifacts
+                .map(({ artifact }) => artifact.created_at)
+                .filter((item) => typeof item === 'string' && item.length > 0)
+                .sort()[0] || null
+            : null,
+        latest_created_at: filteredArtifacts.length > 0
+            ? filteredArtifacts
+                .map(({ artifact }) => artifact.created_at)
+                .filter((item) => typeof item === 'string' && item.length > 0)
+                .sort()
+                .slice(-1)[0] || null
+            : null,
+        scope_note: options.scope === 'session' && options.sessionTag?.trim()
+            ? `Semantic naming artifacts are limited to session selector "${options.sessionTag.trim()}".`
+            : options.scope === 'latest'
+                ? 'Semantic naming artifacts are limited to the latest artifact window.'
+                : 'Semantic naming artifacts reflect the selected artifact scope.',
+    };
+}
+export async function loadSemanticFunctionExplanationIndex(workspaceManager, database, sampleId, options = {}) {
+    const byAddress = new Map();
+    const byFunction = new Map();
+    const artifacts = database.findArtifactsByType(sampleId, SEMANTIC_FUNCTION_EXPLANATIONS_ARTIFACT_TYPE);
+    const loadedArtifacts = [];
+    for (const artifact of artifacts) {
+        const payload = (await readArtifactJson(workspaceManager, database, sampleId, artifact.id));
+        loadedArtifacts.push({ artifact, payload });
+    }
+    const filteredArtifacts = filterSemanticArtifactsByScope(loadedArtifacts, options);
+    for (const { artifact, payload } of filteredArtifacts) {
+        if (!payload || !Array.isArray(payload.explanations)) {
+            continue;
+        }
+        for (const explanation of payload.explanations) {
+            const loaded = {
+                address: explanation.address || null,
+                function: explanation.function || null,
+                summary: explanation.summary,
+                behavior: explanation.behavior,
+                confidence: explanation.confidence,
+                assumptions: explanation.assumptions || [],
+                evidence_used: explanation.evidence_used || [],
+                rewrite_guidance: explanation.rewrite_guidance || [],
+                artifact_id: artifact.id,
+                created_at: artifact.created_at,
+                client_name: payload.client_name || null,
+                model_name: payload.model_name || null,
+                session_tag: payload.session_tag || null,
+                prepare_artifact_id: payload.prepare_artifact_id || null,
+            };
+            const addressKey = normalizeAddressKey(explanation.address);
+            if (addressKey && !byAddress.has(addressKey)) {
+                byAddress.set(addressKey, loaded);
+            }
+            const functionKey = normalizeFunctionKey(explanation.function);
+            if (functionKey && !byFunction.has(functionKey)) {
+                byFunction.set(functionKey, loaded);
+            }
+        }
+    }
+    return {
+        byAddress,
+        byFunction,
+        marker: filteredArtifacts.length > 0
+            ? filteredArtifacts.map(({ artifact }) => `${artifact.id}:${artifact.sha256}`).join('|')
+            : 'none',
+        artifact_ids: filteredArtifacts.map(({ artifact }) => artifact.id),
+        session_tags: Array.from(new Set(filteredArtifacts.flatMap(({ artifact, payload }) => collectSemanticArtifactSessionTags(artifact.path, payload?.session_tag)))),
+        earliest_created_at: filteredArtifacts.length > 0
+            ? filteredArtifacts
+                .map(({ artifact }) => artifact.created_at)
+                .filter((item) => typeof item === 'string' && item.length > 0)
+                .sort()[0] || null
+            : null,
+        latest_created_at: filteredArtifacts.length > 0
+            ? filteredArtifacts
+                .map(({ artifact }) => artifact.created_at)
+                .filter((item) => typeof item === 'string' && item.length > 0)
+                .sort()
+                .slice(-1)[0] || null
+            : null,
+        scope_note: options.scope === 'session' && options.sessionTag?.trim()
+            ? `Semantic explanation artifacts are limited to session selector "${options.sessionTag.trim()}".`
+            : options.scope === 'latest'
+                ? 'Semantic explanation artifacts are limited to the latest artifact window.'
+                : 'Semantic explanation artifacts reflect the selected artifact scope.',
+    };
+}
+export function findSemanticNameSuggestion(index, address, funcName) {
+    if (!index) {
+        return null;
+    }
+    const addressKey = normalizeAddressKey(address);
+    if (addressKey && index.byAddress.has(addressKey)) {
+        return index.byAddress.get(addressKey) || null;
+    }
+    const functionKey = normalizeFunctionKey(funcName);
+    if (functionKey && index.byFunction.has(functionKey)) {
+        return index.byFunction.get(functionKey) || null;
+    }
+    return null;
+}
+export function findSemanticFunctionExplanation(index, address, funcName) {
+    if (!index) {
+        return null;
+    }
+    const addressKey = normalizeAddressKey(address);
+    if (addressKey && index.byAddress.has(addressKey)) {
+        return index.byAddress.get(addressKey) || null;
+    }
+    const functionKey = normalizeFunctionKey(funcName);
+    if (functionKey && index.byFunction.has(functionKey)) {
+        return index.byFunction.get(functionKey) || null;
+    }
+    return null;
+}
+//# sourceMappingURL=semantic-name-suggestion-artifacts.js.map

package/dist/server.d.ts

@@ -0,0 +1,129 @@
+/**
+ * MCP Server implementation
+ * Implements the Model Context Protocol with JSON-RPC 2.0 message handling
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { type ClientCapabilities, type CreateMessageRequest, type CreateMessageResult, type CreateMessageResultWithTools, type Implementation, Prompt, Tool, CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import pino from 'pino';
+import type { Config } from './config.js';
+import type { ToolDefinition, ToolArgs, ToolResult, WorkerResult, PromptDefinition, PromptArgs, PromptResult } from './types.js';
+/**
+ * Tool handler function type - can return either WorkerResult or ToolResult
+ */
+type ToolHandler = (args: ToolArgs) => Promise<WorkerResult | ToolResult>;
+type PromptHandler = (args: PromptArgs) => Promise<PromptResult>;
+/**
+ * MCP Server class implementing the Model Context Protocol
+ */
+export declare class MCPServer {
+    private server;
+    private logger;
+    private tools;
+    private handlers;
+    private prompts;
+    private promptHandlers;
+    constructor(config: Config);
+    /**
+     * Setup MCP protocol handlers
+     */
+    private setupHandlers;
+    /**
+     * Register a tool with its definition and handler
+     */
+    registerTool(definition: ToolDefinition, handler: ToolHandler): void;
+    /**
+     * Register a prompt with its definition and handler
+     */
+    registerPrompt(definition: PromptDefinition, handler: PromptHandler): void;
+    getToolDefinitions(): ToolDefinition[];
+    getToolDefinition(name: string): ToolDefinition | undefined;
+    getPromptDefinitions(): PromptDefinition[];
+    getPromptDefinition(name: string): PromptDefinition | undefined;
+    /**
+     * List all available tools (MCP protocol method)
+     */
+    listTools(): Promise<Tool[]>;
+    /**
+     * List all available prompts (MCP protocol method)
+     */
+    listPrompts(): Promise<Prompt[]>;
+    /**
+     * Convert Zod schema to JSON Schema format
+     * Basic implementation for common Zod types
+     */
+    private zodToJsonSchema;
+    /**
+     * Determine whether a field is required in object schema.
+     * Optional/default/catch wrappers should not be marked as required.
+     */
+    private isFieldRequired;
+    /**
+     * Attach schema description when available.
+     */
+    private withDescription;
+    /**
+     * Convert Zod field schema to JSON Schema property
+     */
+    private zodFieldToJsonSchema;
+    /**
+     * Call a tool by name with arguments (MCP protocol method)
+     */
+    callTool(name: string, args: unknown): Promise<CallToolResult>;
+    /**
+     * Resolve a prompt by name and arguments (MCP protocol method)
+     */
+    getPrompt(name: string, args: Record<string, unknown>): Promise<PromptResult>;
+    private validatePromptArgs;
+    /**
+     * Validate tool arguments against schema
+     * Provides clear error messages with field paths and validation details
+     */
+    private validateArgs;
+    /**
+     * Generate an example object from a Zod schema
+     * Helps users understand the expected input format
+     */
+    private generateSchemaExample;
+    /**
+     * Generate an example value for a specific field schema
+     */
+    private generateFieldExample;
+    /**
+     * Convert worker result to MCP tool result
+     */
+    private workerResultToToolResult;
+    /**
+     * Start the MCP server with stdio transport
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the MCP server
+     */
+    stop(): Promise<void>;
+    /**
+     * Get server instance for testing
+     */
+    getServer(): Server;
+    /**
+     * Get connected client capabilities after MCP initialization.
+     */
+    getClientCapabilities(): ClientCapabilities | undefined;
+    /**
+     * Get connected client implementation info after MCP initialization.
+     */
+    getClientVersion(): Implementation | undefined;
+    /**
+     * Whether the connected MCP client advertised sampling support.
+     */
+    supportsSampling(): boolean;
+    /**
+     * Request client-mediated MCP sampling from the connected client.
+     */
+    createMessage(params: CreateMessageRequest['params']): Promise<CreateMessageResult | CreateMessageResultWithTools>;
+    /**
+     * Get logger instance
+     */
+    getLogger(): pino.Logger;
+}
+export {};
+//# sourceMappingURL=server.d.ts.map