salmon-loop 0.3.0 → 0.3.1

package/dist/core/mcp/bridge/prompt-command-provider.js

@@ -0,0 +1,261 @@
+import { z } from 'zod';
+import { jsonSchemaToZod } from '../schema/json-schema-to-zod.js';
+const SAFE_TOKEN_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+function normalizeToken(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-+/g, '-');
+}
+function safeToken(value, fallback) {
+    const normalized = normalizeToken(value);
+    if (SAFE_TOKEN_PATTERN.test(normalized))
+        return normalized;
+    return fallback;
+}
+function isPromptOptions(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        'serverName' in value &&
+        'client' in value &&
+        typeof value.client?.listPrompts === 'function');
+}
+function buildFallbackSchemaFromArguments(args = []) {
+    const shape = {};
+    for (const arg of args) {
+        const field = z.string().describe(arg.description ?? '');
+        shape[arg.name] = arg.required ? field : field.optional();
+    }
+    return z.object(shape).strict();
+}
+function buildJsonSchemaFromArguments(args = []) {
+    return {
+        type: 'object',
+        properties: Object.fromEntries(args.map((arg) => [
+            arg.name,
+            {
+                type: 'string',
+                description: arg.description,
+            },
+        ])),
+        required: args.filter((arg) => arg.required).map((arg) => arg.name),
+        additionalProperties: false,
+    };
+}
+function parseSlashArgs(req) {
+    const raw = req.argsText.trim();
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('Prompt arguments must be a JSON object.');
+        }
+        return parsed;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid MCP prompt arguments for ${req.command.name}: ${message}`);
+    }
+}
+function coercePromptArgs(args) {
+    return Object.fromEntries(Object.entries(args).map(([key, value]) => {
+        if (typeof value === 'string')
+            return [key, value];
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return [key, String(value)];
+        if (value === null || value === undefined)
+            return [key, ''];
+        return [key, JSON.stringify(value)];
+    }));
+}
+function renderPromptResultAsForwardedInput(result) {
+    return result.messages
+        .map((message) => {
+        const content = message.content;
+        if (content.type === 'text' && typeof content.text === 'string') {
+            return content.text;
+        }
+        return JSON.stringify(message.content);
+    })
+        .filter((part) => part.length > 0)
+        .join('\n\n');
+}
+export class McpPromptCommandProvider {
+    manager;
+    policy;
+    serverName;
+    client;
+    commandPrefix;
+    order;
+    promptsByCommand = new Map();
+    promptsByName = new Map();
+    constructor(optionsOrManager, policy) {
+        if (isPromptOptions(optionsOrManager)) {
+            this.serverName = optionsOrManager.serverName;
+            this.client = optionsOrManager.client;
+            this.commandPrefix = safeToken(optionsOrManager.commandPrefix ?? 'mcp', 'mcp');
+            this.order = optionsOrManager.order ?? 230;
+            return;
+        }
+        this.manager = optionsOrManager;
+        this.policy = policy;
+        this.commandPrefix = 'mcp';
+        this.order = 230;
+    }
+    async load() {
+        if (!this.client || !this.serverName) {
+            this.promptsByCommand.clear();
+            this.promptsByName.clear();
+            return;
+        }
+        const prompts = await this.client.listPrompts();
+        this.promptsByCommand.clear();
+        this.promptsByName.clear();
+        for (const prompt of prompts) {
+            const descriptor = { ...prompt, serverName: prompt.serverName ?? this.serverName };
+            const command = this.commandNameForPrompt(descriptor);
+            this.promptsByCommand.set(command, descriptor);
+            this.promptsByName.set(descriptor.name, descriptor);
+        }
+    }
+    listCommands() {
+        if (!this.manager || !this.policy) {
+            return this.listRecipes().map((recipe) => ({
+                name: recipe.slashCommand,
+                server: recipe.serverName,
+                prompt: recipe.promptName,
+                description: recipe.description,
+                exposure: 'recipe',
+                arguments: this.promptsByName.get(recipe.promptName)?.arguments ?? [],
+            }));
+        }
+        const commands = [];
+        for (const catalog of this.manager.listCatalogs()) {
+            for (const prompt of catalog.prompts) {
+                const decision = this.policy.decidePrompt({
+                    server: catalog.serverName,
+                    name: prompt.name,
+                });
+                if (!decision.allowed || decision.grant?.kind !== 'prompt')
+                    continue;
+                commands.push(this.toCommand(prompt, decision.grant.exposeAs ?? 'slash'));
+            }
+        }
+        return commands;
+    }
+    listSlashCommands() {
+        return Array.from(this.promptsByCommand.entries()).map(([name, prompt]) => ({
+            name,
+            description: this.descriptionForPrompt(prompt),
+            order: this.order,
+        }));
+    }
+    listRecipes() {
+        return Array.from(this.promptsByCommand.entries()).map(([slashCommand, prompt]) => ({
+            id: `mcp.${safeToken(prompt.serverName ?? this.serverName ?? 'server', 'server')}.${safeToken(prompt.name, 'prompt')}`,
+            slashCommand,
+            title: prompt.title ?? prompt.name,
+            description: this.descriptionForPrompt(prompt),
+            promptName: prompt.name,
+            serverName: prompt.serverName ?? this.serverName ?? 'unknown',
+            inputSchema: this.jsonSchemaForPrompt(prompt),
+        }));
+    }
+    getHandler(commandName) {
+        const prompt = this.promptsByCommand.get(commandName.toLowerCase());
+        if (!prompt)
+            return undefined;
+        return {
+            execute: async (req) => {
+                const args = parseSlashArgs(req);
+                const invocation = await this.invokePrompt(prompt.name, args);
+                const input = renderPromptResultAsForwardedInput(invocation.result);
+                const result = { kind: 'forward', input };
+                return result;
+            },
+        };
+    }
+    async invoke(input) {
+        if (!this.manager || !this.policy) {
+            return this.invokePrompt(input.prompt, input.args ?? {}).then((invocation) => invocation.result);
+        }
+        const decision = this.policy.decidePrompt({ server: input.server, name: input.prompt });
+        if (!decision.allowed)
+            throw new Error(decision.denyReason ?? 'MCP_PROMPT_DENIED');
+        const descriptor = this.manager
+            .getCatalog(input.server)
+            ?.prompts.find((candidate) => candidate.name === input.prompt);
+        if (!descriptor)
+            throw new Error(`MCP prompt not found: ${input.server}.${input.prompt}`);
+        const schema = this.buildArgsSchema(descriptor);
+        const args = schema.parse(input.args ?? {});
+        return this.manager.getPrompt(input.server, input.prompt, args);
+    }
+    async invokePrompt(name, rawArgs = {}) {
+        if (!this.client) {
+            throw new Error('MCP prompt client is not configured for direct invocation.');
+        }
+        const prompt = this.promptsByName.get(name);
+        if (!prompt) {
+            throw new Error(`MCP prompt not found: ${this.serverName ?? 'unknown'}/${name}`);
+        }
+        const args = this.validatePromptArgs(prompt, rawArgs);
+        const result = await this.client.getPrompt(prompt.name, args);
+        return {
+            promptName: prompt.name,
+            serverName: prompt.serverName ?? this.serverName ?? 'unknown',
+            args,
+            result,
+            audit: {
+                event: 'mcp.prompt.invoke',
+                serverName: prompt.serverName ?? this.serverName ?? 'unknown',
+                promptName: prompt.name,
+                args,
+                messageCount: result.messages.length,
+            },
+        };
+    }
+    toCommand(prompt, exposure) {
+        return {
+            name: `/mcp.${prompt.serverName}.${prompt.name}`,
+            server: prompt.serverName,
+            prompt: prompt.name,
+            description: prompt.description,
+            exposure: exposure === 'recipe' ? 'recipe' : 'slash',
+            arguments: prompt.arguments ?? [],
+        };
+    }
+    buildArgsSchema(prompt) {
+        const shape = {};
+        for (const arg of prompt.arguments ?? []) {
+            shape[arg.name] = arg.required ? z.string() : z.string().optional();
+        }
+        return z.object(shape).strict();
+    }
+    commandNameForPrompt(prompt) {
+        const server = safeToken(prompt.serverName ?? this.serverName ?? 'server', 'server');
+        const promptName = safeToken(prompt.name, 'prompt');
+        return `/${this.commandPrefix}-${server}-${promptName}`;
+    }
+    descriptionForPrompt(prompt) {
+        return prompt.description ?? prompt.title ?? `MCP prompt ${prompt.name}`;
+    }
+    jsonSchemaForPrompt(prompt) {
+        return prompt.inputSchema ?? buildJsonSchemaFromArguments(prompt.arguments);
+    }
+    zodSchemaForPrompt(prompt) {
+        if (prompt.inputSchema) {
+            return jsonSchemaToZod(prompt.inputSchema);
+        }
+        return buildFallbackSchemaFromArguments(prompt.arguments);
+    }
+    validatePromptArgs(prompt, rawArgs) {
+        const schema = this.zodSchemaForPrompt(prompt);
+        const parsed = schema.parse(rawArgs);
+        return coercePromptArgs(parsed);
+    }
+}
+//# sourceMappingURL=prompt-command-provider.js.map

package/dist/core/mcp/bridge/resource-context-provider.js

@@ -0,0 +1,259 @@
+import { ResourceCache } from '../cache/resource-cache.js';
+export class ResourceContextProviderError extends Error {
+    diagnostic;
+    constructor(message, diagnostic) {
+        super(message);
+        this.diagnostic = diagnostic;
+        this.name = 'ResourceContextProviderError';
+    }
+}
+export class ResourceContextProvider {
+    deps;
+    cache;
+    options;
+    constructor(deps) {
+        this.deps = deps;
+        this.cache = deps.cache ?? new ResourceCache();
+        this.options = {
+            budgetChars: deps.options?.budgetChars ?? 24_000,
+            maxResourceChars: deps.options?.maxResourceChars ?? 8_000,
+            maxResources: deps.options?.maxResources ?? 20,
+        };
+    }
+    async provide(input) {
+        const result = {
+            blocks: [],
+            diagnostics: [],
+            meta: { usedChars: 0, truncated: false, cacheHits: 0, cacheMisses: 0 },
+        };
+        const selected = this.selectResources(input?.resources ?? []);
+        for (const resource of selected.slice(0, this.options.maxResources)) {
+            const optional = resource.includeIntent !== 'required';
+            const policy = this.deps.policy.checkUri({
+                serverName: resource.serverName,
+                uri: resource.uri,
+                intent: resource.includeIntent ?? 'manual',
+            });
+            const allowed = typeof policy === 'boolean' ? policy : policy.allowed;
+            if (!allowed) {
+                const diagnostic = this.diagnostic('POLICY_DENIED', typeof policy === 'boolean'
+                    ? 'MCP resource denied by policy'
+                    : (policy.reason ?? 'MCP resource denied by policy'), resource, optional);
+                if (!optional)
+                    throw new ResourceContextProviderError(diagnostic.message, diagnostic);
+                result.diagnostics.push(diagnostic);
+                continue;
+            }
+            let remaining = this.options.budgetChars - result.meta.usedChars;
+            if (remaining <= 0) {
+                result.meta.truncated = true;
+                result.blocks.push(this.linkBlock(resource, 'budget_exhausted'));
+                continue;
+            }
+            const cacheKey = `${resource.serverName}:${resource.uri}:${Math.min(this.options.maxResourceChars, remaining)}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached) {
+                result.meta.cacheHits += 1;
+                result.blocks.push(...cached);
+                for (const block of cached) {
+                    if (block.type === 'resource_text') {
+                        result.meta.usedChars += block.includedChars;
+                        result.meta.truncated = result.meta.truncated || block.truncated;
+                    }
+                }
+                continue;
+            }
+            result.meta.cacheMisses += 1;
+            try {
+                const connection = this.deps.connections[resource.serverName];
+                if (!connection)
+                    throw new Error(`MCP connection not found: ${resource.serverName}`);
+                const read = await connection.readResource({ uri: resource.uri });
+                const contents = read.contents ?? [];
+                const resourceBlocks = [];
+                for (const content of contents) {
+                    if (remaining <= 0)
+                        break;
+                    const block = this.blockFromRead(resource, content, remaining);
+                    resourceBlocks.push(block);
+                    result.blocks.push(block);
+                    if (block.type === 'resource_text') {
+                        result.meta.usedChars += block.includedChars;
+                        result.meta.truncated = result.meta.truncated || block.truncated;
+                        remaining -= block.includedChars;
+                    }
+                }
+                if (resourceBlocks.length > 0) {
+                    this.cache.set(cacheKey, resourceBlocks);
+                }
+            }
+            catch (error) {
+                const diagnostic = this.diagnostic('READ_FAILED', error instanceof Error ? error.message : String(error), resource, optional);
+                if (!optional)
+                    throw new ResourceContextProviderError(diagnostic.message, diagnostic);
+                result.diagnostics.push(diagnostic);
+            }
+        }
+        return result;
+    }
+    invalidate(serverName, uri) {
+        this.cache.deleteMatching((key) => {
+            const serverPrefix = `${serverName}:`;
+            if (!key.startsWith(serverPrefix))
+                return false;
+            const separatorIndex = key.lastIndexOf(':');
+            if (separatorIndex <= serverPrefix.length)
+                return false;
+            const cachedUri = key.slice(serverPrefix.length, separatorIndex);
+            return cachedUri === uri || uri.startsWith(cachedUri);
+        });
+    }
+    selectResources(manual) {
+        const catalog = this.deps.catalog.listResources();
+        const resources = catalog.filter((resource) => resource.includeIntent === 'required' || resource.includeIntent === 'autoInclude');
+        for (const item of manual) {
+            if (resources.some((resource) => resource.serverName === item.serverName && resource.uri === item.uri)) {
+                continue;
+            }
+            const catalogResource = catalog.find((resource) => resource.serverName === item.serverName && resource.uri === item.uri);
+            resources.push({
+                ...catalogResource,
+                serverName: item.serverName,
+                uri: item.uri,
+                includeIntent: item.intent,
+            });
+        }
+        return resources;
+    }
+    blockFromRead(resource, content, remainingBudget) {
+        if (!content)
+            return this.linkBlock(resource, 'non_text');
+        const contentUri = this.contentUri(resource, content);
+        const mimeType = typeof content.mimeType === 'string' ? content.mimeType : resource.mimeType;
+        if (typeof content.blob === 'string')
+            return this.linkBlock(resource, 'blob', contentUri);
+        if (typeof content.text !== 'string')
+            return this.linkBlock(resource, 'non_text', contentUri);
+        if (!isTextMime(mimeType))
+            return this.linkBlock(resource, 'non_text', contentUri);
+        const raw = normalizeText(content.text, mimeType);
+        const limit = Math.max(0, Math.min(this.options.maxResourceChars, remainingBudget));
+        const truncated = raw.length > limit;
+        const text = truncated ? raw.slice(0, limit) : raw;
+        return {
+            type: 'resource_text',
+            serverName: resource.serverName,
+            uri: contentUri,
+            name: resource.name,
+            mimeType,
+            content: { text, format: isJsonMime(mimeType) ? 'json' : 'text' },
+            includedChars: text.length,
+            truncated,
+        };
+    }
+    linkBlock(resource, reason, uri = resource.uri) {
+        return {
+            type: 'resource_link',
+            serverName: resource.serverName,
+            uri,
+            name: resource.name,
+            reason,
+            metadata: {
+                name: resource.name,
+                description: resource.description,
+                mimeType: resource.mimeType,
+                size: resource.size,
+            },
+        };
+    }
+    contentUri(resource, content) {
+        return typeof content.uri === 'string' ? content.uri : resource.uri;
+    }
+    diagnostic(code, message, resource, optional) {
+        return {
+            code,
+            message,
+            serverName: resource.serverName,
+            uri: resource.uri,
+            optional,
+        };
+    }
+}
+export class McpResourceContextProvider {
+    provider;
+    constructor(manager, policy) {
+        this.provider = new ResourceContextProvider({
+            catalog: {
+                listResources: () => manager.listCatalogs().flatMap((catalog) => catalog.resources.map((resource) => ({
+                    serverName: catalog.serverName,
+                    uri: resource.uri,
+                    name: resource.name,
+                    description: resource.description,
+                    mimeType: resource.mimeType,
+                    includeIntent: 'autoInclude',
+                }))),
+            },
+            connections: new Proxy({}, {
+                get: (_target, serverName) => ({
+                    readResource: ({ uri }) => manager.readResource(serverName, uri),
+                }),
+            }),
+            policy: {
+                checkUri: ({ serverName, uri }) => {
+                    const decision = policy.decideResource({ server: serverName, uri });
+                    return { allowed: decision.allowed, reason: decision.denyReason ?? decision.reason };
+                },
+            },
+        });
+        manager.onResourceUpdated((event) => {
+            this.provider.invalidate(event.serverName, event.uri);
+        });
+    }
+    async read(input) {
+        const result = await this.provider.provide({
+            resources: [{ serverName: input.server, uri: input.uri, intent: input.intent }],
+        });
+        const block = result.blocks[0];
+        if (!block) {
+            return {
+                server: input.server,
+                uri: input.uri,
+                diagnostics: result.diagnostics[0]?.message,
+            };
+        }
+        if (block.type === 'resource_text') {
+            return {
+                server: input.server,
+                uri: input.uri,
+                mimeType: block.mimeType,
+                text: block.content.text,
+                truncated: block.truncated,
+            };
+        }
+        return {
+            server: input.server,
+            uri: input.uri,
+            mimeType: typeof block.metadata.mimeType === 'string' ? block.metadata.mimeType : undefined,
+            linkOnly: true,
+        };
+    }
+}
+function isTextMime(mimeType) {
+    if (!mimeType)
+        return true;
+    return mimeType.startsWith('text/') || isJsonMime(mimeType);
+}
+function isJsonMime(mimeType) {
+    return Boolean(mimeType && (mimeType === 'application/json' || mimeType.endsWith('+json')));
+}
+function normalizeText(text, mimeType) {
+    if (!isJsonMime(mimeType))
+        return text;
+    try {
+        return JSON.stringify(JSON.parse(text), null, 2);
+    }
+    catch {
+        return text;
+    }
+}
+//# sourceMappingURL=resource-context-provider.js.map