@frontmcp/sdk 1.0.3 → 1.1.0-beta.1

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

@@ -0,0 +1,58 @@
+/**
+ * TaskStore factory — mirrors the elicitation-store factory pattern.
+ *
+ * Auto-detects the storage backend from config / env. Memory is the default
+ * for single-node / development; Redis or Upstash is required for multi-node
+ * deployments (both support pub/sub for cross-node terminal/cancel routing).
+ *
+ * Vercel KV is not supported (no pub/sub), matching the elicitation store.
+ *
+ * @module task/store/task-store.factory
+ */
+import { type RootStorage, type StorageConfig } from '@frontmcp/utils';
+import { type FrontMcpLogger, type RedisOptionsInput } from '../../common';
+import { type TaskStore } from './task.store';
+export declare class TaskStoreNotSupportedError extends Error {
+    constructor(message: string);
+}
+export interface TaskStoreOptions {
+    /** Storage config (@frontmcp/utils shape). */
+    storage?: StorageConfig;
+    /** Convenience: legacy redis option, mapped into `storage` when `storage` is absent. */
+    redis?: RedisOptionsInput;
+    /** Key prefix for all task keys. Default `mcp:task:`. */
+    keyPrefix?: string;
+    /** Logger. */
+    logger?: FrontMcpLogger;
+    /** Edge runtime mode — requires distributed storage. */
+    isEdgeRuntime?: boolean;
+    /**
+     * SQLite backend options. When provided, the factory returns a
+     * `SqliteTaskStore` instead of the utils-backed implementation.
+     * Required for cross-invocation persistence in CLI mode.
+     */
+    sqlite?: {
+        path: string;
+        encryption?: {
+            secret: string;
+        };
+        walMode?: boolean;
+        ttlCleanupIntervalMs?: number;
+    };
+}
+export interface TaskStoreResult {
+    store: TaskStore;
+    type: 'memory' | 'redis' | 'upstash' | 'sqlite' | 'auto';
+    /**
+     * Underlying storage instance (not populated for the SQLite backend, which
+     * manages its own Database connection internally).
+     */
+    storage?: RootStorage;
+}
+export declare function createTaskStore(options?: TaskStoreOptions): Promise<TaskStoreResult>;
+/** Synchronous memory-backed factory, primarily for tests. */
+export declare function createMemoryTaskStore(options?: {
+    keyPrefix?: string;
+    logger?: FrontMcpLogger;
+}): TaskStoreResult;
+//# sourceMappingURL=task-store.factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"task-store.factory.d.ts","sourceRoot":"","sources":["../../../src/task/store/task-store.factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAA8C,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEnH,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAE3E,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,qBAAa,0BAA2B,SAAQ,KAAK;gBACvC,OAAO,EAAE,MAAM;CAI5B;AAED,MAAM,WAAW,gBAAgB;IAC/B,8CAA8C;IAC9C,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,wFAAwF;IACxF,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc;IACd,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,wDAAwD;IACxD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,MAAM,CAAC,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,CAAC,EAAE;YAAE,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;QAChC,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,oBAAoB,CAAC,EAAE,MAAM,CAAC;KAC/B,CAAC;CACH;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;IACzD;;;OAGG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB;AAyBD,wBAAsB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,eAAe,CAAC,CA4F9F;AAED,8DAA8D;AAC9D,wBAAgB,qBAAqB,CAAC,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,cAAc,CAAA;CAAO,GAAG,eAAe,CAIpH"}

package/task/store/task.store.d.ts

@@ -0,0 +1,76 @@
+/**
+ * TaskStore interface — abstraction over persistent state for MCP background tasks.
+ *
+ * Mirrors the elicitation store design: reads/writes + pub/sub for cross-node
+ * result unblocking and cancel signaling.
+ *
+ * @module task/store/task.store
+ */
+import type { TaskRecord } from '../task.types';
+/** Callback invoked when a task reaches a terminal status. */
+export type TaskTerminalCallback = (record: TaskRecord) => void;
+/** Callback invoked when a task has been asked to cancel. */
+export type TaskCancelCallback = () => void;
+/** Unsubscribe handle returned by subscribe* methods. */
+export type TaskUnsubscribe = () => Promise<void>;
+/** Result of a paginated list operation. */
+export interface TaskListPage {
+    tasks: TaskRecord[];
+    nextCursor?: string;
+}
+export interface TaskStore {
+    /**
+     * Persist a newly-created task record. The store SHOULD honor `expiresAt`
+     * as TTL for automatic cleanup. Must fail if a record with the same
+     * `taskId` already exists (taskId collisions are a bug upstream).
+     */
+    create(record: TaskRecord): Promise<void>;
+    /**
+     * Fetch a task record. Returns `null` if:
+     *  - the task does not exist
+     *  - the task has expired
+     *  - `sessionId` does not match the record's session (hard auth binding)
+     */
+    get(taskId: string, sessionId: string): Promise<TaskRecord | null>;
+    /**
+     * Apply a partial patch. Returns the updated record, or `null` if the task
+     * no longer exists / belongs to a different session. Implementations should
+     * treat this as a read-modify-write (no external CAS requirement).
+     */
+    update(taskId: string, sessionId: string, patch: Partial<TaskRecord>): Promise<TaskRecord | null>;
+    /**
+     * Delete a task record. No-op if not found.
+     */
+    delete(taskId: string, sessionId: string): Promise<void>;
+    /**
+     * List tasks owned by `sessionId`, paginated.
+     * Cursor format is opaque to callers; implementations define their own.
+     */
+    list(sessionId: string, opts?: {
+        cursor?: string;
+        pageSize?: number;
+    }): Promise<TaskListPage>;
+    /**
+     * Subscribe for a one-shot terminal notification on the given task.
+     * Called once the store observes a terminal status.
+     */
+    subscribeTerminal(taskId: string, sessionId: string, cb: TaskTerminalCallback): Promise<TaskUnsubscribe>;
+    /**
+     * Publish a terminal state change. MUST be called after the backing record
+     * has been updated to a terminal status.
+     */
+    publishTerminal(record: TaskRecord): Promise<void>;
+    /**
+     * Subscribe for cancellation signals. Used by the node running the task to
+     * react to a `tasks/cancel` that arrived at a different node.
+     */
+    subscribeCancel(taskId: string, sessionId: string, cb: TaskCancelCallback): Promise<TaskUnsubscribe>;
+    /**
+     * Broadcast a cancellation signal. The authoritative state transition to
+     * `cancelled` still happens in the flow layer via `update()`.
+     */
+    publishCancel(taskId: string, sessionId: string): Promise<void>;
+    /** Optional teardown hook called during server shutdown. */
+    destroy?(): Promise<void>;
+}
+//# sourceMappingURL=task.store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"task.store.d.ts","sourceRoot":"","sources":["../../../src/task/store/task.store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,8DAA8D;AAC9D,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;AAEhE,6DAA6D;AAC7D,MAAM,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC;AAE5C,yDAAyD;AACzD,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAElD,4CAA4C;AAC5C,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1C;;;;;OAKG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IAEnE;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IAElG;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzD;;;OAGG;IACH,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAE9F;;;OAGG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAEzG;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnD;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAErG;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhE,4DAA4D;IAC5D,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B"}

package/task/task-scope.helper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Scope-level helper for projecting the `tasks` server capability.
+ *
+ * Computed inputs:
+ *  - `hasTaskEnabledTool` — any tool with `execution.taskSupport != 'forbidden'`.
+ *  - `canIdentifyRequestors` — scope has auth configured (so per-session
+ *    binding is enforceable, gating the optional `tasks.list` capability).
+ *
+ * Kept here (and not on the scope class) so transport adapters that build
+ * capabilities inline (local adapter, in-memory server) can reuse the same
+ * logic without depending on TaskRegistry internals.
+ *
+ * @module task/task-scope.helper
+ */
+import type { ServerCapabilities } from '@frontmcp/protocol';
+import type { ScopeEntry } from '../common';
+export declare function computeTaskCapabilities(scope: ScopeEntry): Partial<ServerCapabilities>;
+//# sourceMappingURL=task-scope.helper.d.ts.map

package/task/task-scope.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-scope.helper.d.ts","sourceRoot":"","sources":["../../src/task/task-scope.helper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAYtF"}

package/task/task.registry.d.ts

@@ -0,0 +1,68 @@
+/**
+ * TaskRegistry — in-process bookkeeping for background task execution.
+ *
+ * Responsibilities:
+ *  - Track AbortControllers for tasks currently running on this node so that
+ *    `tasks/cancel` can signal them synchronously without a round-trip.
+ *  - Compute the server's `tasks` capability for the MCP `initialize` response.
+ *
+ * Cross-node cancel signalling (when the cancel request lands on a different
+ * node than the one running the task) is handled by `TaskStore.subscribeCancel`
+ * + `publishCancel`, which is wired in `task-runner.ts`.
+ *
+ * @module task/task.registry
+ */
+import type { ServerCapabilities } from '@frontmcp/protocol';
+import type { FrontMcpLogger } from '../common';
+import type { TaskRunner } from './helpers/task-runner.types';
+import type { TasksConfig } from './task.types';
+/**
+ * Snapshot the registry uses to decide whether to advertise the `tasks`
+ * capability. Kept minimal so it can be refreshed cheaply when tool metadata
+ * changes.
+ */
+export interface TaskCapabilityInputs {
+    /**
+     * Whether any currently-registered tool declares `execution.taskSupport` other
+     * than `'forbidden'`. When false, the server does not advertise task support.
+     */
+    hasTaskEnabledTool: boolean;
+    /**
+     * Whether the current auth context can identify requestors. When false, the
+     * `tasks.list` capability is suppressed per spec §Security.
+     */
+    canIdentifyRequestors: boolean;
+}
+export declare class TaskRegistry {
+    private readonly abortControllers;
+    private readonly logger?;
+    private readonly config;
+    private _runner?;
+    constructor(config?: TasksConfig, logger?: FrontMcpLogger);
+    /** Assign the runner used to execute task-augmented tool calls. */
+    setRunner(runner: TaskRunner): void;
+    /** Current runner (in-process or CLI), set by the scope during init. */
+    get runner(): TaskRunner | undefined;
+    /** Register an AbortController for a running task on this node. */
+    trackRunning(taskId: string): AbortController;
+    /** Untrack a task once it leaves `working`/`input_required`. */
+    untrack(taskId: string): void;
+    /** Returns true if the task is running on this node and abort was fired. */
+    abort(taskId: string, reason?: string): boolean;
+    /** Count currently running tasks (for limits checks). */
+    runningCount(): number;
+    /** Access the tasks config for defaults/limits. */
+    getConfig(): TasksConfig;
+    /**
+     * Compute the MCP server capabilities contribution for tasks per
+     * 2025-11-25 §Capabilities.
+     *
+     * Advertises:
+     *   - `tasks.requests.tools.call` — when any tool declares taskSupport.
+     *   - `tasks.cancel` — always, when the feature is enabled.
+     *   - `tasks.list` — only when requestors can be identified (otherwise
+     *     listing would leak task metadata per spec §Security).
+     */
+    getCapabilities(inputs: TaskCapabilityInputs): Partial<ServerCapabilities>;
+}
+//# sourceMappingURL=task.registry.d.ts.map

package/task/task.registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.registry.d.ts","sourceRoot":"","sources":["../../src/task/task.registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,qBAAqB,EAAE,OAAO,CAAC;CAChC;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsC;IACvE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,OAAO,CAAC,CAAa;gBAEjB,MAAM,GAAE,WAAgB,EAAE,MAAM,CAAC,EAAE,cAAc;IAK7D,mEAAmE;IACnE,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAInC,wEAAwE;IACxE,IAAI,MAAM,IAAI,UAAU,GAAG,SAAS,CAEnC;IAED,mEAAmE;IACnE,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe;IAM7C,gEAAgE;IAChE,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI7B,4EAA4E;IAC5E,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO;IAc/C,yDAAyD;IACzD,YAAY,IAAI,MAAM;IAItB,mDAAmD;IACnD,SAAS,IAAI,WAAW;IAIxB;;;;;;;;;OASG;IACH,eAAe,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAY3E"}

package/task/task.types.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Task types for MCP 2025-11-25 background tasks support.
+ *
+ * See: https://modelcontextprotocol.io/specification/2025-11-25/basic/utilities/tasks
+ *
+ * All protocol-facing Zod schemas are re-exported from `@frontmcp/protocol`,
+ * which is the single boundary between FrontMCP internals and the upstream
+ * MCP protocol package. This module defines the server-side record shape
+ * used by the TaskStore and runtime.
+ *
+ * @module task/task.types
+ */
+import type { CallToolResult, TaskStatus } from '@frontmcp/protocol';
+import type { RedisOptionsInput } from '../common';
+/**
+ * Default task configuration values, used when the server doesn't set them
+ * and clients don't request specific values.
+ */
+export declare const TASK_DEFAULTS: {
+    readonly defaultTtlMs: 3600000;
+    readonly maxTtlMs: 86400000;
+    readonly defaultPollIntervalMs: 2000;
+    readonly maxConcurrentPerSession: 16;
+};
+/**
+ * The `io.modelcontextprotocol/related-task` _meta key per MCP spec.
+ */
+export declare const RELATED_TASK_META_KEY: "io.modelcontextprotocol/related-task";
+/**
+ * The JSON-RPC shape we persist when the underlying request completed with an
+ * error. `tasks/result` MUST return exactly this error to the client.
+ */
+export interface TaskJsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/**
+ * Terminal outcome of a task, captured once the underlying request finishes.
+ * `kind` discriminates between a successful result payload (for a tools/call task
+ * this is a `CallToolResult`) and a JSON-RPC error.
+ */
+export type TaskOutcome = {
+    kind: 'ok';
+    data: CallToolResult;
+} | {
+    kind: 'error';
+    error: TaskJsonRpcError;
+};
+/**
+ * The record persisted in the TaskStore. Keyed by `(sessionId, taskId)`.
+ *
+ * `status` follows the MCP lifecycle: `working` ↔ `input_required` → terminal
+ * (`completed` | `failed` | `cancelled`). Transitions are enforced at the
+ * flow/runtime layer, not by the store.
+ */
+export interface TaskRecord {
+    /** Cryptographically-secure, receiver-generated identifier. */
+    taskId: string;
+    /** Auth context binding — tasks are only visible within their owning session. */
+    sessionId: string;
+    /** Current state of the task execution. */
+    status: TaskStatus;
+    /** Optional human-readable status string (used for failures, cancellations). */
+    statusMessage?: string;
+    /** ISO 8601 timestamp when the task was created. */
+    createdAt: string;
+    /** ISO 8601 timestamp of the last state transition. */
+    lastUpdatedAt: string;
+    /**
+     * Task lifetime in milliseconds from creation. `null` means unlimited (server
+     * may still delete at its discretion). The receiver MAY clamp a client's
+     * requested TTL down to `TasksConfig.maxTtlMs`.
+     */
+    ttlMs: number | null;
+    /** Suggested polling interval in milliseconds (hint to the client). */
+    pollIntervalMs?: number;
+    /** Absolute epoch ms after which the store may delete this record. */
+    expiresAt: number;
+    /**
+     * The JSON-RPC method + params this task is wrapping. Only `tools/call` is
+     * supported in this iteration (see roadmap).
+     */
+    request: {
+        method: 'tools/call';
+        params: Record<string, unknown>;
+    };
+    /**
+     * Populated once `status` reaches a terminal state. Undefined while the task
+     * is `working` or `input_required`.
+     */
+    outcome?: TaskOutcome;
+    /**
+     * Progress token carried from the request's `_meta`. Remains valid for the
+     * duration of the task per spec.
+     */
+    progressToken?: string | number;
+    /**
+     * Identifies the runtime executing the task so we can orphan-detect and
+     * cross-process cancel.
+     *
+     * - `host: 'in-process'` — the same Node server that created the task.
+     * - `host: 'cli'`        — a detached child process spawned by `CliTaskRunner`.
+     *   `pid` is the child's PID; `spawnedAt` the launch timestamp.
+     */
+    executor?: {
+        host: 'in-process' | 'cli';
+        pid?: number;
+        spawnedAt?: string;
+    };
+}
+/**
+ * Projection of a TaskRecord to the MCP `Task` wire shape (what `tasks/get`,
+ * `tasks/list`, and `CreateTaskResult.task` return).
+ */
+export interface TaskWireShape {
+    taskId: string;
+    status: TaskStatus;
+    ttl: number | null;
+    createdAt: string;
+    lastUpdatedAt: string;
+    pollInterval?: number;
+    statusMessage?: string;
+}
+export declare function toWireShape(record: TaskRecord): TaskWireShape;
+export declare function isTerminal(status: TaskStatus): boolean;
+/**
+ * Server-side configuration for the tasks subsystem. Wired in `@FrontMcp({ tasks: ... })`.
+ */
+export interface TasksConfig {
+    /** Enable tasks. Defaults to true when any tool declares execution.taskSupport. */
+    enabled?: boolean;
+    /** Default TTL (ms) when the client doesn't request one. */
+    defaultTtlMs?: number;
+    /** Hard cap on TTL; client-requested values above this are clamped down. */
+    maxTtlMs?: number;
+    /** Suggested poll interval reported to clients. */
+    defaultPollIntervalMs?: number;
+    /** Maximum concurrent task records per session. */
+    maxConcurrentPerSession?: number;
+    /** Key prefix for the store. Default: 'mcp:task:'. */
+    keyPrefix?: string;
+    /**
+     * Redis/Upstash backend options. When set, the task store is backed by the
+     * `@frontmcp/utils` storage abstraction in pub/sub-capable mode, suitable for
+     * multi-node HA deployments. Mutually exclusive with `sqlite`.
+     */
+    redis?: RedisOptionsInput;
+    /**
+     * Throw at startup instead of warning when the runtime cannot run tasks
+     * reliably (edge/serverless with the in-process runner). Default `false`.
+     */
+    strict?: boolean;
+    /**
+     * Runner selection:
+     *  - `'in-process'` (default): tasks run on the current Node event loop.
+     *    Ideal for long-lived servers.
+     *  - `'cli'`: tasks run in a detached child process spawned by the current
+     *    executable. Required when the parent process cannot guarantee it'll
+     *    outlive the task (short-lived CLI hosts, per-request serverless with
+     *    a queue fronting it, etc.). MUST pair with a persistent `tasks.sqlite`
+     *    or `tasks.redis` backend so the worker and host can read each other's
+     *    state.
+     */
+    runner?: 'in-process' | 'cli';
+    /**
+     * SQLite task-store options. When set, the task store is backed by SQLite
+     * instead of the default @frontmcp/utils memory/Redis/Upstash storage.
+     * This is the only option that survives across CLI invocations.
+     */
+    sqlite?: {
+        /** Path to the SQLite database file. */
+        path: string;
+        /** Optional encryption secret (derives AES-256 key). */
+        encryption?: {
+            secret: string;
+        };
+        /** Enable WAL journal mode. Default: `true`. */
+        walMode?: boolean;
+        /** Periodic TTL cleanup interval in ms. Default: 60000. */
+        ttlCleanupIntervalMs?: number;
+    };
+    /**
+     * Command used by the CLI task runner to spawn detached child processes.
+     * When unset, the runner attempts to re-invoke the currently-running
+     * executable (`process.argv[0]` + `process.argv[1]`).
+     *
+     * Override when the FrontMCP entrypoint isn't on the default argv — e.g.,
+     * in tests or bundled CLI distributions.
+     *
+     * Example:
+     * ```ts
+     * cliRunnerCommand: { exe: 'node', args: ['./dist/server.js'] }
+     * ```
+     */
+    cliRunnerCommand?: {
+        exe: string;
+        args?: string[];
+    };
+}
+//# sourceMappingURL=task.types.d.ts.map

package/task/task.types.d.ts.map

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