@absolutejs/mcp 0.5.0 → 0.6.0

package/README.md

@@ -50,6 +50,13 @@ tasks: {
 }
 ```
 
+For multi-instance production deployments, use
+`createPostgresMcpTaskStore()` and `createPostgresMcpSessionStore()` after
+applying `mcpPostgresSchemaSql()`. Task updates and cancellation protect
+terminal states in the database, task reads enforce TTL, and session access
+atomically extends only unexpired sessions. The adapters accept a structural
+SQL client and do not require a particular PostgreSQL driver.
+
 Nothing here depends on a model. The tool shape is structurally compatible with
 [`@absolutejs/ai`](https://github.com/absolutejs/ai)'s `AIToolMap`, so an AI tool
 registry serves over MCP without conversion — but any typed tool registry works.

package/dist/index.js

@@ -1129,15 +1129,98 @@ var mcpServer = (config) => {
   const app = config.serveRootMetadata ? base.get(ROOT_METADATA_PATH, () => metadataResponse(config)) : base;
   return app;
 };
+// src/postgres.ts
+var namespaceOf = (namespace) => {
+  if (!/^[a-z_][a-z0-9_]*$/.test(namespace))
+    throw new Error("MCP PostgreSQL namespace must be a simple identifier");
+  return namespace;
+};
+var mcpPostgresSchemaSql = (namespace = "mcp") => {
+  const ns = namespaceOf(namespace);
+  return `CREATE SCHEMA IF NOT EXISTS ${ns};
+CREATE TABLE IF NOT EXISTS ${ns}.tasks (
+  task_id text PRIMARY KEY,
+  authorization_key text NOT NULL,
+  status text NOT NULL CHECK (status IN ('working','input_required','completed','failed','cancelled')),
+  created_at timestamptz NOT NULL,
+  updated_at timestamptz NOT NULL,
+  expires_at timestamptz,
+  data jsonb NOT NULL
+);
+CREATE INDEX IF NOT EXISTS tasks_authorization_updated_idx ON ${ns}.tasks (authorization_key, updated_at DESC);
+CREATE INDEX IF NOT EXISTS tasks_expiry_idx ON ${ns}.tasks (expires_at) WHERE expires_at IS NOT NULL;
+CREATE TABLE IF NOT EXISTS ${ns}.sessions (
+  session_id text PRIMARY KEY,
+  can_elicit boolean NOT NULL,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  last_seen_at timestamptz NOT NULL DEFAULT now(),
+  expires_at timestamptz NOT NULL
+);
+CREATE INDEX IF NOT EXISTS sessions_expiry_idx ON ${ns}.sessions (expires_at);`;
+};
+var createPostgresMcpTaskStore = ({
+  client,
+  namespace = "mcp",
+  now = () => new Date
+}) => {
+  const ns = namespaceOf(namespace);
+  return {
+    cancel: async (taskId) => {
+      const updatedAt = now().toISOString();
+      await client.query(`UPDATE ${ns}.tasks SET status = 'cancelled', updated_at = $2::timestamptz, data = data || $3::jsonb WHERE task_id = $1 AND status NOT IN ('cancelled','completed','failed')`, [taskId, updatedAt, JSON.stringify({ lastUpdatedAt: updatedAt, status: "cancelled" })]);
+    },
+    get: async (taskId) => (await client.query(`SELECT data FROM ${ns}.tasks WHERE task_id = $1 AND (expires_at IS NULL OR expires_at > $2::timestamptz)`, [taskId, now().toISOString()])).rows[0]?.data ?? null,
+    save: async (task) => {
+      const expiresAt = task.ttlMs === null ? null : new Date(new Date(task.createdAt).getTime() + task.ttlMs).toISOString();
+      await client.query(`INSERT INTO ${ns}.tasks (task_id, authorization_key, status, created_at, updated_at, expires_at, data) VALUES ($1, $2, $3, $4::timestamptz, $5::timestamptz, $6::timestamptz, $7::jsonb) ON CONFLICT (task_id) DO NOTHING`, [task.taskId, task.authorizationKey, task.status, task.createdAt, task.lastUpdatedAt, expiresAt, JSON.stringify(task)]);
+    },
+    update: async (taskId, update) => {
+      const updatedAt = now().toISOString();
+      const data = { ...update, lastUpdatedAt: updatedAt };
+      const result = await client.query(`UPDATE ${ns}.tasks SET status = COALESCE($2::text, status), updated_at = $3::timestamptz, data = data || $4::jsonb WHERE task_id = $1 AND status NOT IN ('cancelled','completed','failed') RETURNING data`, [taskId, update.status ?? null, updatedAt, JSON.stringify(data)]);
+      if (result.rows[0] !== undefined)
+        return result.rows[0].data;
+      return (await client.query(`SELECT data FROM ${ns}.tasks WHERE task_id = $1`, [taskId])).rows[0]?.data ?? null;
+    }
+  };
+};
+var createPostgresMcpSessionStore = ({
+  client,
+  namespace = "mcp",
+  now = () => new Date,
+  ttlMs = 3600000
+}) => {
+  const ns = namespaceOf(namespace);
+  return {
+    create: async ({ canElicit }) => {
+      const id = crypto.randomUUID();
+      const current = now();
+      await client.query(`INSERT INTO ${ns}.sessions (session_id, can_elicit, created_at, last_seen_at, expires_at) VALUES ($1, $2, $3::timestamptz, $3::timestamptz, $4::timestamptz)`, [id, canElicit, current.toISOString(), new Date(current.getTime() + ttlMs).toISOString()]);
+      return id;
+    },
+    drop: async (id) => {
+      await client.query(`DELETE FROM ${ns}.sessions WHERE session_id = $1`, [id]);
+    },
+    get: async (id) => {
+      const current = now();
+      const result = await client.query(`UPDATE ${ns}.sessions SET last_seen_at = $2::timestamptz, expires_at = $3::timestamptz WHERE session_id = $1 AND expires_at > $2::timestamptz RETURNING can_elicit`, [id, current.toISOString(), new Date(current.getTime() + ttlMs).toISOString()]);
+      const row = result.rows[0];
+      return row === undefined ? null : { canElicit: row.can_elicit };
+    }
+  };
+};
 export {
   verifyBearer,
   publicMcpTask,
   protectedResourceMetadata,
   metadataPathFor,
   mcpServer,
+  mcpPostgresSchemaSql,
   feedbackTools,
   dispatchMcp,
   createSessionRegistry,
+  createPostgresMcpTaskStore,
+  createPostgresMcpSessionStore,
   createMemoryMcpTaskStore,
   createMcpHandler,
   createMcpClient,

package/dist/src/index.d.ts

@@ -39,4 +39,5 @@ export { metadataPathFor, protectedResourceMetadata, type ProtectedResourceMetad
 export { mcpServer } from "./server";
 export { createSessionRegistry, type SessionRegistry } from "./sessions";
 export { createMemoryMcpTaskStore, publicMcpTask } from "./tasks";
+export { createPostgresMcpSessionStore, createPostgresMcpTaskStore, mcpPostgresSchemaSql, type McpSqlClient, type McpSqlResult, } from "./postgres";
 export type { McpAgencyOptions, McpAudioContent, McpElicitAnswer, McpElicitationRequest, McpElicitBus, McpElicitResult, McpSessionStore, McpAuthResult, McpCallGate, McpCallMeta, McpContent, McpImageContent, McpPromptArgument, McpPromptDefinition, McpPrompts, McpResource, McpResourceLink, McpResources, McpServerConfig, McpServerInfo, McpTextContent, McpTask, McpTaskStatus, McpTaskStore, McpTasksOptions, McpTool, McpToolAnnotations, McpToolCallContext, McpToolContext, McpToolRegistry, McpToolResult, McpToolReturn, } from "./types";

package/dist/src/postgres.d.ts

@@ -0,0 +1,20 @@
+import type { McpSessionStore, McpTaskStore } from "./types";
+export type McpSqlResult<Row> = {
+    rowCount: number;
+    rows: ReadonlyArray<Row>;
+};
+export type McpSqlClient = {
+    query: <Row = Record<string, unknown>>(sql: string, parameters?: ReadonlyArray<unknown>) => Promise<McpSqlResult<Row>>;
+};
+export declare const mcpPostgresSchemaSql: (namespace?: string) => string;
+export declare const createPostgresMcpTaskStore: ({ client, namespace, now, }: {
+    client: McpSqlClient;
+    namespace?: string;
+    now?: () => Date;
+}) => McpTaskStore;
+export declare const createPostgresMcpSessionStore: ({ client, namespace, now, ttlMs, }: {
+    client: McpSqlClient;
+    namespace?: string;
+    now?: () => Date;
+    ttlMs?: number;
+}) => McpSessionStore;

package/package.json

@@ -11,7 +11,7 @@
     "elysia": ">=1.1.0"
   },
   "dependencies": {
-    "@absolutejs/agency": "^0.1.0",
+    "@absolutejs/agency": "^0.3.0",
     "@absolutejs/manifest": "^0.2.0",
     "@sinclair/typebox": "^0.34.0"
   },
@@ -58,5 +58,5 @@
     "typecheck": "tsc --noEmit --project tsconfig.json"
   },
   "types": "./dist/src/index.d.ts",
-  "version": "0.5.0"
+  "version": "0.6.0"
 }