@alpic-ai/insights 0.0.0-dev.g1ab1e48 → 0.0.0-dev.g1ba9633

package/dist/index.d.mts

@@ -1,6 +1,5 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-
 //#region src/intent-middleware.d.ts
 interface PromptData {
   toolName: string;
@@ -37,6 +36,40 @@ type McpMiddlewareFn = (request: {
  */
 declare function intentMiddleware(options?: IntentMiddlewareOptions): McpMiddlewareFn;
 //#endregion
+//#region src/analytics-middleware.d.ts
+interface CaptureOptions {
+  message?: string;
+  /** Duration of the operation the event describes, in milliseconds. */
+  duration?: number;
+  isError?: boolean;
+  error?: string;
+  /** Freeform event detail. Not indexed — filtering on a property key is a query-time scan. */
+  properties?: Record<string, unknown>;
+}
+interface Analytics {
+  /** Records a custom event on the current session's timeline, interleaved with tool calls. */
+  capture(name: string, options?: CaptureOptions): void;
+  /**
+   * Attaches traits to the current request's user (e.g. email, name, plan). The target user is
+   * resolved by Alpic from the request auth context — no id or sessionId is passed.
+   */
+  identify(traits: Record<string, string>): void;
+}
+/**
+ * Shape of the handler `extra` once `analyticsMiddleware()` (or `track(server)`) is installed.
+ * Cast the handler's `extra` to this to access `analytics` with types.
+ */
+interface AnalyticsExtra {
+  analytics: Analytics;
+}
+/**
+ * Lets MCP server builders record custom analytics events and user traits from inside tool
+ * handlers, via `extra.analytics.capture(...)` / `extra.analytics.identify(...)`. Calls are
+ * buffered during the request and flushed into the response `_meta`, where the Alpic proxy
+ * ingests and strips them before the result reaches the client.
+ */
+declare function analyticsMiddleware(): McpMiddlewareFn;
+//#endregion
 //#region src/feedback-middleware.d.ts
 interface FeedbackData {
   content: string;
@@ -65,10 +98,6 @@ declare function feedbackMiddleware(options?: FeedbackMiddlewareOptions): McpMid
  * or the low-level `Server` and patches the `tools/list` and `tools/call`
  * request handlers to surface captured feedback via `options.handler` (or,
  * when `ALPIC_FEEDBACK_META_KEY` is set, via the response `_meta`).
- *
- * Already-registered handlers are wrapped immediately; future registrations
- * are wrapped via a `Map.set` proxy so order of calls relative to
- * `registerTool` does not matter.
  */
 declare const captureFeedback: (server: McpServer | Server, options?: FeedbackMiddlewareOptions) => void;
 //#endregion
@@ -79,11 +108,15 @@ declare const captureFeedback: (server: McpServer | Server, options?: FeedbackMi
  * low-level `Server` and patches the `tools/list` and `tools/call` request
  * handlers to surface the captured intent via `options.handler` (or, when
  * `ALPIC_INTENT_META_KEY` is set, via the response `_meta`).
- *
- * Already-registered handlers are wrapped immediately; future registrations
- * (e.g. tools added after this call) are wrapped via a `Map.set` proxy so order
- * of calls relative to `registerTool` does not matter.
  */
 declare const captureIntents: (server: McpServer | Server, options?: IntentMiddlewareOptions) => void;
 //#endregion
-export { type FeedbackData, type FeedbackMiddlewareOptions, type IntentMiddlewareOptions, type McpMiddlewareFn, type PromptData, captureFeedback, captureIntents, feedbackMiddleware, intentMiddleware };
+//#region src/track.d.ts
+/**
+ * Enables custom analytics events on a vanilla `@modelcontextprotocol/sdk` server. Accepts the
+ * high-level `McpServer` or the low-level `Server` and patches the `tools/call` request handlers
+ * so tool handlers can call `extra.analytics.capture(...)` / `extra.analytics.identify(...)`.
+ */
+declare const track: (server: McpServer | Server) => void;
+//#endregion
+export { type Analytics, type AnalyticsExtra, type CaptureOptions, type FeedbackData, type FeedbackMiddlewareOptions, type IntentMiddlewareOptions, type McpMiddlewareFn, type PromptData, analyticsMiddleware, captureFeedback, captureIntents, feedbackMiddleware, intentMiddleware, track };

package/dist/index.mjs

@@ -1,8 +1,99 @@
 import { CallToolRequestSchema, CallToolResultSchema, ListToolsResultSchema } from "@modelcontextprotocol/sdk/types.js";
+//#region src/analytics-middleware.ts
+const ALPIC_EVENTS_META_KEY = "alpic/events";
+const ALPIC_IDENTIFY_META_KEY = "alpic/identify";
+const MAX_EVENTS_PER_REQUEST = 50;
+function warnInDev(message) {
+	if (process.env.NODE_ENV !== "production") console.warn(`[insights] ${message}`);
+}
+function createAnalyticsBuffer() {
+	const events = [];
+	let traits;
+	let settled = false;
+	return {
+		analytics: {
+			capture(name, options) {
+				if (settled) {
+					warnInDev(`analytics.capture("${name}") was called after the request settled; the event was dropped. Capture events before the tool handler returns.`);
+					return;
+				}
+				if (events.length >= MAX_EVENTS_PER_REQUEST) {
+					warnInDev(`analytics.capture("${name}") exceeded the ${MAX_EVENTS_PER_REQUEST} events per request limit; the event was dropped.`);
+					return;
+				}
+				events.push({
+					...options,
+					name,
+					timestamp: Date.now()
+				});
+			},
+			identify(newTraits) {
+				if (settled) {
+					warnInDev("analytics.identify() was called after the request settled; the traits were dropped. Identify before the tool handler returns.");
+					return;
+				}
+				traits = {
+					...traits,
+					...newTraits
+				};
+			}
+		},
+		settle: () => {
+			settled = true;
+		},
+		get events() {
+			return events;
+		},
+		get traits() {
+			return traits;
+		}
+	};
+}
+/**
+* Lets MCP server builders record custom analytics events and user traits from inside tool
+* handlers, via `extra.analytics.capture(...)` / `extra.analytics.identify(...)`. Calls are
+* buffered during the request and flushed into the response `_meta`, where the Alpic proxy
+* ingests and strips them before the result reaches the client.
+*/
+function analyticsMiddleware() {
+	return async (request, extra, next) => {
+		if (request.method !== "tools/call" || extra === null || typeof extra !== "object") return next();
+		const buffer = createAnalyticsBuffer();
+		extra.analytics = buffer.analytics;
+		let rawResult;
+		try {
+			rawResult = await next();
+		} finally {
+			buffer.settle();
+		}
+		if (buffer.events.length === 0 && buffer.traits === void 0) return rawResult;
+		if (!CallToolResultSchema.safeParse(rawResult).success) return rawResult;
+		const result = rawResult;
+		const meta = { ...result._meta };
+		if (buffer.events.length > 0) meta[ALPIC_EVENTS_META_KEY] = buffer.events;
+		if (buffer.traits !== void 0) meta[ALPIC_IDENTIFY_META_KEY] = buffer.traits;
+		return {
+			...result,
+			_meta: meta
+		};
+	};
+}
+//#endregion
 //#region src/feedback-middleware.ts
 const FEEDBACK_TOOL_NAME = "send_feedback";
 const FEEDBACK_TOOL_DESCRIPTION = "Send feedback about this MCP server to its operators. Use this tool ONLY for feedback about this MCP server itself, never about other tools, services, or the host. You MAY call this tool when you detect a genuine issue with this server (e.g. a tool that failed unexpectedly, an unhelpful response, a missing capability). You MAY also call it when the user explicitly asks to send feedback. Before sending, strip all personally identifiable information (PII) from the content, including names, email addresses, phone numbers, physical addresses, dates of birth, ID numbers, payment information, and any other information that could identify a specific individual. Replace stripped values with generic placeholders (e.g. \"[name]\", \"[email]\").";
 const FEEDBACK_RESPONSE_TEXT = "Feedback received. Thanks!";
+const FEEDBACK_OUTPUT_SCHEMA = {
+	type: "object",
+	properties: { status: {
+		type: "string",
+		enum: ["received"],
+		description: "Confirmation that the feedback was received by the server operators."
+	} },
+	required: ["status"],
+	additionalProperties: false
+};
+const FEEDBACK_STRUCTURED_CONTENT = { status: "received" };
 /**
 * Lets MCP server builders collect qualitative feedback from end users about their
 * tool/server. Injects a `send_feedback` tool at `tools/list` time and intercepts calls
@@ -36,10 +127,11 @@ function feedbackMiddleware(options) {
 					},
 					required: ["content", "source"]
 				},
+				outputSchema: FEEDBACK_OUTPUT_SCHEMA,
 				annotations: {
-					readOnlyHint: false,
+					readOnlyHint: true,
 					destructiveHint: false,
-					openWorldHint: true,
+					openWorldHint: false,
 					idempotentHint: true
 				}
 			});
@@ -73,39 +165,39 @@ function feedbackMiddleware(options) {
 				type: "text",
 				text: FEEDBACK_RESPONSE_TEXT
 			}],
+			structuredContent: FEEDBACK_STRUCTURED_CONTENT,
 			_meta: { [metaKeyName]: feedback }
 		};
-		return { content: [{
-			type: "text",
-			text: FEEDBACK_RESPONSE_TEXT
-		}] };
+		return {
+			content: [{
+				type: "text",
+				text: FEEDBACK_RESPONSE_TEXT
+			}],
+			structuredContent: FEEDBACK_STRUCTURED_CONTENT
+		};
 	};
 }
 //#endregion
-//#region src/capture-feedback.ts
-const INSTALLED_MARKER$1 = "__alpicCaptureFeedbackInstalled";
+//#region src/install-capture-middleware.ts
 /**
-* Injects a `send_feedback` tool into a vanilla `@modelcontextprotocol/sdk`
-* server and captures feedback submissions. Accepts the high-level `McpServer`
-* or the low-level `Server` and patches the `tools/list` and `tools/call`
-* request handlers to surface captured feedback via `options.handler` (or,
-* when `ALPIC_FEEDBACK_META_KEY` is set, via the response `_meta`).
+* Patches the `tools/list` and `tools/call` request handlers of a vanilla
+* `@modelcontextprotocol/sdk` server (high-level `McpServer` or low-level
+* `Server`) to run the given middleware.
 *
 * Already-registered handlers are wrapped immediately; future registrations
-* are wrapped via a `Map.set` proxy so order of calls relative to
-* `registerTool` does not matter.
+* (e.g. tools added after this call) are wrapped via a `Map.set` proxy so order
+* of calls relative to `registerTool` does not matter.
 */
-const captureFeedback = (server, options) => {
+const installCaptureMiddleware = (server, { middleware, installedMarker, disabledWarning }) => {
 	const handlers = ("server" in server ? server.server : server)?._requestHandlers;
 	if (!(handlers instanceof Map)) {
-		console.warn("@alpic-ai/insights: incompatible @modelcontextprotocol/sdk version — expected `_requestHandlers` Map on Server. Feedback capture disabled.");
+		console.warn(`@alpic-ai/insights: incompatible @modelcontextprotocol/sdk version — expected \`_requestHandlers\` Map on Server. ${disabledWarning}`);
 		return;
 	}
 	const marked = handlers;
-	if (marked[INSTALLED_MARKER$1]) return;
-	marked[INSTALLED_MARKER$1] = true;
-	const middleware = feedbackMiddleware(options);
-	const targets = new Set(["tools/list", "tools/call"]);
+	if (marked[installedMarker]) return;
+	marked[installedMarker] = true;
+	const targets = /* @__PURE__ */ new Set(["tools/list", "tools/call"]);
 	const wrap = (method, handler) => {
 		if (!targets.has(method)) return handler;
 		return async (...args) => {
@@ -121,6 +213,22 @@ const captureFeedback = (server, options) => {
 	handlers.set = (method, handler) => originalSet(method, wrap(method, handler));
 };
 //#endregion
+//#region src/capture-feedback.ts
+/**
+* Injects a `send_feedback` tool into a vanilla `@modelcontextprotocol/sdk`
+* server and captures feedback submissions. Accepts the high-level `McpServer`
+* or the low-level `Server` and patches the `tools/list` and `tools/call`
+* request handlers to surface captured feedback via `options.handler` (or,
+* when `ALPIC_FEEDBACK_META_KEY` is set, via the response `_meta`).
+*/
+const captureFeedback = (server, options) => {
+	installCaptureMiddleware(server, {
+		middleware: feedbackMiddleware(options),
+		installedMarker: "__alpicCaptureFeedbackInstalled",
+		disabledWarning: "Feedback capture disabled."
+	});
+};
+//#endregion
 //#region src/intent-middleware.ts
 const USER_INTENT_FIELD = "user_intent";
 /**
@@ -228,42 +336,33 @@ Examples:
 }
 //#endregion
 //#region src/capture-intents.ts
-const INSTALLED_MARKER = "__alpicCaptureIntentsInstalled";
 /**
 * Captures the user's natural-language intent behind each tool call on a vanilla
 * `@modelcontextprotocol/sdk` server. Accepts the high-level `McpServer` or the
 * low-level `Server` and patches the `tools/list` and `tools/call` request
 * handlers to surface the captured intent via `options.handler` (or, when
 * `ALPIC_INTENT_META_KEY` is set, via the response `_meta`).
-*
-* Already-registered handlers are wrapped immediately; future registrations
-* (e.g. tools added after this call) are wrapped via a `Map.set` proxy so order
-* of calls relative to `registerTool` does not matter.
 */
 const captureIntents = (server, options) => {
-	const handlers = ("server" in server ? server.server : server)?._requestHandlers;
-	if (!(handlers instanceof Map)) {
-		console.warn("@alpic-ai/insights: incompatible @modelcontextprotocol/sdk version — expected `_requestHandlers` Map on Server. Prompt capture disabled.");
-		return;
-	}
-	const marked = handlers;
-	if (marked[INSTALLED_MARKER]) return;
-	marked[INSTALLED_MARKER] = true;
-	const middleware = intentMiddleware(options);
-	const targets = new Set(["tools/list", "tools/call"]);
-	const wrap = (method, handler) => {
-		if (!targets.has(method)) return handler;
-		return async (...args) => {
-			const [request, extra] = args;
-			return middleware({
-				method,
-				params: request.params ?? {}
-			}, extra, () => handler(...args));
-		};
-	};
-	for (const [method, handler] of [...handlers]) handlers.set(method, wrap(method, handler));
-	const originalSet = handlers.set.bind(handlers);
-	handlers.set = (method, handler) => originalSet(method, wrap(method, handler));
+	installCaptureMiddleware(server, {
+		middleware: intentMiddleware(options),
+		installedMarker: "__alpicCaptureIntentsInstalled",
+		disabledWarning: "Prompt capture disabled."
+	});
+};
+//#endregion
+//#region src/track.ts
+/**
+* Enables custom analytics events on a vanilla `@modelcontextprotocol/sdk` server. Accepts the
+* high-level `McpServer` or the low-level `Server` and patches the `tools/call` request handlers
+* so tool handlers can call `extra.analytics.capture(...)` / `extra.analytics.identify(...)`.
+*/
+const track = (server) => {
+	installCaptureMiddleware(server, {
+		middleware: analyticsMiddleware(),
+		installedMarker: "__alpicTrackInstalled",
+		disabledWarning: "Analytics capture disabled."
+	});
 };
 //#endregion
-export { captureFeedback, captureIntents, feedbackMiddleware, intentMiddleware };
+export { analyticsMiddleware, captureFeedback, captureIntents, feedbackMiddleware, intentMiddleware, track };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alpic-ai/insights",
-  "version": "0.0.0-dev.g1ab1e48",
+  "version": "0.0.0-dev.g1ba9633",
   "description": "User insights middlewares for Alpic-hosted MCP servers",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -18,7 +18,7 @@
   "license": "ISC",
   "peerDependencies": {
     "@modelcontextprotocol/sdk": ">=1.29.0 <2",
-    "skybridge": ">=0.36.2"
+    "skybridge": "^0.36.3 || ^1.0.0"
   },
   "peerDependenciesMeta": {
     "skybridge": {
@@ -28,12 +28,12 @@
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@total-typescript/tsconfig": "^1.0.4",
-    "@types/node": "^25.7.0",
+    "@types/node": "^25.9.5",
     "shx": "^0.4.0",
-    "skybridge": "^0.36.2",
-    "tsdown": "^0.22.0",
+    "skybridge": "^1.2.7",
+    "tsdown": "^0.22.5",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.6",
+    "vitest": "^4.1.10",
     "zod": "^4.4.3"
   },
   "scripts": {
@@ -42,7 +42,7 @@
     "test": "pnpm run test:unit && pnpm run test:type && pnpm run test:format",
     "test:unit": "vitest run",
     "test:format": "biome check --error-on-warnings .",
-    "test:type": "tsc --noEmit",
+    "test:type": "tsgo --noEmit",
     "publish:npm": "pnpm publish --tag \"${NPM_TAG}\" --access public --no-git-checks"
   }
 }