@frontmcp/sdk 1.0.4 → 1.1.0-beta.1

package/task/flows/tasks-get.flow.d.ts

@@ -0,0 +1,69 @@
+/**
+ * tasks/get flow — returns the current state snapshot of a task.
+ *
+ * Per MCP 2025-11-25 §Getting Tasks. Non-blocking: returns the record as-is,
+ * whether `working`, `input_required`, or terminal.
+ *
+ * @module task/flows/tasks-get.flow
+ */
+import { z } from '@frontmcp/lazy-zod';
+import { type AuthInfo } from '@frontmcp/protocol';
+import { FlowBase, type FlowRunOptions } from '../../common';
+declare const inputSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    request: import("@frontmcp/lazy-zod").ZodObject<{
+        method: import("@frontmcp/lazy-zod").ZodLiteral<"tasks/get">;
+        params: import("@frontmcp/lazy-zod").ZodObject<{
+            _meta: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+                progressToken: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodNumber]>>;
+                "io.modelcontextprotocol/related-task": import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+                    taskId: import("@frontmcp/lazy-zod").ZodString;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$loose>>;
+            taskId: import("@frontmcp/lazy-zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    ctx: import("@frontmcp/lazy-zod").ZodAny;
+}, import("zod/v4/core").$strip>;
+declare const outputSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    _meta: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+        progressToken: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodNumber]>>;
+        "io.modelcontextprotocol/related-task": import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+            taskId: import("@frontmcp/lazy-zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$loose>>;
+    taskId: import("@frontmcp/lazy-zod").ZodString;
+    status: import("@frontmcp/lazy-zod").ZodEnum<{
+        working: "working";
+        input_required: "input_required";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    ttl: import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodNumber, import("@frontmcp/lazy-zod").ZodNull]>;
+    createdAt: import("@frontmcp/lazy-zod").ZodString;
+    lastUpdatedAt: import("@frontmcp/lazy-zod").ZodString;
+    pollInterval: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
+    statusMessage: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+}, import("zod/v4/core").$strip>;
+declare const stateSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    taskId: import("@frontmcp/lazy-zod").ZodString;
+    sessionId: import("@frontmcp/lazy-zod").ZodString;
+    authInfo: z.ZodType<AuthInfo>;
+}, import("zod/v4/core").$strip>;
+declare const plan: {
+    readonly pre: ["parseInput"];
+    readonly execute: ["fetchAndRespond"];
+};
+declare global {
+    interface ExtendFlows {
+        'tasks:get': FlowRunOptions<TasksGetFlow, typeof plan, typeof inputSchema, typeof outputSchema, typeof stateSchema>;
+    }
+}
+declare const name: "tasks:get";
+export default class TasksGetFlow extends FlowBase<typeof name> {
+    logger: import("../../common").FrontMcpLogger;
+    parseInput(): Promise<void>;
+    fetchAndRespond(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=tasks-get.flow.d.ts.map

package/task/flows/tasks-get.flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-get.flow.d.ts","sourceRoot":"","sources":["../../../src/task/flows/tasks-get.flow.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAC;AACvC,OAAO,EAA6C,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9F,OAAO,EAAQ,QAAQ,EAA8B,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAU/F,QAAA,MAAM,WAAW;;;;;;;;;;;;;;gCAGf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;gCAAsB,CAAC;AAEzC,QAAA,MAAM,WAAW;;;cAGM,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;gCACxC,CAAC;AAEH,QAAA,MAAM,IAAI;;;CAG2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,WAAW,EAAE,cAAc,CAAC,YAAY,EAAE,OAAO,IAAI,EAAE,OAAO,WAAW,EAAE,OAAO,YAAY,EAAE,OAAO,WAAW,CAAC,CAAC;KACrH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,WAAoB,CAAC;AAUlC,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAC7D,MAAM,wCAA0C;IAG1C,UAAU;IAuBV,eAAe;CAUtB"}

package/task/flows/tasks-list.flow.d.ts

@@ -0,0 +1,73 @@
+/**
+ * tasks/list flow — paginated, session-scoped list of tasks.
+ *
+ * Per MCP 2025-11-25 §Task Listing and §Security: we only return tasks owned
+ * by the requesting session. The list capability is advertised only when
+ * requestors are identifiable; otherwise listing tasks would leak metadata.
+ *
+ * @module task/flows/tasks-list.flow
+ */
+import { z } from '@frontmcp/lazy-zod';
+import { type AuthInfo } from '@frontmcp/protocol';
+import { FlowBase, type FlowRunOptions } from '../../common';
+declare const inputSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    request: import("@frontmcp/lazy-zod").ZodObject<{
+        params: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+            _meta: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+                progressToken: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodNumber]>>;
+                "io.modelcontextprotocol/related-task": import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+                    taskId: import("@frontmcp/lazy-zod").ZodString;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$loose>>;
+            cursor: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        method: import("@frontmcp/lazy-zod").ZodLiteral<"tasks/list">;
+    }, import("zod/v4/core").$strip>;
+    ctx: import("@frontmcp/lazy-zod").ZodAny;
+}, import("zod/v4/core").$strip>;
+declare const outputSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    _meta: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+        progressToken: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodNumber]>>;
+        "io.modelcontextprotocol/related-task": import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+            taskId: import("@frontmcp/lazy-zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$loose>>;
+    nextCursor: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    tasks: import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodObject<{
+        taskId: import("@frontmcp/lazy-zod").ZodString;
+        status: import("@frontmcp/lazy-zod").ZodEnum<{
+            working: "working";
+            input_required: "input_required";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>;
+        ttl: import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodNumber, import("@frontmcp/lazy-zod").ZodNull]>;
+        createdAt: import("@frontmcp/lazy-zod").ZodString;
+        lastUpdatedAt: import("@frontmcp/lazy-zod").ZodString;
+        pollInterval: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
+        statusMessage: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$loose>;
+declare const stateSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    sessionId: import("@frontmcp/lazy-zod").ZodString;
+    cursor: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    authInfo: z.ZodType<AuthInfo>;
+}, import("zod/v4/core").$strip>;
+declare const plan: {
+    readonly pre: ["parseInput"];
+    readonly execute: ["listAndRespond"];
+};
+declare global {
+    interface ExtendFlows {
+        'tasks:list': FlowRunOptions<TasksListFlow, typeof plan, typeof inputSchema, typeof outputSchema, typeof stateSchema>;
+    }
+}
+declare const name: "tasks:list";
+export default class TasksListFlow extends FlowBase<typeof name> {
+    logger: import("../../common").FrontMcpLogger;
+    parseInput(): Promise<void>;
+    listAndRespond(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=tasks-list.flow.d.ts.map

package/task/flows/tasks-list.flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-list.flow.d.ts","sourceRoot":"","sources":["../../../src/task/flows/tasks-list.flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAC;AACvC,OAAO,EAAiD,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAElG,OAAO,EAAQ,QAAQ,EAA8B,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAI/F,QAAA,MAAM,WAAW;;;;;;;;;;;;;;gCAGf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;gCAAwB,CAAC;AAE3C,QAAA,MAAM,WAAW;;;cAGM,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;gCACxC,CAAC;AAEH,QAAA,MAAM,IAAI;;;CAG2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,YAAY,EAAE,cAAc,CAC1B,aAAa,EACb,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,YAAqB,CAAC;AAUnC,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAC9D,MAAM,wCAA2C;IAG3C,UAAU;IAuBV,cAAc;CAWrB"}

package/task/flows/tasks-result.flow.d.ts

@@ -0,0 +1,93 @@
+/**
+ * tasks/result flow — blocks until the task reaches a terminal status, then
+ * returns the underlying request's result verbatim.
+ *
+ * Per MCP 2025-11-25 §Result Retrieval:
+ *  - For terminal tasks, MUST return exactly what the underlying request would
+ *    have returned (a `CallToolResult` on success, or the original JSON-RPC
+ *    error on failure).
+ *  - For non-terminal tasks, MUST block until terminal. We use the store's
+ *    pub/sub `subscribeTerminal` so cross-node unblocking works automatically.
+ *  - The response MUST include `_meta['io.modelcontextprotocol/related-task']`
+ *    with the `taskId` (unlike `tasks/get`/`list`/`cancel`).
+ *
+ * @module task/flows/tasks-result.flow
+ */
+import { z } from '@frontmcp/lazy-zod';
+import { type AuthInfo } from '@frontmcp/protocol';
+import { FlowBase, type FlowRunOptions } from '../../common';
+declare const inputSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    request: import("@frontmcp/lazy-zod").ZodObject<{
+        method: import("@frontmcp/lazy-zod").ZodLiteral<"tasks/result">;
+        params: import("@frontmcp/lazy-zod").ZodObject<{
+            _meta: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+                progressToken: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodNumber]>>;
+                "io.modelcontextprotocol/related-task": import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+                    taskId: import("@frontmcp/lazy-zod").ZodString;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$loose>>;
+            taskId: import("@frontmcp/lazy-zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    ctx: import("@frontmcp/lazy-zod").ZodAny;
+}, import("zod/v4/core").$strip>;
+declare const outputSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    _meta: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+        progressToken: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodNumber]>>;
+        "io.modelcontextprotocol/related-task": import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodObject<{
+            taskId: import("@frontmcp/lazy-zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$loose>>;
+}, import("zod/v4/core").$loose>;
+declare const stateSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    taskId: import("@frontmcp/lazy-zod").ZodString;
+    sessionId: import("@frontmcp/lazy-zod").ZodString;
+    authInfo: z.ZodType<AuthInfo>;
+}, import("zod/v4/core").$strip>;
+declare const plan: {
+    readonly pre: ["parseInput"];
+    readonly execute: ["awaitTerminal"];
+};
+declare global {
+    interface ExtendFlows {
+        'tasks:result': FlowRunOptions<TasksResultFlow, typeof plan, typeof inputSchema, typeof outputSchema, typeof stateSchema>;
+    }
+}
+declare const name: "tasks:result";
+export default class TasksResultFlow extends FlowBase<typeof name> {
+    logger: import("../../common").FrontMcpLogger;
+    parseInput(): Promise<void>;
+    awaitTerminal(): Promise<void>;
+    /**
+     * Block until the task reaches a terminal state.
+     *
+     * Two wake-up paths:
+     *  1. `subscribeTerminal` — instant for backends whose pub/sub reaches this
+     *     process (memory, Redis/Upstash, SQLite within the same process).
+     *  2. Periodic `store.get` polling — the only path that works for the
+     *     SQLite backend when the caller and the runner live in different
+     *     processes (CLI runner + future stdio invocation). Without this, those
+     *     callers would block forever since the child's EventEmitter never
+     *     reaches the parent.
+     */
+    private waitForTerminal;
+    private pollDelayMs;
+    private respondWithOutcome;
+}
+/**
+ * Thrown from `tasks:result` when the underlying request terminated in error.
+ * The handler converts this back into the exact JSON-RPC error per spec.
+ */
+export declare class JsonRpcReplayError extends Error {
+    readonly code: number;
+    readonly data: unknown;
+    readonly taskId: string;
+    constructor(code: number, message: string, data: unknown, taskId: string);
+    toJsonRpcError(): {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export {};
+//# sourceMappingURL=tasks-result.flow.d.ts.map

package/task/flows/tasks-result.flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-result.flow.d.ts","sourceRoot":"","sources":["../../../src/task/flows/tasks-result.flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAC;AACvC,OAAO,EAA2D,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE5G,OAAO,EAAQ,QAAQ,EAA8B,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAU/F,QAAA,MAAM,WAAW;;;;;;;;;;;;;;gCAGf,CAAC;AAKH,QAAA,MAAM,YAAY;;;;;;;gCAA6B,CAAC;AAEhD,QAAA,MAAM,WAAW;;;cAGM,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;gCACxC,CAAC;AAEH,QAAA,MAAM,IAAI;;;CAG2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,cAAc,EAAE,cAAc,CAC5B,eAAe,EACf,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,cAAuB,CAAC;AAUrC,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAChE,MAAM,wCAA6C;IAG7C,UAAU;IAuBV,aAAa;IAcnB;;;;;;;;;;;OAWG;YACW,eAAe;IAgE7B,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,kBAAkB;CAoB3B;AAED;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;aAEzB,IAAI,EAAE,MAAM;aAEZ,IAAI,EAAE,OAAO;aACb,MAAM,EAAE,MAAM;gBAHd,IAAI,EAAE,MAAM,EAC5B,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,MAAM;IAKhC,cAAc,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE;CAQpE"}

package/task/helpers/cli-task-runner.d.ts

@@ -0,0 +1,46 @@
+/**
+ * CLI task runner — spawns a detached worker process that executes the tool
+ * and writes the terminal outcome back to the persistent store.
+ *
+ * The worker is launched via `frontmcp __run-task <taskId>` using either:
+ *   1. An explicit `tasks.cliRunnerCommand` override, or
+ *   2. The currently-running executable (`argv[0]` + `argv[1]`),
+ *   3. Falling back to `node <entrypoint>`.
+ *
+ * Cancellation uses `process.kill(pid, SIGTERM)`. The worker is expected to
+ * observe the signal via the AbortSignal surfaced on `ToolContext.signal`.
+ *
+ * @module task/helpers/cli-task-runner
+ */
+import type { FrontMcpLogger } from '../../common';
+import type { TaskStore } from '../store';
+import type { TaskRecord } from '../task.types';
+import type { SpawnContext, TaskRunner } from './task-runner.types';
+export interface CliTaskRunnerCommand {
+    exe: string;
+    args?: string[];
+}
+export interface CliTaskRunnerDeps {
+    store: TaskStore;
+    /** Explicit command override. When omitted, the runner uses `argv[0]`+`argv[1]`. */
+    command?: CliTaskRunnerCommand;
+    logger?: FrontMcpLogger;
+}
+declare const RUN_TASK_SUBCOMMAND = "__run-task";
+declare const RUN_TASK_ENV_VAR = "FRONTMCP_RUN_TASK_ID";
+export declare class CliTaskRunner implements TaskRunner {
+    private readonly deps;
+    readonly kind: "cli";
+    constructor(deps: CliTaskRunnerDeps);
+    run(record: TaskRecord, _context: SpawnContext): Promise<void>;
+    /**
+     * Transition a task to `failed` when we couldn't even get a worker off the
+     * ground. Publishes the terminal event so any `tasks/result` waiter is
+     * unblocked, and is best-effort (a failing store write is only logged).
+     */
+    private markBootstrapFailure;
+    cancel(record: TaskRecord): Promise<void>;
+    private resolveCommand;
+}
+export { RUN_TASK_SUBCOMMAND, RUN_TASK_ENV_VAR };
+//# sourceMappingURL=cli-task-runner.d.ts.map

package/task/helpers/cli-task-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-task-runner.d.ts","sourceRoot":"","sources":["../../../src/task/helpers/cli-task-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEpE,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,SAAS,CAAC;IACjB,oFAAoF;IACpF,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAED,QAAA,MAAM,mBAAmB,eAAe,CAAC;AACzC,QAAA,MAAM,gBAAgB,yBAAyB,CAAC;AAEhD,qBAAa,aAAc,YAAW,UAAU;IAGlC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;gBAEF,IAAI,EAAE,iBAAiB;IAE9C,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IA+CpE;;;;OAIG;YACW,oBAAoB;IAsB5B,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAyB/C,OAAO,CAAC,cAAc;CAoBvB;AAED,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,CAAC"}

package/task/helpers/in-process-task-runner.d.ts

@@ -0,0 +1,28 @@
+/**
+ * In-process task runner — dispatches the task via a microtask on the current
+ * Node event loop. The default runner for long-lived servers.
+ *
+ * @module task/helpers/in-process-task-runner
+ */
+import type { FrontMcpLogger } from '../../common';
+import type { TaskStore } from '../store';
+import type { TaskRegistry } from '../task.registry';
+import type { TaskRecord } from '../task.types';
+import type { TaskNotifier } from './task-notifier';
+import { type TaskRunnerScope } from './task-runner';
+import type { SpawnContext, TaskRunner } from './task-runner.types';
+export interface InProcessTaskRunnerDeps {
+    scope: TaskRunnerScope;
+    store: TaskStore;
+    registry: TaskRegistry;
+    notifier: TaskNotifier;
+    logger?: FrontMcpLogger;
+}
+export declare class InProcessTaskRunner implements TaskRunner {
+    private readonly deps;
+    readonly kind: "in-process";
+    constructor(deps: InProcessTaskRunnerDeps);
+    run(record: TaskRecord, context: SpawnContext): Promise<void>;
+    cancel(record: TaskRecord): Promise<void>;
+}
+//# sourceMappingURL=in-process-task-runner.d.ts.map

package/task/helpers/in-process-task-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-process-task-runner.d.ts","sourceRoot":"","sources":["../../../src/task/helpers/in-process-task-runner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAuB,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEpE,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAED,qBAAa,mBAAoB,YAAW,UAAU;IAGxC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,QAAQ,CAAC,IAAI,EAAG,YAAY,CAAU;gBAET,IAAI,EAAE,uBAAuB;IAEpD,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB7D,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAIhD"}

package/task/helpers/process-liveness.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Cross-platform process liveness probe.
+ *
+ * `process.kill(pid, 0)` is the canonical "is this PID alive" check on POSIX.
+ * It sends no signal but throws `ESRCH` if the PID is gone. Windows also
+ * supports it via Node's `process.kill` polyfill (reports the target's
+ * existence via the same error semantics).
+ *
+ * Used by `CliTaskRunner.cancel` and by `SqliteTaskStore` orphan detection to
+ * decide whether a `working`/`input_required` task is still being executed.
+ *
+ * @module task/helpers/process-liveness
+ */
+/** Returns `true` if a process with the given PID is alive and accessible. */
+export declare function isAlive(pid: number): boolean;
+//# sourceMappingURL=process-liveness.d.ts.map

package/task/helpers/process-liveness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-liveness.d.ts","sourceRoot":"","sources":["../../../src/task/helpers/process-liveness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,8EAA8E;AAC9E,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAY5C"}

package/task/helpers/task-id.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Task ID generation — cryptographically secure per MCP spec §Security.
+ *
+ * Uses `randomUUID()` from `@frontmcp/utils` for cross-platform (Node/browser)
+ * consistency, as required by `CLAUDE.md` "Crypto Utilities".
+ *
+ * @module task/helpers/task-id
+ */
+export declare function generateTaskId(): string;
+//# sourceMappingURL=task-id.d.ts.map

package/task/helpers/task-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-id.d.ts","sourceRoot":"","sources":["../../../src/task/helpers/task-id.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,wBAAgB,cAAc,IAAI,MAAM,CAEvC"}

package/task/helpers/task-notifier.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Task status notifier — bridges TaskRecord state transitions to
+ * `notifications/tasks/status` delivery via the SDK notification service.
+ *
+ * Per spec §Task Notifications, the notification MUST carry the full Task
+ * wire shape, and SHOULD NOT include `io.modelcontextprotocol/related-task`
+ * in `_meta` (the `taskId` field on the params is the source of truth).
+ *
+ * @module task/helpers/task-notifier
+ */
+import type { FrontMcpLogger } from '../../common';
+import type { NotificationService } from '../../notification/notification.service';
+import { type TaskRecord } from '../task.types';
+export declare class TaskNotifier {
+    private readonly notifications;
+    private readonly logger?;
+    constructor(notifications: NotificationService, logger?: FrontMcpLogger | undefined);
+    sendStatus(record: TaskRecord): void;
+}
+//# sourceMappingURL=task-notifier.d.ts.map

package/task/helpers/task-notifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-notifier.d.ts","sourceRoot":"","sources":["../../../src/task/helpers/task-notifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AACnF,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAE7D,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;gBADP,aAAa,EAAE,mBAAmB,EAClC,MAAM,CAAC,EAAE,cAAc,YAAA;IAG1C,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;CAkBrC"}

package/task/helpers/task-runner.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Task runner — executes a `tools/call` request in the background and records
+ * its terminal outcome.
+ *
+ * Called synchronously (fire-and-forget) from the task-creation path in the
+ * existing `tools:call-tool` flow. The outer HTTP request will already have
+ * returned the `CreateTaskResult` by the time this resumes.
+ *
+ * Runtime approach: we re-dispatch the underlying `tools/call` request through
+ * `scope.runFlowForOutput('tools:call-tool', ...)` with the `task` field
+ * stripped so the flow executes the tool normally. Any result or thrown error
+ * is captured into a TaskOutcome and written to the store as a terminal state.
+ *
+ * Cross-node cancel: we subscribe to the cancel channel for the duration of
+ * execution. If a cancel is signalled, the AbortController fires, which the
+ * tool is expected to observe through the standard execution context.
+ *
+ * @module task/helpers/task-runner
+ */
+import type { FrontMcpLogger } from '../../common';
+import type { TaskStore } from '../store';
+import type { TaskRegistry } from '../task.registry';
+import { type TaskRecord } from '../task.types';
+import type { TaskNotifier } from './task-notifier';
+/** Narrow interface over scope to avoid circular type import. */
+export interface TaskRunnerScope {
+    runFlowForOutput<TInput = unknown, TOutput = unknown>(name: 'tools:call-tool', input: TInput): Promise<TOutput>;
+}
+export interface RunTaskParams {
+    /** Persisted record (already stored in status `working`). */
+    record: TaskRecord;
+    /** Raw request params AFTER removing the `task` field, to pass to the flow. */
+    cleanedRequestParams: Record<string, unknown>;
+    /** The original request handler context (carries authInfo etc.). */
+    ctx: unknown;
+    scope: TaskRunnerScope;
+    store: TaskStore;
+    registry: TaskRegistry;
+    notifier: TaskNotifier;
+    logger?: FrontMcpLogger;
+}
+/**
+ * Schedule background execution and return immediately. The returned Promise
+ * resolves once the task reaches a terminal state — primarily useful in tests.
+ */
+export declare function runTaskInBackground(params: RunTaskParams): Promise<void>;
+//# sourceMappingURL=task-runner.d.ts.map

package/task/helpers/task-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-runner.d.ts","sourceRoot":"","sources":["../../../src/task/helpers/task-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAqC,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AACnF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,iEAAiE;AACjE,MAAM,WAAW,eAAe;IAC9B,gBAAgB,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACjH;AAED,MAAM,WAAW,aAAa;IAC5B,6DAA6D;IAC7D,MAAM,EAAE,UAAU,CAAC;IACnB,+EAA+E;IAC/E,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9C,oEAAoE;IACpE,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAIxE"}

package/task/helpers/task-runner.types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Runner abstraction — picks how a task-augmented `tools/call` actually gets
+ * executed. Long-lived Node servers use the in-process runner (a microtask
+ * dispatch). CLI hosts spawn a detached child process so the work survives
+ * the short-lived parent.
+ *
+ * @module task/helpers/task-runner.types
+ */
+import type { TaskRecord } from '../task.types';
+export interface SpawnContext {
+    /** Raw request params after stripping the `task` field, passed to the tool. */
+    cleanedRequestParams: Record<string, unknown>;
+    /** Original request handler context (carries authInfo etc.). */
+    ctx: unknown;
+}
+export interface TaskRunner {
+    readonly kind: 'in-process' | 'cli';
+    /**
+     * Start executing `record`. Implementations are fire-and-forget — the promise
+     * resolves once execution has been *scheduled*, not completed. A successful
+     * resolve does NOT mean the task is done; state transitions are persisted via
+     * the TaskStore.
+     */
+    run(record: TaskRecord, context: SpawnContext): Promise<void>;
+    /**
+     * Attempt to cancel execution of a record. Called from `tasks/cancel` after
+     * the store transition to `cancelled` has already been written. Implementations
+     * should be idempotent and tolerate absent executors.
+     */
+    cancel(record: TaskRecord): Promise<void>;
+}
+//# sourceMappingURL=task-runner.types.d.ts.map

package/task/helpers/task-runner.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-runner.types.d.ts","sourceRoot":"","sources":["../../../src/task/helpers/task-runner.types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,WAAW,YAAY;IAC3B,+EAA+E;IAC/E,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9C,gEAAgE;IAChE,GAAG,EAAE,OAAO,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,KAAK,CAAC;IAEpC;;;;;OAKG;IACH,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9D;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C"}

package/task/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @frontmcp/sdk task module — MCP 2025-11-25 background tasks support.
+ *
+ * See: https://modelcontextprotocol.io/specification/2025-11-25/basic/utilities/tasks
+ *
+ * @module task
+ */
+export * from './task.types';
+export * from './store';
+export { TaskRegistry, type TaskCapabilityInputs } from './task.registry';
+export { computeTaskCapabilities } from './task-scope.helper';
+export { TaskNotifier } from './helpers/task-notifier';
+export { generateTaskId } from './helpers/task-id';
+export { runTaskInBackground, type RunTaskParams, type TaskRunnerScope } from './helpers/task-runner';
+export type { TaskRunner, SpawnContext } from './helpers/task-runner.types';
+export { InProcessTaskRunner, type InProcessTaskRunnerDeps } from './helpers/in-process-task-runner';
+export { CliTaskRunner, type CliTaskRunnerDeps, type CliTaskRunnerCommand, RUN_TASK_SUBCOMMAND, RUN_TASK_ENV_VAR, } from './helpers/cli-task-runner';
+export { isAlive } from './helpers/process-liveness';
+export { isTaskWorkerProcess, TASK_WORKER_MODE_FLAG } from './runtime/execute-task-flag';
+export { default as TasksGetFlow } from './flows/tasks-get.flow';
+export { default as TasksResultFlow } from './flows/tasks-result.flow';
+export { default as TasksCancelFlow } from './flows/tasks-cancel.flow';
+export { default as TasksListFlow } from './flows/tasks-list.flow';
+//# sourceMappingURL=index.d.ts.map

package/task/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/task/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACtG,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,mBAAmB,EAAE,KAAK,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AACrG,OAAO,EACL,aAAa,EACb,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAKrD,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEzF,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,yBAAyB,CAAC"}

package/task/runtime/execute-task-flag.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Small helpers for the task-worker mode that can be safely imported by any
+ * layer without pulling the full FrontMcpInstance graph (which would otherwise
+ * create a cycle via scope → transport → task → execute-task → front-mcp).
+ *
+ * @module task/runtime/execute-task-flag
+ */
+export declare const TASK_WORKER_MODE_FLAG: "__taskWorkerMode";
+/** True when this process was launched as a task worker. */
+export declare function isTaskWorkerProcess(): boolean;
+//# sourceMappingURL=execute-task-flag.d.ts.map

package/task/runtime/execute-task-flag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-task-flag.d.ts","sourceRoot":"","sources":["../../../src/task/runtime/execute-task-flag.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,eAAO,MAAM,qBAAqB,EAAG,kBAA2B,CAAC;AAEjE,4DAA4D;AAC5D,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C"}

package/task/runtime/execute-task.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Task-worker entrypoint.
+ *
+ * Called by the `__run-task <taskId>` CLI subcommand. Loads the user's
+ * FrontMCP config, boots a minimal scope (no HTTP transport), looks up the
+ * pending task record, runs the tool through the same flow pipeline the
+ * Node server would, and exits.
+ *
+ * The FRONTMCP_RUN_TASK_ID environment variable is set by the parent's
+ * `CliTaskRunner` so this module (and `scope.instance.ts`) can detect it is
+ * being invoked as a worker rather than as a long-lived server.
+ *
+ * @module task/runtime/execute-task
+ */
+import { type FrontMcpConfigInput } from '../../common';
+/**
+ * Boot the user's FrontMCP config in task-worker mode and run a single task
+ * to completion. Returns the exit code the worker should use.
+ */
+export declare function executeTaskWorker(options: FrontMcpConfigInput, taskId: string): Promise<number>;
+//# sourceMappingURL=execute-task.d.ts.map

package/task/runtime/execute-task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-task.d.ts","sourceRoot":"","sources":["../../../src/task/runtime/execute-task.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAA0B,KAAK,mBAAmB,EAAuB,MAAM,cAAc,CAAC;AASrG;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA0HrG"}

package/task/store/index.d.ts

@@ -0,0 +1,4 @@
+export type { TaskStore, TaskTerminalCallback, TaskCancelCallback, TaskUnsubscribe, TaskListPage } from './task.store';
+export { StorageTaskStore } from './storage-task.store';
+export { createTaskStore, createMemoryTaskStore, TaskStoreNotSupportedError, type TaskStoreOptions, type TaskStoreResult, } from './task-store.factory';
+//# sourceMappingURL=index.d.ts.map

package/task/store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/task/store/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACvH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,0BAA0B,EAC1B,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,sBAAsB,CAAC"}

package/task/store/storage-task.store.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Storage-backed TaskStore implementation.
+ *
+ * Uses `@frontmcp/utils` storage abstractions (memory / Redis / Upstash) with
+ * automatic TTL, key namespacing, and pub/sub for cross-node signalling.
+ *
+ * Key layout (under the store's NamespacedStorage):
+ *  - `records:{sessionId}:{taskId}` — the TaskRecord JSON
+ *  - Pub/sub channels:
+ *      - `terminal:{taskId}` — fires when a task reaches terminal status
+ *      - `cancel:{taskId}`   — fires when a task is asked to cancel
+ *
+ * @module task/store/storage-task.store
+ */
+import { type NamespacedStorage } from '@frontmcp/utils';
+import { type FrontMcpLogger } from '../../common';
+import { type TaskRecord } from '../task.types';
+import type { TaskCancelCallback, TaskListPage, TaskStore, TaskTerminalCallback, TaskUnsubscribe } from './task.store';
+export declare class StorageTaskStore implements TaskStore {
+    private readonly storage;
+    private readonly records;
+    private readonly logger?;
+    private readonly terminalCallbacks;
+    private readonly terminalSubs;
+    private readonly cancelCallbacks;
+    private readonly cancelSubs;
+    constructor(storage: NamespacedStorage, logger?: FrontMcpLogger);
+    create(record: TaskRecord): Promise<void>;
+    get(taskId: string, sessionId: string): Promise<TaskRecord | null>;
+    update(taskId: string, sessionId: string, patch: Partial<TaskRecord>): Promise<TaskRecord | null>;
+    delete(taskId: string, sessionId: string): Promise<void>;
+    list(sessionId: string, opts?: {
+        cursor?: string;
+        pageSize?: number;
+    }): Promise<TaskListPage>;
+    subscribeTerminal(taskId: string, _sessionId: string, cb: TaskTerminalCallback): Promise<TaskUnsubscribe>;
+    publishTerminal(record: TaskRecord): Promise<void>;
+    subscribeCancel(taskId: string, _sessionId: string, cb: TaskCancelCallback): Promise<TaskUnsubscribe>;
+    publishCancel(taskId: string, _sessionId: string): Promise<void>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=storage-task.store.d.ts.map

package/task/store/storage-task.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-task.store.d.ts","sourceRoot":"","sources":["../../../src/task/store/storage-task.store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAKL,KAAK,iBAAiB,EAEvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,SAAS,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAYvH,qBAAa,gBAAiB,YAAW,SAAS;IAChD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IACnD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAiB;IAEzC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAgD;IAClF,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkC;IAC/D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA8C;IAC9E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkC;gBAEjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,cAAc;IAMzD,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAazC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAalE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAqBjG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxD,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,YAAY,CAAC;IA8BjG,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,CAAC;IAsDzG,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BlD,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC;IA2CrG,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuChE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAoB/B"}