veryfront 0.1.146 → 0.1.148

package/esm/src/internal-agents/schema.js

@@ -61,22 +61,233 @@ export const RuntimeAgentSourceContextSchema = z.discriminatedUnion("type", [
         releaseId: z.string().min(1).max(255),
     }),
 ]);
+const RuntimeMessageExtensionFieldsSchema = {
+    name: z.string().max(256).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    createdAt: z.string().optional(),
+};
+export const RuntimeToolFunctionCallSchema = z.object({
+    name: ClientToolNameSchema,
+    arguments: z.string().max(MAX_TOOL_PARAMETERS_BYTES),
+}).strict();
+export const RuntimeToolCallSchema = z.object({
+    id: z.string().min(1).max(128),
+    type: z.literal("function"),
+    function: RuntimeToolFunctionCallSchema,
+}).strict();
+export const RuntimeSystemMessageSchema = z.object({
+    id: z.string().min(1),
+    role: z.literal("system"),
+    content: z.string(),
+    ...RuntimeMessageExtensionFieldsSchema,
+}).strict();
+export const RuntimeUserMessageSchema = z.object({
+    id: z.string().min(1),
+    role: z.literal("user"),
+    content: z.string(),
+    ...RuntimeMessageExtensionFieldsSchema,
+}).strict();
+export const RuntimeAssistantMessageSchema = z.object({
+    id: z.string().min(1),
+    role: z.literal("assistant"),
+    content: z.string().optional(),
+    toolCalls: z.array(RuntimeToolCallSchema).optional(),
+    ...RuntimeMessageExtensionFieldsSchema,
+}).strict();
+export const RuntimeToolMessageSchema = z.object({
+    id: z.string().min(1),
+    role: z.literal("tool"),
+    toolCallId: z.string().min(1).max(128),
+    content: z.string(),
+    error: z.string().optional(),
+    ...RuntimeMessageExtensionFieldsSchema,
+}).strict();
+export const RuntimeMessageSchema = z.discriminatedUnion("role", [
+    RuntimeSystemMessageSchema,
+    RuntimeUserMessageSchema,
+    RuntimeAssistantMessageSchema,
+    RuntimeToolMessageSchema,
+]);
+export const RuntimeContextSchema = z.union([
+    z.object({
+        description: z.string().max(1024),
+        value: z.string().max(MAX_CONTEXT_ITEM_BYTES),
+    }),
+    RuntimeContextItemSchema,
+]);
 export const RuntimeRunAgentInputSchema = z.object({
+    threadId: z.string().uuid(),
+    runId: RunIdSchema,
+    parentRunId: RunIdSchema.optional(),
+    state: z.unknown().optional(),
+    messages: z.array(RuntimeMessageSchema).max(MAX_RUNTIME_MESSAGES),
+    tools: z.array(RuntimeInjectedToolSchema).max(50).default([]),
+    context: z.array(RuntimeContextSchema).max(10).default([]).refine((value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES), { message: "context must be less than 64 KB total" }),
+    forwardedProps: z.record(z.string(), z.unknown()).optional().refine((value) => value === undefined || isWithinJsonSizeLimit(value, MAX_FORWARDED_PROPS_BYTES), { message: "forwardedProps must be less than 64 KB" }),
+});
+export const InternalAgentCompatibilityMessageSchema = z.object({
+    id: z.string().min(1),
+    role: z.enum(["user", "assistant", "system", "tool"]),
+    parts: z.array(z.object({ type: z.string().min(1) }).passthrough()).default([]),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    createdAt: z.string().optional(),
+});
+export const InternalAgentStreamRequestSchema = z.object({
     agentId: AgentIdSchema,
     threadId: z.string().uuid(),
     runId: RunIdSchema,
-    messages: z.array(z.object({
-        id: z.string().min(1),
-        role: z.enum(["user", "assistant", "system", "tool"]),
-        parts: z.array(z.object({ type: z.string().min(1) }).passthrough()).default([]),
-        metadata: z.record(z.string(), z.unknown()).optional(),
-        createdAt: z.string().optional(),
-    })).max(MAX_RUNTIME_MESSAGES),
+    parentRunId: RunIdSchema.optional(),
+    state: z.unknown().optional(),
+    messages: z.array(z.union([RuntimeMessageSchema, InternalAgentCompatibilityMessageSchema])).max(MAX_RUNTIME_MESSAGES),
     tools: z.array(RuntimeInjectedToolSchema).max(50).default([]),
-    context: z.array(RuntimeContextItemSchema).max(10).default([]).refine((value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES), { message: "context must be less than 64 KB total" }),
+    context: z.array(RuntimeContextSchema).max(10).default([]).refine((value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES), { message: "context must be less than 64 KB total" }),
     agentSource: RuntimeAgentSourceContextSchema.optional(),
     forwardedProps: z.record(z.string(), z.unknown()).optional().refine((value) => value === undefined || isWithinJsonSizeLimit(value, MAX_FORWARDED_PROPS_BYTES), { message: "forwardedProps must be less than 64 KB" }),
 });
+function extractToolArgs(part) {
+    const args = part.args;
+    if (args && typeof args === "object" && !Array.isArray(args)) {
+        return args;
+    }
+    const input = part.input;
+    if (input && typeof input === "object" && !Array.isArray(input)) {
+        return input;
+    }
+    return {};
+}
+function serializeToolArguments(args) {
+    try {
+        return JSON.stringify(args);
+    }
+    catch {
+        return "{}";
+    }
+}
+function getPartString(part, ...keys) {
+    for (const key of keys) {
+        const value = part[key];
+        if (typeof value === "string" && value.length > 0) {
+            return value;
+        }
+    }
+    return null;
+}
+function isLegacyToolCallPart(part) {
+    return getPartString(part, "type") === "tool_call";
+}
+function isCanonicalToolCallPart(part) {
+    const type = getPartString(part, "type");
+    return type === "tool-call" ||
+        (typeof type === "string" && type.startsWith("tool-") && type !== "tool-result" &&
+            type !== "tool_result");
+}
+function getToolCallShape(part) {
+    const id = getPartString(part, "toolCallId", "tool_call_id", "id");
+    const name = getPartString(part, "toolName", "tool_name", "name");
+    if (!id || !name) {
+        return null;
+    }
+    return {
+        id,
+        type: "function",
+        function: {
+            name,
+            arguments: serializeToolArguments(extractToolArgs(part)),
+        },
+    };
+}
+function isToolResultPart(part) {
+    const type = getPartString(part, "type");
+    return type === "tool-result" || type === "tool_result";
+}
+function stringifyToolResult(result) {
+    if (typeof result === "string") {
+        return result;
+    }
+    try {
+        return JSON.stringify(result);
+    }
+    catch {
+        return String(result);
+    }
+}
+function toRuntimeMessage(message) {
+    if (!("parts" in message)) {
+        return message;
+    }
+    const textContent = message.parts
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+    const sharedFields = {
+        ...(message.metadata ? { metadata: message.metadata } : {}),
+        ...(message.createdAt ? { createdAt: message.createdAt } : {}),
+    };
+    switch (message.role) {
+        case "system":
+            return {
+                id: message.id,
+                role: "system",
+                content: textContent,
+                ...sharedFields,
+            };
+        case "user":
+            return {
+                id: message.id,
+                role: "user",
+                content: textContent,
+                ...sharedFields,
+            };
+        case "assistant": {
+            const toolCalls = message.parts.flatMap((part) => {
+                if (!isCanonicalToolCallPart(part) && !isLegacyToolCallPart(part)) {
+                    return [];
+                }
+                const toolCall = getToolCallShape(part);
+                return toolCall ? [toolCall] : [];
+            });
+            return {
+                id: message.id,
+                role: "assistant",
+                ...(textContent ? { content: textContent } : {}),
+                ...(toolCalls.length ? { toolCalls } : {}),
+                ...sharedFields,
+            };
+        }
+        case "tool": {
+            const toolResultPart = message.parts.find((part) => isToolResultPart(part) && getPartString(part, "toolCallId", "tool_call_id") !== null);
+            const toolCallId = toolResultPart
+                ? getPartString(toolResultPart, "toolCallId", "tool_call_id")
+                : null;
+            const toolResult = toolResultPart && "result" in toolResultPart
+                ? toolResultPart.result
+                : toolResultPart && "output" in toolResultPart
+                    ? toolResultPart.output
+                    : undefined;
+            const toolError = toolResultPart ? getPartString(toolResultPart, "error") : null;
+            return {
+                id: message.id,
+                role: "tool",
+                toolCallId: toolCallId ?? message.id,
+                content: toolResult !== undefined ? stringifyToolResult(toolResult) : textContent,
+                ...(toolError ? { error: toolError } : {}),
+                ...sharedFields,
+            };
+        }
+    }
+}
+export function toRuntimeRunAgentInput(input) {
+    return {
+        threadId: input.threadId,
+        runId: input.runId,
+        ...(input.parentRunId ? { parentRunId: input.parentRunId } : {}),
+        ...(input.state !== undefined ? { state: input.state } : {}),
+        messages: input.messages.map(toRuntimeMessage),
+        tools: input.tools,
+        context: input.context,
+        ...(input.forwardedProps ? { forwardedProps: input.forwardedProps } : {}),
+    };
+}
 export const ResumeSignalSchema = z.discriminatedUnion("type", [
     z.object({
         type: z.literal("tool_result"),

package/esm/src/jobs/schemas.d.ts

@@ -2,9 +2,9 @@ import { z } from "zod";
 export declare const JobStatusSchema: z.ZodEnum<{
     failed: "failed";
     completed: "completed";
+    working: "working";
     canceled: "canceled";
     submitted: "submitted";
-    working: "working";
 }>;
 export declare const CronJobStatusSchema: z.ZodEnum<{
     deleting: "deleting";
@@ -199,9 +199,9 @@ export declare const JobSchema: z.ZodObject<{
     status: z.ZodEnum<{
         failed: "failed";
         completed: "completed";
+        working: "working";
         canceled: "canceled";
         submitted: "submitted";
-        working: "working";
     }>;
     target: z.ZodString;
     config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -302,9 +302,9 @@ export declare const JobListItemSchema: z.ZodObject<{
     status: z.ZodEnum<{
         failed: "failed";
         completed: "completed";
+        working: "working";
         canceled: "canceled";
         submitted: "submitted";
-        working: "working";
     }>;
     target: z.ZodString;
     config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -351,9 +351,9 @@ export declare const PaginatedJobsResponseSchema: z.ZodObject<{
         status: z.ZodEnum<{
             failed: "failed";
             completed: "completed";
+            working: "working";
             canceled: "canceled";
             submitted: "submitted";
-            working: "working";
         }>;
         target: z.ZodString;
         config: z.ZodRecord<z.ZodString, z.ZodUnknown>;

package/esm/src/mcp/elicitation.d.ts

@@ -0,0 +1,16 @@
+export interface FormElicitationOptions {
+    message: string;
+    schema: Record<string, unknown>;
+}
+export interface UrlElicitationOptions {
+    message: string;
+    url: string;
+    elicitationId: string;
+}
+export interface ElicitationRequest {
+    method: "elicitation/create";
+    params: Record<string, unknown>;
+}
+export declare function buildFormElicitation(options: FormElicitationOptions): ElicitationRequest;
+export declare function buildUrlElicitation(options: UrlElicitationOptions): ElicitationRequest;
+//# sourceMappingURL=elicitation.d.ts.map

package/esm/src/mcp/elicitation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elicitation.d.ts","sourceRoot":"","sources":["../../../src/src/mcp/elicitation.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,oBAAoB,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,sBAAsB,GAC9B,kBAAkB,CASpB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,qBAAqB,GAC7B,kBAAkB,CAUpB"}

package/esm/src/mcp/elicitation.js

@@ -0,0 +1,21 @@
+export function buildFormElicitation(options) {
+    return {
+        method: "elicitation/create",
+        params: {
+            mode: "form",
+            message: options.message,
+            requestedSchema: options.schema,
+        },
+    };
+}
+export function buildUrlElicitation(options) {
+    return {
+        method: "elicitation/create",
+        params: {
+            mode: "url",
+            message: options.message,
+            url: options.url,
+            elicitationId: options.elicitationId,
+        },
+    };
+}

package/esm/src/mcp/index.d.ts

@@ -25,6 +25,9 @@ import "../../_dnt.polyfills.js";
 export type { MCPServerConfig, MCPStats, MCPTool, ToolAnnotations, ToolListEntry, } from "./types.js";
 export { clearMCPRegistry, getMCPRegistry, getMCPStats, registerPrompt, registerResource, registerTool, } from "./registry.js";
 export { createMCPServer, type IntegrationLoaderConfig, MCPServer } from "./server.js";
+export { buildFormElicitation, buildUrlElicitation, type ElicitationRequest, type FormElicitationOptions, type UrlElicitationOptions, } from "./elicitation.js";
 export { formatSSEEvent, formatSSEPrimingEvent, formatSSERetry } from "./sse.js";
 export { SessionManager } from "./session.js";
+export { TaskStore } from "./task-store.js";
+export type { Task } from "./task-store.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/src/mcp/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,yBAAyB,CAAC;AAGjC,YAAY,EACV,eAAe,EACf,QAAQ,EACR,OAAO,EACP,eAAe,EACf,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,KAAK,uBAAuB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEvF,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,yBAAyB,CAAC;AAGjC,YAAY,EACV,eAAe,EACf,QAAQ,EACR,OAAO,EACP,eAAe,EACf,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,KAAK,uBAAuB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEvF,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,YAAY,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC"}

package/esm/src/mcp/index.js

@@ -24,5 +24,7 @@
 import "../../_dnt.polyfills.js";
 export { clearMCPRegistry, getMCPRegistry, getMCPStats, registerPrompt, registerResource, registerTool, } from "./registry.js";
 export { createMCPServer, MCPServer } from "./server.js";
+export { buildFormElicitation, buildUrlElicitation, } from "./elicitation.js";
 export { formatSSEEvent, formatSSEPrimingEvent, formatSSERetry } from "./sse.js";
 export { SessionManager } from "./session.js";
+export { TaskStore } from "./task-store.js";

package/esm/src/mcp/server.d.ts

@@ -25,11 +25,25 @@ export interface IntegrationLoaderConfig {
     apiToken?: string;
 }
 export declare class MCPServer {
+    private static LOG_LEVELS;
+    private logLevel;
     private config;
     private integrationLoader?;
     private integrationsLoaded;
     private sessionManager;
+    private taskStore;
+    private pendingTasks;
+    private clientCapabilities;
+    /** Callback for server-initiated notifications. Set by transport layer. */
+    onNotification?: (notification: {
+        jsonrpc: "2.0";
+        method: string;
+        params?: unknown;
+    }) => void;
     constructor(config: MCPServerConfig);
+    notifyToolsChanged(): void;
+    notifyResourcesChanged(): void;
+    notifyPromptsChanged(): void;
     /**
      * Configure integration tools to be loaded from the API.
      *
@@ -38,6 +52,7 @@ export declare class MCPServer {
      * Otherwise falls back to the legacy local loading path.
      */
     setIntegrationLoader(config: IntegrationLoaderConfig): void;
+    clientSupportsElicitation(mode: "form" | "url"): boolean;
     handleRequest(request: JSONRPCRequest, context?: ToolExecutionContext): Promise<JSONRPCResponse>;
     private dispatch;
     private initialize;
@@ -49,6 +64,13 @@ export declare class MCPServer {
     private listPrompts;
     private getPrompt;
     private complete;
+    private setLogLevel;
+    private getTask;
+    private getTaskResult;
+    private cancelTask;
+    private listTasks;
+    /** Wait for all background task executions to settle. Useful in tests. */
+    waitForPendingTasks(): Promise<void>;
     createHTTPHandler(): (request: dntShim.Request) => Promise<dntShim.Response>;
     private extractRequestContext;
     private validateAuth;

package/esm/src/mcp/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/src/mcp/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAG/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAI7D,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,YAAY,CAAC;AAMjE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAYzE,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,EAAE,CAAC;AA4DzD,UAAU,cAAc;IACtB,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED,UAAU,eAAe;IACvB,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,OAAO,CAAC;KAChB,CAAC;CACH;AAED,MAAM,WAAW,uBAAuB;IACtC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,GAAG,SAAS,CAAC,CAAC;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAID,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,iBAAiB,CAAC,CAA0B;IACpD,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,cAAc,CAAwB;gBAElC,MAAM,EAAE,eAAe;IAQnC;;;;;;OAMG;IACH,oBAAoB,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI;IAK3D,aAAa,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,CAAC;IAmBhG,OAAO,CAAC,QAAQ;IAoChB,OAAO,CAAC,UAAU;YA2BJ,SAAS;IA6BvB,OAAO,CAAC,QAAQ;IAgDhB,OAAO,CAAC,qBAAqB;IAuB7B,OAAO,CAAC,aAAa;IAoBrB,OAAO,CAAC,YAAY;IA6CpB,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,SAAS;IAuCjB,OAAO,CAAC,QAAQ;IAUhB,iBAAiB,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;IAiG5E,OAAO,CAAC,qBAAqB;YAgBf,YAAY;IAsB1B,OAAO,CAAC,cAAc;YAsBR,0BAA0B;CAqBzC;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAElE"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/src/mcp/server.ts"],"names":[],"mappings":"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"}

package/esm/src/mcp/server.js

@@ -11,6 +11,7 @@ import { validateContentType } from "../security/input-validation/limits.js";
 import { VeryfrontError } from "../security/input-validation/errors.js";
 import { logger as baseLogger } from "../utils/index.js";
 import { SessionManager } from "./session.js";
+import { TaskStore } from "./task-store.js";
 const logger = baseLogger.component("mcp-server");
 const MAX_REQUEST_BODY_SIZE = 1_048_576; // 1 MB
 const MAX_CONTEXT_HEADER_LENGTH = 255;
@@ -66,16 +67,43 @@ function readAllowedHeader(request, headerName, pattern) {
 }
 const MCP_SUPPORTED_VERSIONS = ["2025-11-25", "2024-11-05"];
 export class MCPServer {
+    static LOG_LEVELS = [
+        "debug",
+        "info",
+        "notice",
+        "warning",
+        "error",
+        "critical",
+        "alert",
+        "emergency",
+    ];
+    logLevel = "warning";
     config;
     integrationLoader;
     integrationsLoaded = false;
     sessionManager = new SessionManager();
+    taskStore = new TaskStore();
+    pendingTasks = new Map();
+    // TODO(#842): capabilities should be stored per-session (keyed by MCP-Session-Id)
+    // so concurrent clients don't overwrite each other's capability flags.
+    clientCapabilities = {};
+    /** Callback for server-initiated notifications. Set by transport layer. */
+    onNotification;
     constructor(config) {
         this.config = config;
         if (!config.auth || config.auth.type === "none") {
             logger.warn("MCP server has no authentication configured — all requests will be accepted");
         }
     }
+    notifyToolsChanged() {
+        this.onNotification?.({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+    }
+    notifyResourcesChanged() {
+        this.onNotification?.({ jsonrpc: "2.0", method: "notifications/resources/list_changed" });
+    }
+    notifyPromptsChanged() {
+        this.onNotification?.({ jsonrpc: "2.0", method: "notifications/prompts/list_changed" });
+    }
     /**
      * Configure integration tools to be loaded from the API.
      *
@@ -87,6 +115,16 @@ export class MCPServer {
         this.integrationLoader = config;
         this.integrationsLoaded = false;
     }
+    clientSupportsElicitation(mode) {
+        const raw = this.clientCapabilities.elicitation;
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return false;
+        const elicitation = raw;
+        // Per MCP spec: empty elicitation object implies basic form support (backwards compat)
+        if (mode === "form" && Object.keys(elicitation).length === 0)
+            return true;
+        return mode in elicitation;
+    }
     handleRequest(request, context) {
         return withSpan("mcp.handleRequest", async () => {
             try {
@@ -122,8 +160,21 @@ export class MCPServer {
                 return this.initialize(params);
             case "notifications/initialized":
                 return Promise.resolve({});
+            case "notifications/cancelled":
+                // TODO(#841): propagate cancellation to in-flight tool executions via AbortController
+                return Promise.resolve({});
             case "completion/complete":
                 return this.complete(params);
+            case "logging/setLevel":
+                return this.setLogLevel(params);
+            case "tasks/get":
+                return this.getTask(params);
+            case "tasks/result":
+                return this.getTaskResult(params);
+            case "tasks/cancel":
+                return this.cancelTask(params);
+            case "tasks/list":
+                return this.listTasks();
             default:
                 throw toError(createError({
                     type: "agent",
@@ -137,6 +188,8 @@ export class MCPServer {
         const negotiated = requested && MCP_SUPPORTED_VERSIONS.includes(requested)
             ? requested
             : MCP_SUPPORTED_VERSIONS[0];
+        const clientCaps = (p.capabilities ?? {});
+        this.clientCapabilities = clientCaps;
         return Promise.resolve({
             protocolVersion: negotiated,
             serverInfo: {
@@ -150,6 +203,8 @@ export class MCPServer {
                 resources: { subscribe: true, listChanged: true },
                 prompts: { listChanged: true },
                 completions: {},
+                logging: {},
+                tasks: { list: {}, cancel: {}, requests: { tools: { call: {} } } },
             },
             instructions: "Veryfront MCP server provides development tools. Use vf_get_errors to check for code errors, vf_get_logs for server logs, vf_scaffold for code generation, and vf_get_project_context for project structure.",
         });
@@ -183,7 +238,13 @@ export class MCPServer {
         return { tools };
     }
     callTool(params, context) {
-        const { name, arguments: args } = toParamsRecord(params);
+        const p = toParamsRecord(params);
+        const { name, arguments: args } = p;
+        const meta = (p._meta ?? {});
+        const rawToken = meta.progressToken;
+        const progressToken = (typeof rawToken === "string" || typeof rawToken === "number")
+            ? rawToken
+            : undefined;
         if (!name) {
             throw toError(createError({ type: "agent", message: "Tool name is required" }));
         }
@@ -202,9 +263,46 @@ export class MCPServer {
                 throw new JsonRpcError(-32602, `Invalid arguments for tool ${toolName}: ${message}`);
             }
         }
+        const toolContext = progressToken !== undefined
+            ? { ...context, progressToken }
+            : context;
+        // Async task mode: if the caller provides a `task` field, create a task
+        // and run the tool in the background, returning the task immediately.
+        const taskParam = p.task;
+        if (taskParam) {
+            const MIN_TTL = 1000;
+            const MAX_TTL = 3_600_000; // 1 hour
+            const rawTtl = typeof taskParam.ttl === "number" ? taskParam.ttl : 60000;
+            const ttl = Math.max(MIN_TTL, Math.min(MAX_TTL, rawTtl));
+            const task = this.taskStore.create(ttl);
+            // Run tool in background, update task on completion
+            // TODO(#842): wire AbortController so that tasks/cancel actually aborts the running tool execution
+            const pending = withSpan("mcp.callTool.async", async () => {
+                try {
+                    const result = await executeTool(toolName, args, toolContext);
+                    this.taskStore.complete(task.taskId, {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                        isError: false,
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    logger.warn("Async tool execution failed", {
+                        tool: toolName,
+                        taskId: task.taskId,
+                        error: message,
+                    });
+                    this.taskStore.fail(task.taskId, message);
+                }
+            }, { "mcp.tool.name": toolName, "mcp.task.id": task.taskId }).then(() => {
+                this.pendingTasks.delete(task.taskId);
+            });
+            this.pendingTasks.set(task.taskId, pending);
+            return Promise.resolve({ task });
+        }
         return withSpan("mcp.callTool", async () => {
             try {
-                const result = await executeTool(toolName, args, context);
+                const result = await executeTool(toolName, args, toolContext);
                 return {
                     content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
                     isError: false,
@@ -327,6 +425,63 @@ export class MCPServer {
             completion: { values: [], total: 0, hasMore: false },
         });
     }
+    setLogLevel(params) {
+        const p = toParamsRecord(params);
+        const level = p.level;
+        if (!MCPServer.LOG_LEVELS.includes(level)) {
+            return Promise.reject({
+                code: -32602,
+                message: `Invalid log level: ${level}. Valid levels: ${MCPServer.LOG_LEVELS.join(", ")}`,
+            });
+        }
+        this.logLevel = level;
+        return Promise.resolve({});
+    }
+    getTask(params) {
+        const { taskId } = toParamsRecord(params);
+        if (!taskId) {
+            throw new JsonRpcError(-32602, "taskId is required");
+        }
+        const task = this.taskStore.get(String(taskId));
+        if (!task) {
+            throw new JsonRpcError(-32602, `Task not found: ${taskId}`);
+        }
+        return Promise.resolve({ ...task });
+    }
+    getTaskResult(params) {
+        const { taskId } = toParamsRecord(params);
+        if (!taskId) {
+            throw new JsonRpcError(-32602, "taskId is required");
+        }
+        const task = this.taskStore.get(String(taskId));
+        if (!task) {
+            throw new JsonRpcError(-32602, `Task not found: ${taskId}`);
+        }
+        const result = this.taskStore.getResult(String(taskId));
+        if (result === undefined) {
+            throw new JsonRpcError(-32002, "Task result is not yet available");
+        }
+        return Promise.resolve(result);
+    }
+    cancelTask(params) {
+        const { taskId } = toParamsRecord(params);
+        if (!taskId) {
+            throw new JsonRpcError(-32602, "taskId is required");
+        }
+        const cancelled = this.taskStore.cancel(String(taskId));
+        if (!cancelled) {
+            throw new JsonRpcError(-32002, `Cannot cancel task: ${taskId}`);
+        }
+        const task = this.taskStore.get(String(taskId));
+        return Promise.resolve({ ...task });
+    }
+    listTasks() {
+        return Promise.resolve({ tasks: this.taskStore.list() });
+    }
+    /** Wait for all background task executions to settle. Useful in tests. */
+    waitForPendingTasks() {
+        return Promise.all(this.pendingTasks.values()).then(() => { });
+    }
     createHTTPHandler() {
         return async (request) => {
             const requestOrigin = request.headers.get("Origin");
@@ -480,6 +635,12 @@ export class MCPServer {
             };
         }
         await syncIntegrationConfig(apiBaseUrl, apiToken, integrationConfigs);
+        try {
+            this.notifyToolsChanged();
+        }
+        catch (_) {
+            // Notification delivery failure is non-fatal — sync already succeeded
+        }
         return true;
     }
 }