@amplitude/ai 0.1.0

package/dist/mcp/validate-file.d.ts

@@ -0,0 +1,20 @@
+//#region src/mcp/validate-file.d.ts
+interface CallSite {
+  line: number;
+  provider: string;
+  api: string;
+  instrumented: boolean;
+}
+interface FileAnalysis {
+  total_call_sites: number;
+  instrumented: number;
+  uninstrumented: number;
+  has_amplitude_import: boolean;
+  has_session_context: boolean;
+  call_sites: CallSite[];
+  suggestions: string[];
+}
+declare function analyzeFileInstrumentation(source: string): FileAnalysis;
+//#endregion
+export { CallSite, FileAnalysis, analyzeFileInstrumentation };
+//# sourceMappingURL=validate-file.d.ts.map

package/dist/mcp/validate-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-file.d.ts","names":[],"sources":["../../src/mcp/validate-file.ts"],"sourcesContent":[],"mappings":";UAAiB,QAAA;EAAA,IAAA,EAAA,MAAQ;EAOR,QAAA,EAAA,MAAY;EA+Eb,GAAA,EAAA,MAAA;;;UA/EC,YAAA;;;;;;cAMH;;;iBAyEE,0BAAA,kBAA4C"}

package/dist/mcp/validate-file.js

@@ -0,0 +1,122 @@
+//#region src/mcp/validate-file.ts
+const llmPatterns = [
+	{
+		pattern: /\.chat\.completions\.create\s*\(/g,
+		receiverRe: /(\w+)(?:\.\w+)*\.chat\.completions\.create\s*\(/,
+		provider: "openai",
+		api: "chat.completions.create"
+	},
+	{
+		pattern: /\.chat\.completions\.parse\s*\(/g,
+		receiverRe: /(\w+)(?:\.\w+)*\.chat\.completions\.parse\s*\(/,
+		provider: "openai",
+		api: "chat.completions.parse"
+	},
+	{
+		pattern: /\.responses\.create\s*\(/g,
+		receiverRe: /(\w+)(?:\.\w+)*\.responses\.create\s*\(/,
+		provider: "openai",
+		api: "responses.create"
+	},
+	{
+		pattern: /\.messages\.create\s*\(/g,
+		receiverRe: /(\w+)(?:\.\w+)*\.messages\.create\s*\(/,
+		provider: "anthropic",
+		api: "messages.create"
+	},
+	{
+		pattern: /\.generateContent\s*\(/g,
+		receiverRe: /(\w+)(?:\.\w+)*\.generateContent\s*\(/,
+		provider: "gemini",
+		api: "generateContent"
+	},
+	{
+		pattern: /\.send\s*\(\s*new\s+InvokeModelCommand\s*\(/g,
+		receiverRe: /(\w+)(?:\.\w+)*\.send\s*\(/,
+		provider: "bedrock",
+		api: "invokeModel"
+	},
+	{
+		pattern: /\.send\s*\(\s*new\s+ConverseCommand\s*\(/g,
+		receiverRe: /(\w+)(?:\.\w+)*\.send\s*\(/,
+		provider: "bedrock",
+		api: "converse"
+	}
+];
+function findWrappedConstructors(source) {
+	const result = /* @__PURE__ */ new Set();
+	for (const m of source.matchAll(/(?:const|let|var)\s+(\w+)\s*=\s*new\s+(?:OpenAI|Anthropic|Gemini|AzureOpenAI|Bedrock|Mistral)\s*\(/g)) {
+		const varName = m[1] ?? "";
+		if (!varName) continue;
+		let depth = 1;
+		let i = (m.index ?? 0) + m[0].length;
+		let argBlock = "";
+		while (i < source.length && depth > 0) {
+			const ch = source[i];
+			if (ch === "(") depth++;
+			else if (ch === ")") depth--;
+			if (depth > 0) argBlock += ch;
+			i++;
+		}
+		if (/\bamplitude\s*:/.test(argBlock)) result.add(varName);
+	}
+	return result;
+}
+function analyzeFileInstrumentation(source) {
+	const hasPatch = /\bpatch\s*\(\s*\{/.test(source);
+	const hasSessionContext = /\.session\s*\(/.test(source) || /\bsession\.run\s*\(/.test(source) || /\bcreateAmplitudeAIMiddleware\s*\(/.test(source);
+	const hasAmplitudeImport = /from\s+['"]@amplitude\/ai['"]/.test(source) || /require\s*\(\s*['"]@amplitude\/ai['"]\s*\)/.test(source) || /\bAmplitudeAI\b/.test(source);
+	const wrappedClients = findWrappedConstructors(source);
+	if (hasAmplitudeImport) for (const m of source.matchAll(/(?:const|let|var)\s+(\w+)\s*=\s*(?:\w+\.)*wrap\s*\(/g)) {
+		const name = m[1] ?? "";
+		if (name) wrappedClients.add(name);
+	}
+	const callSites = [];
+	const lines = source.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i] ?? "";
+		for (const { pattern, receiverRe, provider, api } of llmPatterns) {
+			pattern.lastIndex = 0;
+			if (pattern.test(line)) {
+				const receiver = line.match(receiverRe)?.[1] ?? "";
+				const instrumented = hasPatch || wrappedClients.has(receiver);
+				callSites.push({
+					line: i + 1,
+					provider,
+					api,
+					instrumented
+				});
+			}
+		}
+	}
+	const uninstrumentedSites = callSites.filter((s) => !s.instrumented);
+	let suggestions;
+	if (uninstrumentedSites.length > 0) suggestions = [
+		"Now: instrument provider calls with wrapper/swap import (for example, `new OpenAI({ amplitude: ai, apiKey })`).",
+		"Next: add session lineage with `const session = ai.agent(...).session(...)` and wrap calls in `session.run(...)`.",
+		"Why: session context unlocks session-level scoring, enrichments, and reliable product-to-AI funnels.",
+		"Content tiers: choose `contentMode` (`full`, `metadata_only`, or `customer_enriched`) and prefer `redactPii: true` when using `full`.",
+		"Fallback: use `patch({ amplitudeAI: ai })` for migration speed, then graduate to wrapper + session context."
+	];
+	else if (callSites.length > 0 && !hasSessionContext) suggestions = [
+		"Tracking is present, but session context is missing.",
+		"Now: add `const session = ai.agent(...).session(...)` and execute LLM calls inside `session.run(...)` (or use middleware).",
+		"Why: without session lineage you lose high-value outcomes like session enrichments, scoring, and dependable session funnels.",
+		"Content tiers: set `contentMode` intentionally and keep `redactPii: true` when using `full`."
+	];
+	else if (callSites.length > 0) suggestions = ["File appears instrumented with session lineage.", "For privacy-by-default, set `contentMode` intentionally and enable `redactPii: true` when using `full`."];
+	else suggestions = ["No supported LLM call sites detected in this file.", "If this file should emit AI telemetry, add wrapped provider calls and session context."];
+	return {
+		total_call_sites: callSites.length,
+		instrumented: callSites.length - uninstrumentedSites.length,
+		uninstrumented: uninstrumentedSites.length,
+		has_amplitude_import: hasAmplitudeImport,
+		has_session_context: hasSessionContext,
+		call_sites: callSites,
+		suggestions
+	};
+}
+
+//#endregion
+export { analyzeFileInstrumentation };
+//# sourceMappingURL=validate-file.js.map

package/dist/mcp/validate-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-file.js","names":["callSites: CallSite[]","suggestions: string[]"],"sources":["../../src/mcp/validate-file.ts"],"sourcesContent":["export interface CallSite {\n  line: number;\n  provider: string;\n  api: string;\n  instrumented: boolean;\n}\n\nexport interface FileAnalysis {\n  total_call_sites: number;\n  instrumented: number;\n  uninstrumented: number;\n  has_amplitude_import: boolean;\n  has_session_context: boolean;\n  call_sites: CallSite[];\n  suggestions: string[];\n}\n\nconst llmPatterns = [\n  {\n    pattern: /\\.chat\\.completions\\.create\\s*\\(/g,\n    receiverRe: /(\\w+)(?:\\.\\w+)*\\.chat\\.completions\\.create\\s*\\(/,\n    provider: 'openai',\n    api: 'chat.completions.create',\n  },\n  {\n    pattern: /\\.chat\\.completions\\.parse\\s*\\(/g,\n    receiverRe: /(\\w+)(?:\\.\\w+)*\\.chat\\.completions\\.parse\\s*\\(/,\n    provider: 'openai',\n    api: 'chat.completions.parse',\n  },\n  {\n    pattern: /\\.responses\\.create\\s*\\(/g,\n    receiverRe: /(\\w+)(?:\\.\\w+)*\\.responses\\.create\\s*\\(/,\n    provider: 'openai',\n    api: 'responses.create',\n  },\n  {\n    pattern: /\\.messages\\.create\\s*\\(/g,\n    receiverRe: /(\\w+)(?:\\.\\w+)*\\.messages\\.create\\s*\\(/,\n    provider: 'anthropic',\n    api: 'messages.create',\n  },\n  {\n    pattern: /\\.generateContent\\s*\\(/g,\n    receiverRe: /(\\w+)(?:\\.\\w+)*\\.generateContent\\s*\\(/,\n    provider: 'gemini',\n    api: 'generateContent',\n  },\n  {\n    pattern: /\\.send\\s*\\(\\s*new\\s+InvokeModelCommand\\s*\\(/g,\n    receiverRe: /(\\w+)(?:\\.\\w+)*\\.send\\s*\\(/,\n    provider: 'bedrock',\n    api: 'invokeModel',\n  },\n  {\n    pattern: /\\.send\\s*\\(\\s*new\\s+ConverseCommand\\s*\\(/g,\n    receiverRe: /(\\w+)(?:\\.\\w+)*\\.send\\s*\\(/,\n    provider: 'bedrock',\n    api: 'converse',\n  },\n];\n\nfunction findWrappedConstructors(source: string): Set<string> {\n  const result = new Set<string>();\n  const declRe =\n    /(?:const|let|var)\\s+(\\w+)\\s*=\\s*new\\s+(?:OpenAI|Anthropic|Gemini|AzureOpenAI|Bedrock|Mistral)\\s*\\(/g;\n  for (const m of source.matchAll(declRe)) {\n    const varName = m[1] ?? '';\n    if (!varName) continue;\n    let depth = 1;\n    let i = (m.index ?? 0) + m[0].length;\n    let argBlock = '';\n    while (i < source.length && depth > 0) {\n      const ch = source[i];\n      if (ch === '(') depth++;\n      else if (ch === ')') depth--;\n      if (depth > 0) argBlock += ch;\n      i++;\n    }\n    if (/\\bamplitude\\s*:/.test(argBlock)) {\n      result.add(varName);\n    }\n  }\n  return result;\n}\n\nexport function analyzeFileInstrumentation(source: string): FileAnalysis {\n  const hasPatch = /\\bpatch\\s*\\(\\s*\\{/.test(source);\n  const hasSessionContext =\n    /\\.session\\s*\\(/.test(source) ||\n    /\\bsession\\.run\\s*\\(/.test(source) ||\n    /\\bcreateAmplitudeAIMiddleware\\s*\\(/.test(source);\n\n  const hasAmplitudeImport =\n    /from\\s+['\"]@amplitude\\/ai['\"]/.test(source) ||\n    /require\\s*\\(\\s*['\"]@amplitude\\/ai['\"]\\s*\\)/.test(source) ||\n    /\\bAmplitudeAI\\b/.test(source);\n\n  const wrappedClients = findWrappedConstructors(source);\n  if (hasAmplitudeImport) {\n    const wrapRe = /(?:const|let|var)\\s+(\\w+)\\s*=\\s*(?:\\w+\\.)*wrap\\s*\\(/g;\n    for (const m of source.matchAll(wrapRe)) {\n      const name = m[1] ?? '';\n      if (name) wrappedClients.add(name);\n    }\n  }\n\n  const callSites: CallSite[] = [];\n  const lines = source.split('\\n');\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i] ?? '';\n    for (const { pattern, receiverRe, provider, api } of llmPatterns) {\n      pattern.lastIndex = 0;\n      if (pattern.test(line)) {\n        const rm = line.match(receiverRe);\n        const receiver = rm?.[1] ?? '';\n        const instrumented = hasPatch || wrappedClients.has(receiver);\n        callSites.push({ line: i + 1, provider, api, instrumented });\n      }\n    }\n  }\n\n  const uninstrumentedSites = callSites.filter((s) => !s.instrumented);\n  let suggestions: string[];\n  if (uninstrumentedSites.length > 0) {\n    suggestions = [\n      'Now: instrument provider calls with wrapper/swap import (for example, `new OpenAI({ amplitude: ai, apiKey })`).',\n      'Next: add session lineage with `const session = ai.agent(...).session(...)` and wrap calls in `session.run(...)`.',\n      'Why: session context unlocks session-level scoring, enrichments, and reliable product-to-AI funnels.',\n      'Content tiers: choose `contentMode` (`full`, `metadata_only`, or `customer_enriched`) and prefer `redactPii: true` when using `full`.',\n      'Fallback: use `patch({ amplitudeAI: ai })` for migration speed, then graduate to wrapper + session context.',\n    ];\n  } else if (callSites.length > 0 && !hasSessionContext) {\n    suggestions = [\n      'Tracking is present, but session context is missing.',\n      'Now: add `const session = ai.agent(...).session(...)` and execute LLM calls inside `session.run(...)` (or use middleware).',\n      'Why: without session lineage you lose high-value outcomes like session enrichments, scoring, and dependable session funnels.',\n      'Content tiers: set `contentMode` intentionally and keep `redactPii: true` when using `full`.',\n    ];\n  } else if (callSites.length > 0) {\n    suggestions = [\n      'File appears instrumented with session lineage.',\n      'For privacy-by-default, set `contentMode` intentionally and enable `redactPii: true` when using `full`.',\n    ];\n  } else {\n    suggestions = [\n      'No supported LLM call sites detected in this file.',\n      'If this file should emit AI telemetry, add wrapped provider calls and session context.',\n    ];\n  }\n\n  return {\n    total_call_sites: callSites.length,\n    instrumented: callSites.length - uninstrumentedSites.length,\n    uninstrumented: uninstrumentedSites.length,\n    has_amplitude_import: hasAmplitudeImport,\n    has_session_context: hasSessionContext,\n    call_sites: callSites,\n    suggestions,\n  };\n}\n"],"mappings":";AAiBA,MAAM,cAAc;CAClB;EACE,SAAS;EACT,YAAY;EACZ,UAAU;EACV,KAAK;EACN;CACD;EACE,SAAS;EACT,YAAY;EACZ,UAAU;EACV,KAAK;EACN;CACD;EACE,SAAS;EACT,YAAY;EACZ,UAAU;EACV,KAAK;EACN;CACD;EACE,SAAS;EACT,YAAY;EACZ,UAAU;EACV,KAAK;EACN;CACD;EACE,SAAS;EACT,YAAY;EACZ,UAAU;EACV,KAAK;EACN;CACD;EACE,SAAS;EACT,YAAY;EACZ,UAAU;EACV,KAAK;EACN;CACD;EACE,SAAS;EACT,YAAY;EACZ,UAAU;EACV,KAAK;EACN;CACF;AAED,SAAS,wBAAwB,QAA6B;CAC5D,MAAM,yBAAS,IAAI,KAAa;AAGhC,MAAK,MAAM,KAAK,OAAO,SADrB,sGACqC,EAAE;EACvC,MAAM,UAAU,EAAE,MAAM;AACxB,MAAI,CAAC,QAAS;EACd,IAAI,QAAQ;EACZ,IAAI,KAAK,EAAE,SAAS,KAAK,EAAE,GAAG;EAC9B,IAAI,WAAW;AACf,SAAO,IAAI,OAAO,UAAU,QAAQ,GAAG;GACrC,MAAM,KAAK,OAAO;AAClB,OAAI,OAAO,IAAK;YACP,OAAO,IAAK;AACrB,OAAI,QAAQ,EAAG,aAAY;AAC3B;;AAEF,MAAI,kBAAkB,KAAK,SAAS,CAClC,QAAO,IAAI,QAAQ;;AAGvB,QAAO;;AAGT,SAAgB,2BAA2B,QAA8B;CACvE,MAAM,WAAW,oBAAoB,KAAK,OAAO;CACjD,MAAM,oBACJ,iBAAiB,KAAK,OAAO,IAC7B,sBAAsB,KAAK,OAAO,IAClC,qCAAqC,KAAK,OAAO;CAEnD,MAAM,qBACJ,gCAAgC,KAAK,OAAO,IAC5C,6CAA6C,KAAK,OAAO,IACzD,kBAAkB,KAAK,OAAO;CAEhC,MAAM,iBAAiB,wBAAwB,OAAO;AACtD,KAAI,mBAEF,MAAK,MAAM,KAAK,OAAO,SADR,uDACwB,EAAE;EACvC,MAAM,OAAO,EAAE,MAAM;AACrB,MAAI,KAAM,gBAAe,IAAI,KAAK;;CAItC,MAAMA,YAAwB,EAAE;CAChC,MAAM,QAAQ,OAAO,MAAM,KAAK;AAChC,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM,MAAM;AACzB,OAAK,MAAM,EAAE,SAAS,YAAY,UAAU,SAAS,aAAa;AAChE,WAAQ,YAAY;AACpB,OAAI,QAAQ,KAAK,KAAK,EAAE;IAEtB,MAAM,WADK,KAAK,MAAM,WAAW,GACX,MAAM;IAC5B,MAAM,eAAe,YAAY,eAAe,IAAI,SAAS;AAC7D,cAAU,KAAK;KAAE,MAAM,IAAI;KAAG;KAAU;KAAK;KAAc,CAAC;;;;CAKlE,MAAM,sBAAsB,UAAU,QAAQ,MAAM,CAAC,EAAE,aAAa;CACpE,IAAIC;AACJ,KAAI,oBAAoB,SAAS,EAC/B,eAAc;EACZ;EACA;EACA;EACA;EACA;EACD;UACQ,UAAU,SAAS,KAAK,CAAC,kBAClC,eAAc;EACZ;EACA;EACA;EACA;EACD;UACQ,UAAU,SAAS,EAC5B,eAAc,CACZ,mDACA,0GACD;KAED,eAAc,CACZ,sDACA,yFACD;AAGH,QAAO;EACL,kBAAkB,UAAU;EAC5B,cAAc,UAAU,SAAS,oBAAoB;EACrD,gBAAgB,oBAAoB;EACpC,sBAAsB;EACtB,qBAAqB;EACrB,YAAY;EACZ;EACD"}

package/dist/middleware.d.ts

@@ -0,0 +1,32 @@
+import { AmplitudeAI } from "./client.js";
+
+//#region src/middleware.d.ts
+
+interface MiddlewareOptions {
+  amplitudeAI: AmplitudeAI;
+  userIdResolver: (req: unknown) => string | null;
+  sessionIdResolver?: (req: unknown) => string;
+  agentId?: string | null;
+  env?: string | null;
+  trackSessionEvents?: boolean;
+  flushOnResponse?: boolean;
+}
+interface ExpressLikeRequest {
+  headers: Record<string, string | string[] | undefined>;
+}
+interface ExpressLikeResponse {
+  on: (event: string, callback: () => void) => void;
+}
+/**
+ * Creates Express-compatible middleware.
+ *
+ * Usage:
+ *   app.use(createAmplitudeAIMiddleware({
+ *     amplitudeAI: ai,
+ *     userIdResolver: (req) => req.headers['x-user-id'],
+ *   }));
+ */
+declare function createAmplitudeAIMiddleware(options: MiddlewareOptions): (req: ExpressLikeRequest, res: ExpressLikeResponse, next: () => void) => void;
+//#endregion
+export { MiddlewareOptions, createAmplitudeAIMiddleware };
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../src/middleware.ts"],"sourcesContent":[],"mappings":";;;;AAuCqD,UA3BpC,iBAAA,CA2BoC;EAa5C,WAAA,EAvCM,WAuCN;EACA,cAAA,EAAA,CAAA,GAAA,EAAA,OAAA,EAAA,GAAA,MAAA,GAAA,IAAA;EAAmB,iBAAA,CAAA,EAAA,CAAA,GAAA,EAAA,OAAA,EAAA,GAAA,MAAA;;;;;;UA/BlB,kBAAA;WACC;;UAGD,mBAAA;;;;;;;;;;;;iBAaM,2BAAA,UAAqC,0BAa5C,yBACA"}

package/dist/middleware.js

@@ -0,0 +1,67 @@
+import { getLogger } from "./utils/logger.js";
+import { SessionContext, _sessionStorage } from "./context.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/middleware.ts
+/**
+* HTTP middleware for automatic session tracking in Express/Koa/Hono apps.
+*
+* Port of the Python ASGI middleware (AmplitudeAIMiddleware).
+* For Express-like frameworks, use createAmplitudeAIMiddleware().
+*/
+/**
+* Creates Express-compatible middleware.
+*
+* Usage:
+*   app.use(createAmplitudeAIMiddleware({
+*     amplitudeAI: ai,
+*     userIdResolver: (req) => req.headers['x-user-id'],
+*   }));
+*/
+function createAmplitudeAIMiddleware(options) {
+	const { amplitudeAI, userIdResolver, sessionIdResolver = () => randomUUID(), agentId = null, env = null, trackSessionEvents = true, flushOnResponse = true } = options;
+	const logger = getLogger(amplitudeAI.amplitude);
+	return (req, res, next) => {
+		const userId = userIdResolver(req);
+		const sessionId = sessionIdResolver(req);
+		let traceId = req.headers["x-trace-id"];
+		if (!traceId && req.headers.traceparent) {
+			const parts = String(req.headers.traceparent).split("-");
+			traceId = parts.length >= 2 ? parts[1] : void 0;
+		}
+		if (!traceId) traceId = randomUUID();
+		const ctx = new SessionContext({
+			sessionId,
+			traceId,
+			userId,
+			agentId,
+			env,
+			nextTurnIdFn: () => amplitudeAI._nextTurnId(sessionId)
+		});
+		_sessionStorage.run(ctx, () => {
+			res.on("finish", () => {
+				if (trackSessionEvents && userId != null) try {
+					amplitudeAI.trackSessionEnd({
+						userId,
+						sessionId,
+						traceId: traceId ?? void 0,
+						env,
+						agentId
+					});
+				} catch (error) {
+					logger.warn(`Failed to track session end in middleware: ${error instanceof Error ? error.message : String(error)}`);
+				}
+				if (flushOnResponse) try {
+					amplitudeAI.flush();
+				} catch (error) {
+					logger.warn(`Failed to flush events in middleware: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+			next();
+		});
+	};
+}
+
+//#endregion
+export { createAmplitudeAIMiddleware };
+//# sourceMappingURL=middleware.js.map

package/dist/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","names":[],"sources":["../src/middleware.ts"],"sourcesContent":["/**\n * HTTP middleware for automatic session tracking in Express/Koa/Hono apps.\n *\n * Port of the Python ASGI middleware (AmplitudeAIMiddleware).\n * For Express-like frameworks, use createAmplitudeAIMiddleware().\n */\n\nimport { randomUUID } from 'node:crypto';\nimport type { AmplitudeAI } from './client.js';\nimport { _sessionStorage, SessionContext } from './context.js';\nimport { getLogger } from './utils/logger.js';\n\nexport interface MiddlewareOptions {\n  amplitudeAI: AmplitudeAI;\n  userIdResolver: (req: unknown) => string | null;\n  sessionIdResolver?: (req: unknown) => string;\n  agentId?: string | null;\n  env?: string | null;\n  trackSessionEvents?: boolean;\n  flushOnResponse?: boolean;\n}\n\ninterface ExpressLikeRequest {\n  headers: Record<string, string | string[] | undefined>;\n}\n\ninterface ExpressLikeResponse {\n  on: (event: string, callback: () => void) => void;\n}\n\n/**\n * Creates Express-compatible middleware.\n *\n * Usage:\n *   app.use(createAmplitudeAIMiddleware({\n *     amplitudeAI: ai,\n *     userIdResolver: (req) => req.headers['x-user-id'],\n *   }));\n */\nexport function createAmplitudeAIMiddleware(options: MiddlewareOptions) {\n  const {\n    amplitudeAI,\n    userIdResolver,\n    sessionIdResolver = () => randomUUID(),\n    agentId = null,\n    env = null,\n    trackSessionEvents = true,\n    flushOnResponse = true,\n  } = options;\n  const logger = getLogger(amplitudeAI.amplitude);\n\n  return (\n    req: ExpressLikeRequest,\n    res: ExpressLikeResponse,\n    next: () => void,\n  ): void => {\n    const userId = userIdResolver(req);\n    const sessionId = sessionIdResolver(req);\n\n    let traceId = req.headers['x-trace-id'] as string | undefined;\n    if (!traceId && req.headers.traceparent) {\n      const parts = String(req.headers.traceparent).split('-');\n      traceId = parts.length >= 2 ? parts[1] : undefined;\n    }\n    if (!traceId) traceId = randomUUID();\n\n    const ctx = new SessionContext({\n      sessionId,\n      traceId,\n      userId,\n      agentId,\n      env,\n      nextTurnIdFn: () => amplitudeAI._nextTurnId(sessionId),\n    });\n\n    _sessionStorage.run(ctx, () => {\n      res.on('finish', () => {\n        if (trackSessionEvents && userId != null) {\n          try {\n            amplitudeAI.trackSessionEnd({\n              userId,\n              sessionId,\n              traceId: traceId ?? undefined,\n              env,\n              agentId,\n            });\n          } catch (error) {\n            logger.warn(\n              `Failed to track session end in middleware: ${\n                error instanceof Error ? error.message : String(error)\n              }`,\n            );\n          }\n        }\n\n        if (flushOnResponse) {\n          try {\n            amplitudeAI.flush();\n          } catch (error) {\n            logger.warn(\n              `Failed to flush events in middleware: ${\n                error instanceof Error ? error.message : String(error)\n              }`,\n            );\n          }\n        }\n      });\n\n      next();\n    });\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,4BAA4B,SAA4B;CACtE,MAAM,EACJ,aACA,gBACA,0BAA0B,YAAY,EACtC,UAAU,MACV,MAAM,MACN,qBAAqB,MACrB,kBAAkB,SAChB;CACJ,MAAM,SAAS,UAAU,YAAY,UAAU;AAE/C,SACE,KACA,KACA,SACS;EACT,MAAM,SAAS,eAAe,IAAI;EAClC,MAAM,YAAY,kBAAkB,IAAI;EAExC,IAAI,UAAU,IAAI,QAAQ;AAC1B,MAAI,CAAC,WAAW,IAAI,QAAQ,aAAa;GACvC,MAAM,QAAQ,OAAO,IAAI,QAAQ,YAAY,CAAC,MAAM,IAAI;AACxD,aAAU,MAAM,UAAU,IAAI,MAAM,KAAK;;AAE3C,MAAI,CAAC,QAAS,WAAU,YAAY;EAEpC,MAAM,MAAM,IAAI,eAAe;GAC7B;GACA;GACA;GACA;GACA;GACA,oBAAoB,YAAY,YAAY,UAAU;GACvD,CAAC;AAEF,kBAAgB,IAAI,WAAW;AAC7B,OAAI,GAAG,gBAAgB;AACrB,QAAI,sBAAsB,UAAU,KAClC,KAAI;AACF,iBAAY,gBAAgB;MAC1B;MACA;MACA,SAAS,WAAW;MACpB;MACA;MACD,CAAC;aACK,OAAO;AACd,YAAO,KACL,8CACE,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,GAEzD;;AAIL,QAAI,gBACF,KAAI;AACF,iBAAY,OAAO;aACZ,OAAO;AACd,YAAO,KACL,yCACE,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,GAEzD;;KAGL;AAEF,SAAM;IACN"}

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js

@@ -0,0 +1,54 @@
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+/**
+* Experimental task capability assertion helpers.
+* WARNING: These APIs are experimental and may change without notice.
+*
+* @experimental
+*/
+/**
+* Asserts that task creation is supported for tools/call.
+* Used by Client.assertTaskCapability and Server.assertTaskHandlerCapability.
+*
+* @param requests - The task requests capability object
+* @param method - The method being checked
+* @param entityName - 'Server' or 'Client' for error messages
+* @throws Error if the capability is not supported
+*
+* @experimental
+*/
+function assertToolsCallTaskCapability(requests, method, entityName) {
+	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
+	switch (method) {
+		case "tools/call":
+			if (!requests.tools?.call) throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+			break;
+		default: break;
+	}
+}
+/**
+* Asserts that task creation is supported for sampling/createMessage or elicitation/create.
+* Used by Server.assertTaskCapability and Client.assertTaskHandlerCapability.
+*
+* @param requests - The task requests capability object
+* @param method - The method being checked
+* @param entityName - 'Server' or 'Client' for error messages
+* @throws Error if the capability is not supported
+*
+* @experimental
+*/
+function assertClientRequestTaskCapability(requests, method, entityName) {
+	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
+	switch (method) {
+		case "sampling/createMessage":
+			if (!requests.sampling?.createMessage) throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+			break;
+		case "elicitation/create":
+			if (!requests.elicitation?.create) throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+			break;
+		default: break;
+	}
+}
+
+//#endregion
+export { assertClientRequestTaskCapability, assertToolsCallTaskCapability };
+//# sourceMappingURL=helpers.js.map

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js"],"sourcesContent":["/**\n * Experimental task capability assertion helpers.\n * WARNING: These APIs are experimental and may change without notice.\n *\n * @experimental\n */\n/**\n * Asserts that task creation is supported for tools/call.\n * Used by Client.assertTaskCapability and Server.assertTaskHandlerCapability.\n *\n * @param requests - The task requests capability object\n * @param method - The method being checked\n * @param entityName - 'Server' or 'Client' for error messages\n * @throws Error if the capability is not supported\n *\n * @experimental\n */\nexport function assertToolsCallTaskCapability(requests, method, entityName) {\n    if (!requests) {\n        throw new Error(`${entityName} does not support task creation (required for ${method})`);\n    }\n    switch (method) {\n        case 'tools/call':\n            if (!requests.tools?.call) {\n                throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);\n            }\n            break;\n        default:\n            // Method doesn't support tasks, which is fine - no error\n            break;\n    }\n}\n/**\n * Asserts that task creation is supported for sampling/createMessage or elicitation/create.\n * Used by Server.assertTaskCapability and Client.assertTaskHandlerCapability.\n *\n * @param requests - The task requests capability object\n * @param method - The method being checked\n * @param entityName - 'Server' or 'Client' for error messages\n * @throws Error if the capability is not supported\n *\n * @experimental\n */\nexport function assertClientRequestTaskCapability(requests, method, entityName) {\n    if (!requests) {\n        throw new Error(`${entityName} does not support task creation (required for ${method})`);\n    }\n    switch (method) {\n        case 'sampling/createMessage':\n            if (!requests.sampling?.createMessage) {\n                throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);\n            }\n            break;\n        case 'elicitation/create':\n            if (!requests.elicitation?.create) {\n                throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);\n            }\n            break;\n        default:\n            // Method doesn't support tasks, which is fine - no error\n            break;\n    }\n}\n//# sourceMappingURL=helpers.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,SAAgB,8BAA8B,UAAU,QAAQ,YAAY;AACxE,KAAI,CAAC,SACD,OAAM,IAAI,MAAM,GAAG,WAAW,gDAAgD,OAAO,GAAG;AAE5F,SAAQ,QAAR;EACI,KAAK;AACD,OAAI,CAAC,SAAS,OAAO,KACjB,OAAM,IAAI,MAAM,GAAG,WAAW,+DAA+D,OAAO,GAAG;AAE3G;EACJ,QAEI;;;;;;;;;;;;;;AAcZ,SAAgB,kCAAkC,UAAU,QAAQ,YAAY;AAC5E,KAAI,CAAC,SACD,OAAM,IAAI,MAAM,GAAG,WAAW,gDAAgD,OAAO,GAAG;AAE5F,SAAQ,QAAR;EACI,KAAK;AACD,OAAI,CAAC,SAAS,UAAU,cACpB,OAAM,IAAI,MAAM,GAAG,WAAW,2EAA2E,OAAO,GAAG;AAEvH;EACJ,KAAK;AACD,OAAI,CAAC,SAAS,aAAa,OACvB,OAAM,IAAI,MAAM,GAAG,WAAW,uEAAuE,OAAO,GAAG;AAEnH;EACJ,QAEI"}

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js

@@ -0,0 +1,20 @@
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
+/**
+* Experimental task interfaces for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
+*/
+/**
+* Checks if a task status represents a terminal state.
+* Terminal states are those where the task has finished and will not change.
+*
+* @param status - The task status to check
+* @returns True if the status is terminal (completed, failed, or cancelled)
+* @experimental
+*/
+function isTerminal(status) {
+	return status === "completed" || status === "failed" || status === "cancelled";
+}
+
+//#endregion
+export { isTerminal };
+//# sourceMappingURL=interfaces.js.map

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.js","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js"],"sourcesContent":["/**\n * Experimental task interfaces for MCP SDK.\n * WARNING: These APIs are experimental and may change without notice.\n */\n/**\n * Checks if a task status represents a terminal state.\n * Terminal states are those where the task has finished and will not change.\n *\n * @param status - The task status to check\n * @returns True if the status is terminal (completed, failed, or cancelled)\n * @experimental\n */\nexport function isTerminal(status) {\n    return status === 'completed' || status === 'failed' || status === 'cancelled';\n}\n//# sourceMappingURL=interfaces.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;AAYA,SAAgB,WAAW,QAAQ;AAC/B,QAAO,WAAW,eAAe,WAAW,YAAY,WAAW"}

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js

@@ -0,0 +1,34 @@
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js
+/**
+* Experimental McpServer task features for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
+*
+* @experimental
+*/
+/**
+* Experimental task features for McpServer.
+*
+* Access via `server.experimental.tasks`:
+* ```typescript
+* server.experimental.tasks.registerToolTask('long-running', config, handler);
+* ```
+*
+* @experimental
+*/
+var ExperimentalMcpServerTasks = class {
+	constructor(_mcpServer) {
+		this._mcpServer = _mcpServer;
+	}
+	registerToolTask(name, config, handler) {
+		const execution = {
+			taskSupport: "required",
+			...config.execution
+		};
+		if (execution.taskSupport === "forbidden") throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
+		return this._mcpServer._createRegisteredTool(name, config.title, config.description, config.inputSchema, config.outputSchema, config.annotations, execution, config._meta, handler);
+	}
+};
+
+//#endregion
+export { ExperimentalMcpServerTasks };
+//# sourceMappingURL=mcp-server.js.map

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.js","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js"],"sourcesContent":["/**\n * Experimental McpServer task features for MCP SDK.\n * WARNING: These APIs are experimental and may change without notice.\n *\n * @experimental\n */\n/**\n * Experimental task features for McpServer.\n *\n * Access via `server.experimental.tasks`:\n * ```typescript\n * server.experimental.tasks.registerToolTask('long-running', config, handler);\n * ```\n *\n * @experimental\n */\nexport class ExperimentalMcpServerTasks {\n    constructor(_mcpServer) {\n        this._mcpServer = _mcpServer;\n    }\n    registerToolTask(name, config, handler) {\n        // Validate that taskSupport is not 'forbidden' for task-based tools\n        const execution = { taskSupport: 'required', ...config.execution };\n        if (execution.taskSupport === 'forbidden') {\n            throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);\n        }\n        // Access McpServer's internal _createRegisteredTool method\n        const mcpServerInternal = this._mcpServer;\n        return mcpServerInternal._createRegisteredTool(name, config.title, config.description, config.inputSchema, config.outputSchema, config.annotations, execution, config._meta, handler);\n    }\n}\n//# sourceMappingURL=mcp-server.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;AAgBA,IAAa,6BAAb,MAAwC;CACpC,YAAY,YAAY;AACpB,OAAK,aAAa;;CAEtB,iBAAiB,MAAM,QAAQ,SAAS;EAEpC,MAAM,YAAY;GAAE,aAAa;GAAY,GAAG,OAAO;GAAW;AAClE,MAAI,UAAU,gBAAgB,YAC1B,OAAM,IAAI,MAAM,oCAAoC,KAAK,6DAA6D;AAI1H,SAD0B,KAAK,WACN,sBAAsB,MAAM,OAAO,OAAO,OAAO,aAAa,OAAO,aAAa,OAAO,cAAc,OAAO,aAAa,WAAW,OAAO,OAAO,QAAQ"}

package/dist/node_modules/.pnpm/@modelcontextprotocol_sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js

@@ -0,0 +1,225 @@
+import { CreateMessageResultSchema, ElicitResultSchema } from "../../types.js";
+
+//#region node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
+/**
+* Experimental server task features for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
+*
+* @experimental
+*/
+/**
+* Experimental task features for low-level MCP servers.
+*
+* Access via `server.experimental.tasks`:
+* ```typescript
+* const stream = server.experimental.tasks.requestStream(request, schema, options);
+* ```
+*
+* For high-level server usage with task-based tools, use `McpServer.experimental.tasks` instead.
+*
+* @experimental
+*/
+var ExperimentalServerTasks = class {
+	constructor(_server) {
+		this._server = _server;
+	}
+	/**
+	* Sends a request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* This method provides streaming access to request processing, allowing you to
+	* observe intermediate task status updates for task-augmented requests.
+	*
+	* @param request - The request to send
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	requestStream(request, resultSchema, options) {
+		return this._server.requestStream(request, resultSchema, options);
+	}
+	/**
+	* Sends a sampling request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
+	* before the final result.
+	*
+	* @example
+	* ```typescript
+	* const stream = server.experimental.tasks.createMessageStream({
+	*     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
+	*     maxTokens: 100
+	* }, {
+	*     onprogress: (progress) => {
+	*         // Handle streaming tokens via progress notifications
+	*         console.log('Progress:', progress.message);
+	*     }
+	* });
+	*
+	* for await (const message of stream) {
+	*     switch (message.type) {
+	*         case 'taskCreated':
+	*             console.log('Task created:', message.task.taskId);
+	*             break;
+	*         case 'taskStatus':
+	*             console.log('Task status:', message.task.status);
+	*             break;
+	*         case 'result':
+	*             console.log('Final result:', message.result);
+	*             break;
+	*         case 'error':
+	*             console.error('Error:', message.error);
+	*             break;
+	*     }
+	* }
+	* ```
+	*
+	* @param params - The sampling request parameters
+	* @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	createMessageStream(params, options) {
+		const clientCapabilities = this._server.getClientCapabilities();
+		if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) throw new Error("Client does not support sampling tools capability.");
+		if (params.messages.length > 0) {
+			const lastMessage = params.messages[params.messages.length - 1];
+			const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+			const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+			const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
+			const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+			const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+			if (hasToolResults) {
+				if (lastContent.some((c) => c.type !== "tool_result")) throw new Error("The last message must contain only tool_result content if any is present");
+				if (!hasPreviousToolUse) throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+			}
+			if (hasPreviousToolUse) {
+				const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+				const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+				if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+			}
+		}
+		return this.requestStream({
+			method: "sampling/createMessage",
+			params
+		}, CreateMessageResultSchema, options);
+	}
+	/**
+	* Sends an elicitation request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
+	* and 'taskStatus' messages before the final result.
+	*
+	* @example
+	* ```typescript
+	* const stream = server.experimental.tasks.elicitInputStream({
+	*     mode: 'url',
+	*     message: 'Please authenticate',
+	*     elicitationId: 'auth-123',
+	*     url: 'https://example.com/auth'
+	* }, {
+	*     task: { ttl: 300000 } // Task-augmented for long-running auth flow
+	* });
+	*
+	* for await (const message of stream) {
+	*     switch (message.type) {
+	*         case 'taskCreated':
+	*             console.log('Task created:', message.task.taskId);
+	*             break;
+	*         case 'taskStatus':
+	*             console.log('Task status:', message.task.status);
+	*             break;
+	*         case 'result':
+	*             console.log('User action:', message.result.action);
+	*             break;
+	*         case 'error':
+	*             console.error('Error:', message.error);
+	*             break;
+	*     }
+	* }
+	* ```
+	*
+	* @param params - The elicitation request parameters
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	elicitInputStream(params, options) {
+		const clientCapabilities = this._server.getClientCapabilities();
+		const mode = params.mode ?? "form";
+		switch (mode) {
+			case "url":
+				if (!clientCapabilities?.elicitation?.url) throw new Error("Client does not support url elicitation.");
+				break;
+			case "form":
+				if (!clientCapabilities?.elicitation?.form) throw new Error("Client does not support form elicitation.");
+				break;
+		}
+		const normalizedParams = mode === "form" && params.mode === void 0 ? {
+			...params,
+			mode: "form"
+		} : params;
+		return this.requestStream({
+			method: "elicitation/create",
+			params: normalizedParams
+		}, ElicitResultSchema, options);
+	}
+	/**
+	* Gets the current status of a task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	* @returns The task status
+	*
+	* @experimental
+	*/
+	async getTask(taskId, options) {
+		return this._server.getTask({ taskId }, options);
+	}
+	/**
+	* Retrieves the result of a completed task.
+	*
+	* @param taskId - The task identifier
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options
+	* @returns The task result
+	*
+	* @experimental
+	*/
+	async getTaskResult(taskId, resultSchema, options) {
+		return this._server.getTaskResult({ taskId }, resultSchema, options);
+	}
+	/**
+	* Lists tasks with optional pagination.
+	*
+	* @param cursor - Optional pagination cursor
+	* @param options - Optional request options
+	* @returns List of tasks with optional next cursor
+	*
+	* @experimental
+	*/
+	async listTasks(cursor, options) {
+		return this._server.listTasks(cursor ? { cursor } : void 0, options);
+	}
+	/**
+	* Cancels a running task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	*
+	* @experimental
+	*/
+	async cancelTask(taskId, options) {
+		return this._server.cancelTask({ taskId }, options);
+	}
+};
+
+//#endregion
+export { ExperimentalServerTasks };
+//# sourceMappingURL=server.js.map