@kelpie/server 0.1.0

package/dist/modules/integrations/schema.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Core owns the connection lifecycle; the provider itself ships as a module and
+ * declares `provider_id`. Module-owned provider tables reference this row.
+ *
+ * `user_id` is set for personal connections such as a Gmail mailbox, null for
+ * workspace-wide ones.
+ */
+export declare const integrationConnections: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "integration_connections";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "integration_connections";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "integration_connections";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        providerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider_id";
+            tableName: "integration_connections";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "integration_connections";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "integration_connections";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        config: import("drizzle-orm/pg-core").PgColumn<{
+            name: "config";
+            tableName: "integration_connections";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        secretsEncrypted: import("drizzle-orm/pg-core").PgColumn<{
+            name: "secrets_encrypted";
+            tableName: "integration_connections";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastSyncAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "integration_connections";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "integration_connections";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "integration_connections";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/modules/integrations/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/modules/integrations/schema.ts"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBlC,CAAA"}

package/dist/modules/integrations/schema.js

@@ -0,0 +1,26 @@
+import { index, jsonb, pgTable, text } from 'drizzle-orm/pg-core';
+import { createdAt, moment, primaryId, updatedAt } from '../../lib/columns.js';
+import { users } from '../auth/schema.js';
+import { workspaces } from '../workspace/schema.js';
+/**
+ * Core owns the connection lifecycle; the provider itself ships as a module and
+ * declares `provider_id`. Module-owned provider tables reference this row.
+ *
+ * `user_id` is set for personal connections such as a Gmail mailbox, null for
+ * workspace-wide ones.
+ */
+export const integrationConnections = pgTable('integration_connections', {
+    id: primaryId(),
+    workspaceId: text('workspace_id')
+        .notNull()
+        .references(() => workspaces.id, { onDelete: 'cascade' }),
+    providerId: text('provider_id').notNull(),
+    userId: text('user_id').references(() => users.id, { onDelete: 'cascade' }),
+    status: text('status').notNull(),
+    config: jsonb('config').notNull().default({}),
+    secretsEncrypted: text('secrets_encrypted'),
+    lastSyncAt: moment('last_sync_at'),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (table) => [index('integration_connections_workspace_idx').on(table.workspaceId)]);
+//# sourceMappingURL=schema.js.map

package/dist/modules/integrations/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/modules/integrations/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAA;AAEjE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAC9E,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAEnD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,OAAO,CAC3C,yBAAyB,EACzB;IACE,EAAE,EAAE,SAAS,EAAE;IACf,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC;SAC9B,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;IAC3D,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE;IACzC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;IAC3E,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE;IAChC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IAC7C,gBAAgB,EAAE,IAAI,CAAC,mBAAmB,CAAC;IAC3C,UAAU,EAAE,MAAM,CAAC,cAAc,CAAC;IAClC,SAAS,EAAE,SAAS,EAAE;IACtB,SAAS,EAAE,SAAS,EAAE;CACvB,EACD,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,uCAAuC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAClF,CAAA"}

package/dist/modules/mcp/index.d.ts

@@ -0,0 +1,26 @@
+import type { McpServerInfo } from './protocol.ts';
+/**
+ * The MCP endpoint's identity and address.
+ *
+ * Not a `KelpieModule`: its tools come from every module that registered one, so
+ * there is nothing to mount until the whole registration pass has finished. The
+ * app mounts it after the `/v1` routers, which is `architecture.md` boot step 6.
+ */
+/** Where the transport mounts. `brief.md` and the client config snippets say `/mcp`. */
+export declare const MCP_ROUTE_PREFIX = "/mcp";
+/**
+ * `version` is the `@kelpie/server` package version. Both sit at `0.0.0` until
+ * there is a release process to move them; a client shows this string when it
+ * lists the connection, so it is worth keeping honest rather than inventing one.
+ */
+export declare const MCP_SERVER_INFO: McpServerInfo;
+/**
+ * Sent on `initialize`. An agent reads this before it reads a tool description,
+ * so it says what the data is for and which habits `brief.md` asks of it, not
+ * what the tools are named.
+ */
+export declare const MCP_INSTRUCTIONS: string;
+export type { McpServerInfo } from './protocol.ts';
+export { createMcpEndpoint } from './router.ts';
+export type { McpEndpoint, McpRouterDependencies } from './router.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/mcp/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD;;;;;;GAMG;AAEH,wFAAwF;AACxF,eAAO,MAAM,gBAAgB,SAAS,CAAA;AAEtC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,aAI7B,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,QAkBjB,CAAA;AAEZ,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAC/C,YAAY,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA"}

package/dist/modules/mcp/index.js

@@ -0,0 +1,45 @@
+/**
+ * The MCP endpoint's identity and address.
+ *
+ * Not a `KelpieModule`: its tools come from every module that registered one, so
+ * there is nothing to mount until the whole registration pass has finished. The
+ * app mounts it after the `/v1` routers, which is `architecture.md` boot step 6.
+ */
+/** Where the transport mounts. `brief.md` and the client config snippets say `/mcp`. */
+export const MCP_ROUTE_PREFIX = '/mcp';
+/**
+ * `version` is the `@kelpie/server` package version. Both sit at `0.0.0` until
+ * there is a release process to move them; a client shows this string when it
+ * lists the connection, so it is worth keeping honest rather than inventing one.
+ */
+export const MCP_SERVER_INFO = {
+    name: 'kelpie',
+    title: 'Kelpie',
+    version: '0.0.0',
+};
+/**
+ * Sent on `initialize`. An agent reads this before it reads a tool description,
+ * so it says what the data is for and which habits `brief.md` asks of it, not
+ * what the tools are named.
+ */
+export const MCP_INSTRUCTIONS = [
+    'Kelpie is a CRM and company brain for one workspace. Your API key fixes which',
+    'workspace you can see; there is no way to reach another.',
+    '',
+    'The tools mirror the REST API one for one. Names are the resource then the verb:',
+    'people_list, people_get, people_create, people_update, people_delete. Arguments and',
+    'results are snake_case JSON. Lists are cursor paged: pass the next_cursor you were',
+    'given back as cursor, and filter free text with q.',
+    '',
+    'Working habits this workspace expects:',
+    '- Read decisions_list before proposing anything. A decision is a commitment already',
+    '  made, and contradicting one is worse than saying nothing.',
+    '- Prefer pinned notes (notes_list with pinned true) over unpinned ones. They are',
+    '  pinned because somebody decided they carry the signal.',
+    '- The handbook holds voice, ICP, and how this company sells. Read handbook_pages_list',
+    '  before writing anything a customer will see.',
+    '- A job title belongs to a position, not a person. A person may hold several.',
+    '- Next steps are plan_items with a date and an owner, not prose in a summary field.',
+].join('\n');
+export { createMcpEndpoint } from './router.js';
+//# sourceMappingURL=index.js.map

package/dist/modules/mcp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/modules/mcp/index.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAA;AAEtC;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAkB;IAC5C,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,QAAQ;IACf,OAAO,EAAE,OAAO;CACjB,CAAA;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,+EAA+E;IAC/E,0DAA0D;IAC1D,EAAE;IACF,kFAAkF;IAClF,qFAAqF;IACrF,oFAAoF;IACpF,oDAAoD;IACpD,EAAE;IACF,wCAAwC;IACxC,qFAAqF;IACrF,6DAA6D;IAC7D,kFAAkF;IAClF,0DAA0D;IAC1D,uFAAuF;IACvF,gDAAgD;IAChD,+EAA+E;IAC/E,qFAAqF;CACtF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAGZ,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA"}

package/dist/modules/mcp/protocol.d.ts

@@ -0,0 +1,166 @@
+import { z } from 'zod';
+import type { Actor } from '../../lib/actor.ts';
+import type { Logger } from '../../lib/logger.ts';
+import type { McpTool } from '../../runtime/module.ts';
+/**
+ * JSON-RPC 2.0 and the MCP methods Kelpie answers, as pure functions over parsed
+ * messages. The transport around them lives in `router.ts`.
+ *
+ * Kelpie is a tool server and nothing else: it declares the `tools` capability,
+ * never initiates a message, and holds no per-client state. That is what makes it
+ * safe to answer every POST from any instance without a session id.
+ *
+ * **Two eras on one endpoint.** `2026-07-28` removed the `initialize` handshake
+ * and moved the protocol version into every request, which the spec's own
+ * vocabulary calls *modern*; everything before it is *legacy*. A dual-era server
+ * is explicitly permitted to serve both, choosing from how the client opens, and
+ * that is what this does. The eras differ in how a request arrives and how a
+ * result is dressed; the tools underneath are the same objects either way.
+ */
+/** The two shapes of MCP. Fixed per request, never per connection: there is none. */
+export type ProtocolEra = 'legacy' | 'modern';
+/**
+ * Revisions that carry version, identity and capabilities in each request's
+ * `_meta` rather than establishing them with a handshake.
+ */
+export declare const MODERN_PROTOCOL_VERSIONS: readonly string[];
+/**
+ * Revisions that open with `initialize`.
+ *
+ * `2025-03-26` is kept because its clients are the ones that send JSON-RPC
+ * batches, which `2025-06-18` removed. Answering both costs one array branch in
+ * the transport and keeps older MCP clients working.
+ */
+export declare const LEGACY_PROTOCOL_VERSIONS: readonly string[];
+/** Everything Kelpie speaks, newest first. This is the list a `-32022` hands back. */
+export declare const SUPPORTED_PROTOCOL_VERSIONS: readonly string[];
+/** Newest revision Kelpie speaks, which is also the newest that exists. */
+export declare const LATEST_PROTOCOL_VERSION = "2026-07-28";
+/**
+ * Newest *legacy* revision, and the one an `initialize` naming something
+ * unrecognised is answered with. Handing a legacy client `2026-07-28` would name
+ * a revision in which the handshake it just completed does not exist.
+ */
+export declare const LATEST_LEGACY_PROTOCOL_VERSION = "2025-06-18";
+/**
+ * `_meta` keys the modern revision defines. Reverse-DNS prefixed, which is the
+ * naming rule for anything outside a caller's own namespace.
+ */
+export declare const PROTOCOL_VERSION_META = "io.modelcontextprotocol/protocolVersion";
+export declare const CLIENT_INFO_META = "io.modelcontextprotocol/clientInfo";
+export declare const CLIENT_CAPABILITIES_META = "io.modelcontextprotocol/clientCapabilities";
+export declare const SERVER_INFO_META = "io.modelcontextprotocol/serverInfo";
+/** JSON-RPC's own codes. Anything Kelpie refuses maps onto one of these. */
+export declare const PARSE_ERROR = -32700;
+export declare const INVALID_REQUEST = -32600;
+export declare const METHOD_NOT_FOUND = -32601;
+export declare const INVALID_PARAMS = -32602;
+export declare const INTERNAL_ERROR = -32603;
+/**
+ * Codes MCP allocates for itself, from the `-32020` to `-32099` band the spec
+ * reserves. Both were renumbered out of the implementation-defined range in
+ * `2026-07-28`, so these values are the current ones and not the draft's.
+ */
+export declare const HEADER_MISMATCH = -32020;
+export declare const UNSUPPORTED_PROTOCOL_VERSION = -32022;
+/**
+ * How long a client may hold the tool listing.
+ *
+ * The set is fixed at boot by the module list, so within one process it cannot
+ * change at all; only a redeploy that adds a module can move it. An hour bounds
+ * how long a client can be wrong about that, and matches the figure the spec's
+ * own `server/discover` example uses.
+ */
+export declare const TOOL_LISTING_TTL_MS = 3600000;
+export interface JsonRpcError {
+    readonly code: number;
+    readonly message: string;
+    readonly data?: unknown;
+}
+/**
+ * Null only ever appears on an error response whose request could not be read far
+ * enough to find an id. JSON-RPC requires it there; MCP forbids it on a request.
+ */
+export type JsonRpcId = string | number | null;
+export interface JsonRpcResponse {
+    readonly jsonrpc: '2.0';
+    readonly id: JsonRpcId;
+    readonly result?: unknown;
+    readonly error?: JsonRpcError;
+}
+/**
+ * An incoming message. `id` present means a request that must be answered; absent
+ * means a notification, which must not be.
+ *
+ * Loose about `params` on purpose: each method validates its own, so a bad shape
+ * is that method's `-32602` rather than a blanket parse failure that says nothing
+ * about which field was wrong.
+ */
+declare const messageSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type JsonRpcMessage = z.infer<typeof messageSchema>;
+export interface McpServerInfo {
+    readonly name: string;
+    readonly title: string;
+    readonly version: string;
+}
+/** A tool as `tools/list` publishes it: the description plus a JSON Schema. */
+export interface PublishedTool {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Record<string, unknown>;
+}
+export interface DispatchDependencies {
+    readonly tools: readonly McpTool[];
+    /** The `tools/list` payload, built once at mount. */
+    readonly published: readonly PublishedTool[];
+    readonly serverInfo: McpServerInfo;
+    /** What this workspace's data is for. Sent on `initialize` and on `server/discover`. */
+    readonly instructions: string;
+    readonly logger: Logger;
+}
+/**
+ * Converts a tool's Zod input schema to the JSON Schema `tools/list` publishes.
+ *
+ * `io: 'input'` matters: a field with a `.default()` is optional to the caller and
+ * required to the tool body, and only the input view says so.
+ *
+ * @throws When a schema has no JSON Schema equivalent. Called at mount, so that
+ *   is a boot failure rather than a broken tool listing.
+ */
+export declare function publishTool(tool: McpTool): PublishedTool;
+/** Parses one incoming message. */
+export declare function parseMessage(value: unknown): JsonRpcMessage | undefined;
+/** The protocol version a modern client puts in every request's `_meta`. */
+export declare function readMetaVersion(params: unknown): string | undefined;
+/** `params.name`, which the transport mirrors into `Mcp-Name`. */
+export declare function readParamsName(params: unknown): string | undefined;
+export declare function isModernVersion(version: string): boolean;
+export declare function isSupportedVersion(version: string): boolean;
+export declare function failure(id: JsonRpcId, code: number, message: string, data?: unknown): JsonRpcResponse;
+/** The `-32022` a client reads to pick a version it and Kelpie both speak. */
+export declare function unsupportedVersion(id: JsonRpcId, requested: string): JsonRpcResponse;
+/**
+ * The version to answer a legacy `initialize` with.
+ *
+ * A client asking for a legacy revision gets that one back, which is what lets a
+ * `2025-03-26` client keep its batches. Anything else gets the newest legacy
+ * revision, and the client decides whether it can live with it.
+ */
+export declare function negotiateLegacyVersion(requested: string): string;
+/**
+ * Answers one message.
+ *
+ * @param era Which revision's rules to answer under. The transport decides it
+ *   from how the request arrived, and every method here that exists in only one
+ *   era is method-not-found in the other.
+ * @returns The response, or undefined for a notification, which JSON-RPC forbids
+ *   answering.
+ */
+export declare function dispatch(dependencies: DispatchDependencies, message: JsonRpcMessage, era: ProtocolEra, actor: Actor): Promise<JsonRpcResponse | undefined>;
+export {};
+//# sourceMappingURL=protocol.d.ts.map

package/dist/modules/mcp/protocol.d.ts.map

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