@codai/axiom-mcp 2.1.0 → 2.2.0

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { ErrorCode } from "@codai/axiom-schema";
+import { ErrorCode, PlanArtifact, PlanInput } from "@codai/axiom-schema";
 import { z } from "zod";
 import { GuardOptions } from "@codai/axiom-checks";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import "@modelcontextprotocol/sdk/types.js";
+import { McpRequestContext, McpServer } from "@modelcontextprotocol/server";
+import "@modelcontextprotocol/server/stdio";
 //#region src/jsonschema.d.ts
 export declare const SCHEMA_KINDS: readonly ["Plan", "Manifest", "ManifestBundle", "CheckReport", "ApplyResult", "Profile", "Journal", "RepoSnapshot"];
 type SchemaKind = (typeof SCHEMA_KINDS)[number];
@@ -55,6 +55,127 @@ export declare function createRootsPolicy(rootArgs: readonly string[]): Promise<
  */
 export declare function resolveRoot(policy: RootsPolicy, requested?: string): Promise<ResolvedRoot>;
 //#endregion
+//#region src/adapter.d.ts
+/** Wire era a connection/request is served on (`legacy` = 2024-10-07 … 2025-11-25). */
+type WireEra = McpRequestContext["era"];
+//#endregion
+//#region src/tasks.d.ts
+export declare const TASK_STATUSES: readonly ["working", "completed", "failed", "cancelled"];
+type TaskStatus = (typeof TASK_STATUSES)[number];
+/** How long a finished task stays pollable. */
+export declare const TASK_TTL_MS: number;
+/** Advisory poll interval returned to clients. */
+export declare const TASK_POLL_INTERVAL_MS = 2000;
+/** Concurrent `working` tasks per server process; the (n+1)th `axiom_check_start` is refused. */
+export declare const TASK_MAX_WORKING = 8;
+/** Idle sessions (no `add`/`seal`) are dropped after this. */
+export declare const PLAN_SESSION_TTL_MS: number;
+/** Artifacts a session may hold — same bound as `PlanSchema.artifacts.max`. */
+export declare const PLAN_SESSION_MAX_ARTIFACTS = 2000;
+/** Summed UTF-8 JSON bytes of every chunk a session accepts (64 MiB, the `default` profile's `maxTotalBytes`). */
+export declare const PLAN_SESSION_MAX_BYTES: number;
+declare const TaskErrorSchema: z.ZodObject<{
+  code: z.ZodString;
+  message: z.ZodString;
+  details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+interface TaskRecord<T = unknown> {
+  taskId: string;
+  /** Tool that created the task (`axiom_check`). */
+  tool: string;
+  status: TaskStatus;
+  createdAt: number;
+  /** Set when the task reaches a terminal status. */
+  finishedAt?: number;
+  result?: T;
+  error?: z.output<typeof TaskErrorSchema>;
+  controller: AbortController;
+  /** Root the task was bound to (for logging / listing). */
+  root?: string;
+}
+interface TaskDescriptor {
+  taskId: string;
+  tool: string;
+  status: TaskStatus;
+  pollIntervalMs: number;
+  ttlMs: number;
+  /** Milliseconds since the task was created. */
+  elapsedMs: number;
+}
+interface TaskStoreOptions {
+  now?: () => number;
+  ttlMs?: number;
+  pollIntervalMs?: number;
+  maxWorking?: number;
+}
+export declare class TaskStore {
+  private readonly tasks;
+  private readonly now;
+  readonly ttlMs: number;
+  readonly pollIntervalMs: number;
+  readonly maxWorking: number;
+  constructor(opts?: TaskStoreOptions);
+  /**
+   * Start `work` in the background. The returned record is `working` until the promise settles;
+   * a rejection becomes `failed` (AxiomError → its closed code, anything else → `ERR_INTERNAL`),
+   * a rejection after `cancel()` stays `cancelled`.
+   */
+  start<T>(tool: string, work: (signal: AbortSignal) => Promise<T>, meta?: {
+    root?: string;
+  }): TaskRecord<T>;
+  get(taskId: string): TaskRecord;
+  /** Abort a `working` task; terminal tasks are left as they are (idempotent). */
+  cancel(taskId: string): TaskRecord;
+  describe(rec: TaskRecord): TaskDescriptor;
+  /** Drop terminal tasks older than `ttlMs`. */
+  sweep(): void;
+  /** Abort everything still running (server shutdown). */
+  abortAll(): void;
+  get size(): number;
+}
+/** Everything in a Plan except `artifacts` (and the fixed `apiVersion`/`kind`) — what `axiom_plan_begin` receives. */
+type PlanHeader = Omit<PlanInput, "artifacts" | "apiVersion" | "kind">;
+interface PlanSession {
+  sessionId: string;
+  header: PlanHeader;
+  artifacts: PlanArtifact[];
+  paths: Set<string>;
+  /** Summed UTF-8 JSON bytes of accepted chunks. */
+  bytes: number;
+  createdAt: number;
+  touchedAt: number;
+  sealed: boolean;
+}
+interface PlanSessionStoreOptions {
+  now?: () => number;
+  ttlMs?: number;
+  maxOpen?: number;
+  maxArtifacts?: number;
+  maxBytes?: number;
+}
+export declare class PlanSessionStore {
+  private readonly sessions;
+  private readonly now;
+  readonly ttlMs: number;
+  readonly maxOpen: number;
+  readonly maxArtifacts: number;
+  readonly maxBytes: number;
+  constructor(opts?: PlanSessionStoreOptions);
+  begin(header: PlanHeader): PlanSession;
+  get(sessionId: string): PlanSession;
+  /** Append already-validated artifacts; duplicates (within or across chunks) are `ERR_INVALID_PLAN`. */
+  add(sessionId: string, artifacts: readonly PlanArtifact[], chunkBytes: number): PlanSession;
+  /** Mark sealed and return the assembled Plan input; the session is dropped. */
+  seal(sessionId: string): {
+    session: PlanSession;
+    plan: PlanInput;
+  };
+  /** Drop an unsealed session without compiling. Unknown ids are a no-op. */
+  abandon(sessionId: string): boolean;
+  sweep(): void;
+  get size(): number;
+}
+//#endregion
 //#region src/tools.d.ts
 /** Hard cap on any single `bundle`/`plan` argument, measured as UTF-8 JSON bytes (§(f) payload size). */
 export declare const BUNDLE_BYTES_MAX: number;
@@ -74,6 +195,10 @@ interface ToolContext {
   seenRoots: Set<string>;
   /** `--allow-guards` / `--guard-allowlist` from startup (§3.2); absent = guards disabled. */
   guards?: GuardOptions;
+  /** Long-running checks (`axiom_check_start` / `axiom_task_*`), shared across a factory's instances (S-406). */
+  tasks: TaskStore;
+  /** Chunked plan sessions (`axiom_plan_begin` / `add` / `seal`), shared like `tasks`. */
+  planSessions: PlanSessionStore;
 }
 interface ToolDef<I extends z.ZodRawShape = z.ZodRawShape, O extends z.ZodType = z.ZodType> {
   name: string;
@@ -100,6 +225,17 @@ interface CreateServerOptions {
   tools?: readonly AnyToolDef[];
   /** `--allow-guards` / `--guard-allowlist` (§3.2). Omit to keep guards disabled. */
   guards?: ToolContext["guards"];
+  /** Wire era this instance will serve (set by the serving entry; `legacy` when hand-connected). */
+  era?: WireEra;
+  /**
+   * Roots discovered via tool calls (sub-roots of the allowlist). Shared across the instances a
+   * factory builds so a digest compiled on one 2026-era HTTP request is loadable on the next.
+   */
+  seenRoots?: Set<string>;
+  /** Background check tasks (S-406). Shared across a factory's instances; a fresh store per server otherwise. */
+  tasks?: TaskStore;
+  /** Chunked plan sessions (S-406). Shared like `tasks`. */
+  planSessions?: PlanSessionStore;
 }
 interface StructuredError {
   code: ErrorCode;
@@ -129,5 +265,5 @@ export declare function buildToolsSpec(): ToolSpecEntry[];
 /** Stable text form (2-space JSON + trailing newline) used both by the generator and the parity test. */
 export declare function renderToolsSpec(): string;
 //#endregion
-export type { AnyToolDef, CreateServerOptions, LogLevel, Logger, ResolvedRoot, RiskClass, RootsPolicy, SchemaKind, StructuredError, ToolAnnotations, ToolContext, ToolDef, ToolSpecEntry };
+export type { AnyToolDef, CreateServerOptions, LogLevel, Logger, PlanSession, ResolvedRoot, RiskClass, RootsPolicy, SchemaKind, StructuredError, TaskDescriptor, TaskRecord, TaskStatus, ToolAnnotations, ToolContext, ToolDef, ToolSpecEntry };
 //# sourceMappingURL=index.d.ts.map