@lunora/mcp 1.0.0-alpha.24 → 1.0.0-alpha.241

package/dist/worker/index.d.ts

@@ -0,0 +1,258 @@
+import { L as LunoraMcpServerOptions } from "../packem_shared/server.d-DQgZyRkG.js";
+export { A as AGENT_RUN_INPUT_SCHEMA, a as AGENT_STATUS_TOOL_NAME,
+/** Worker-safe entry: fetch handlers and tool composition, with no stdio transport or `node:*` imports. */
+type C as CallAgentToolOptions,
+/** Worker-safe entry: fetch handlers and tool composition, with no stdio transport or `node:*` imports. */
+type M as McpAgentExposure, b as agentToolDefinitions, c as callAgentTool, p as parseAgentsEnv } from "../packem_shared/server.d-DQgZyRkG.js";
+import { M as McpFetchHandler } from "../packem_shared/serve-stateless.d-DD5arqFx.js";
+export { D as DEFAULT_MAX_REQUEST_BYTES, type S as ServeStatelessOptions, s as serveStateless } from "../packem_shared/serve-stateless.d-DD5arqFx.js";
+import { T as ToolDefinition, c as ToolResult, b as ToolInputSchema } from "../packem_shared/compose.d-BVnP3uAy.js";
+export { type M as McpServerInfo, type a as McpTool, d as createToolServer } from "../packem_shared/compose.d-BVnP3uAy.js";
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { LunoraClient } from '@lunora/client';
+import '@modelcontextprotocol/sdk/server/index.js';
+import '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+/**
+ * The observability tools. Descriptions say WHEN to call the tool, not just
+ * what it returns — an agent picking between five similar reads needs the
+ * trigger, and it pays for these strings on every turn.
+ */
+declare const OBSERVABILITY_TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
+/** The read-only tool surface: introspection + query. Always exposed. */
+declare const READ_ONLY_TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
+/** The write tool surface (mutations + actions). Exposed ONLY when writes are enabled. */
+declare const WRITE_TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
+/**
+ * The tools this server advertises: every family whose gate is open, in table
+ * order. A gated family is OMITTED rather than refused — an AI agent can't
+ * invoke what it can't see — and {@link callTool} re-checks the same gate at
+ * dispatch, so the guarantee does not depend on a client honouring this list.
+ */
+declare const toolDefinitions: (allowWrites: boolean, allowObservability?: boolean, allowDataReads?: boolean) => ReadonlyArray<ToolDefinition>;
+/**
+ * Dispatch a tool call against `client`: find the family that owns `name`, check
+ * its gate, hand off. Unknown tools and thrown errors are returned as `isError`
+ * results (rather than rejections) so the calling model sees the failure as tool
+ * output, per the MCP convention.
+ *
+ * Each gate is enforced HERE as well as in {@link toolDefinitions}, so a call to
+ * a gated tool is refused even if the client somehow names one it was never
+ * shown.
+ */
+declare const callTool: (client: LunoraClient, name: string, input: Record<string, unknown>, allowWrites?: boolean, allowObservability?: boolean, allowDataReads?: boolean) => Promise<ToolResult>;
+/**
+ * The verified access-token payload better-auth hands a protected handler.
+ *
+ * A JWT payload is an open bag of claims, so this is deliberately an index
+ * signature with the two entries this module reads named. It is structurally
+ * satisfied by `jose`'s `JWTPayload`, which is what better-auth passes.
+ */
+interface McpAccessTokenClaims {
+  readonly [claim: string]: unknown;
+  /** Space-delimited granted scopes (RFC 6749 §3.3). */
+  readonly scope?: unknown;
+  /** Subject — the user the token was issued for. */
+  readonly sub?: string;
+}
+/**
+ * The MCP auth gate: wraps a claims-aware handler into a plain fetch handler.
+ *
+ * Declared structurally here rather than imported from `@better-auth/mcp`,
+ * following the same rule `./paid` follows for `@lunora/x402`: a type import
+ * from a package this one does not depend on puts that package's `.d.ts` into
+ * the build graph, and a consumer that never installs it never builds it
+ * either — so the dts bundler looks for a `dist/` that does not exist and fails
+ * the build. Structural typing costs nothing here because this module never
+ * inspects the gate; it only applies it.
+ *
+ * Both better-auth entry points partially apply to this shape:
+ * `(handler) => requireMcpAuth(auth, handler, opts)` and
+ * `(handler) => createMcpProtectedRequestHandler(options, handler)`.
+ */
+type McpAuthProtect = (handler: (request: Request, claims: McpAccessTokenClaims) => Promise<Response>) => McpFetchHandler;
+/** Server options, or a function deriving them from the request's verified claims. */
+type AuthedMcpServerOptions = ((claims: McpAccessTokenClaims) => LunoraMcpServerOptions | Promise<LunoraMcpServerOptions>) | LunoraMcpServerOptions;
+interface AuthedMcpFetchHandlerOptions {
+  /**
+   * Largest accepted request body, in bytes — enforced while the body streams
+   * in, not after it is buffered. Defaults to `DEFAULT_MAX_REQUEST_BYTES`
+   * (128 KiB), which a value that is not a non-negative safe integer also
+   * falls back to.
+   */
+  maxRequestBytes?: number;
+  /**
+   * The OAuth gate to mount the MCP server behind. Pass
+   * `(handler) => requireMcpAuth(auth, handler, opts)` from
+   * `@lunora/auth/plugins`.
+   */
+  protect: McpAuthProtect;
+  /**
+   * The Lunora MCP server to serve once a request is authorized — either a
+   * fixed options object, or a function of the verified token claims so tool
+   * exposure can follow the scopes the token actually carries.
+   */
+  server: AuthedMcpServerOptions;
+  /**
+   * Step-up for the side-effecting tools: the write tools
+   * (`lunora_run_mutation` / `lunora_run_action`) and the agent tools (each
+   * `agent_<name>` and `lunora_agent_status`, since starting a durable run is a
+   * side effect). A token without `scope` still sees them in `tools/list`, and
+   * a `tools/call` to one throws `challenge([scope])` instead of running, so the
+   * client can re-authorize for the scope and retry. Unset, tools follow
+   * `allowWrites` / `allowAgents` alone. The raw-row and observability families
+   * need their own token scopes with or without `stepUp`; without it a call
+   * without the scope is refused as a tool error, not challenged.
+   */
+  stepUp?: {
+    /**
+     * Build the error that makes the gate answer 403 `insufficient_scope`
+     * naming `scopes`. Pass `createInsufficientScopeError` from
+     * `@lunora/auth/plugins`: better-auth only turns an error that factory
+     * created into the challenge.
+     */
+    challenge: (scopes: string[]) => unknown;
+    /** The scope a call to a side-effecting tool needs, e.g. `"lunora:write"`. */
+    scope: string;
+  };
+}
+/**
+ * Parse an access token's `scope` claim into a set.
+ *
+ * RFC 6749 §3.3 makes `scope` a space-delimited string, and better-auth issues
+ * it that way; anything else (absent, or a non-string an extension wrote)
+ * yields an empty set rather than throwing, so a scope check on a malformed
+ * token denies instead of crashing the tool call.
+ */
+declare const mcpTokenScopes: (claims: McpAccessTokenClaims) => ReadonlySet<string>;
+declare const createAuthedMcpFetchHandler: (options: AuthedMcpFetchHandlerOptions) => McpFetchHandler;
+/** {@link createMcpFetchHandler} options: the server's, plus this transport's body limit. */
+interface McpFetchHandlerOptions extends LunoraMcpServerOptions {
+  /**
+   * Largest accepted request body, in bytes — enforced while the body streams
+   * in, not after it is buffered. Defaults to `DEFAULT_MAX_REQUEST_BYTES`
+   * (128 KiB), which a value that is not a non-negative safe integer also
+   * falls back to.
+   */
+  maxRequestBytes?: number;
+}
+/**
+ * Build a stateless Streamable-HTTP fetch handler for a Lunora MCP server. Each
+ * invocation constructs a fresh proxy server and serves the request through
+ * {@link serveStateless}.
+ *
+ * The `LunoraClient` is resolved ONCE, here, and shared by every request: it is
+ * the same deployment on each one, and the public-function registry memo in
+ * `./tools` is keyed by client identity, so a per-request client would re-fetch
+ * that registry on every tool call. A misconfiguration (`url` without `token`)
+ * therefore throws when the handler is built rather than on first request,
+ * which is where `createLunoraMcpServer` already documents reporting it.
+ */
+declare const createMcpFetchHandler: (options: McpFetchHandlerOptions) => McpFetchHandler;
+/** A tool handler: receives the call's `arguments` bag, returns an MCP tool result. */
+/**
+ * The x402 vocabulary this module needs, declared here rather than imported.
+ *
+ * The x402 package is an optional peer, and a type import from its `charge`
+ * entry puts its `.d.ts` back into this package's build graph:
+ * a consumer that never installs x402 never builds it either, so the dts bundler
+ * looks for a `dist/` that does not exist and fails. That is not hypothetical —
+ * it broke the docs site build, which runs a filtered build over the docs app and its dependency closure
+ * and therefore never builds x402.
+ *
+ * Declaring them locally is safe because this module never *inspects* a charge
+ * config; it forwards it whole to `createChargeMiddleware`. The index signature
+ * keeps a real charge config assignable as x402 grows fields.
+ */
+/** Mirrors x402's `X402Price` — a decimal string like `"$0.05"`, or a number. */
+type X402Price = number | string;
+/** Mirrors x402's charge config with the per-tool price omitted. */
+interface X402ChargeSettings {
+  /** Network this resource settles on. */
+  readonly network: string;
+  /** Everything else x402 accepts, forwarded untouched. */
+  readonly [key: string]: unknown;
+  /** Payout wallet(s), per network family. */
+  readonly recipient: {
+    readonly evm?: string;
+    readonly svm?: string;
+  };
+}
+type ToolHandler = (arguments_: Record<string, unknown>) => Promise<ToolResult> | ToolResult;
+/** Registration shape for a free tool. */
+interface RegisterToolOptions {
+  /** Optional MCP tool annotations (`readOnlyHint`, `title`, …). */
+  annotations?: Tool["annotations"];
+  /** Human/model-facing description of what the tool does. */
+  description: string;
+  /** JSON-Schema object describing the tool's arguments. */
+  inputSchema: ToolInputSchema;
+  /** Unique tool name (the MCP `tools/call` `name`). */
+  name: string;
+}
+/** Registration shape for a paid tool: a {@link RegisterToolOptions} plus its USD price. */
+interface RegisterPaidToolOptions extends RegisterToolOptions {
+  /** USD price per call (e.g. `"$0.05"`), charged via x402 before dispatch. */
+  price: X402Price;
+}
+/** x402 settlement vocabulary shared by every paid tool (network, recipient, facilitator); price is per-tool. */
+type PaidMcpChargeConfig = X402ChargeSettings;
+/** Config for `createPaidMcpServer`. */
+interface PaidMcpServerConfig {
+  /** The worker-level x402 charge config; each paid tool supplies only its own `price`. */
+  charge: PaidMcpChargeConfig;
+  /**
+   * Largest accepted request body, in bytes — enforced while the body streams
+   * in, not after it is buffered. Defaults to `DEFAULT_MAX_REQUEST_BYTES`
+   * (128 KiB), which a value that is not a non-negative safe integer also
+   * falls back to.
+   */
+  maxRequestBytes?: number;
+  /** Name/version advertised in the MCP `initialize` handshake. Defaults to `lunora-paid-mcp`. */
+  serverInfo?: {
+    name: string;
+    version: string;
+  };
+}
+/**
+ * The Worker execution context, as this module reads it: only `waitUntil`, and
+ * structurally, so the package takes no `@cloudflare/workers-types` dependency.
+ */
+interface PaidMcpExecutionContext {
+  waitUntil?: (promise: Promise<unknown>) => void;
+}
+/**
+ * The paid server's fetch handler.
+ *
+ * Unlike the free `McpFetchHandler` it takes the Worker's full
+ * `(request, env, ctx)` triple — the shape `export default { fetch }` is called
+ * with — because the x402 receipt sink NEEDS `ctx.waitUntil`: work that is
+ * neither awaited into the response nor registered with it is cancelled when the
+ * request ends, so an async `onReceipt` (inserting the settled payment into a
+ * durable table) frequently never runs while the money has already moved
+ * on-chain. `env` is accepted and ignored so the handler drops straight into the
+ * default export; both are optional, so a non-Workers caller may still invoke it
+ * with a bare `Request` (the middleware then simply sees no `waitUntil`).
+ */
+type PaidMcpFetchHandler = (request: Request, env?: unknown, context?: PaidMcpExecutionContext) => Promise<Response>;
+/** A paid MCP server: register free/paid tools, then serve over Streamable HTTP. */
+interface PaidMcpServer {
+  /** The Streamable-HTTP fetch handler; gates each paid `tools/call` behind x402. */
+  readonly fetchHandler: PaidMcpFetchHandler;
+  /** Register a **paid** tool: its dispatch runs the x402 charge middleware first. */
+  paidTool: (options: RegisterPaidToolOptions, handler: ToolHandler) => void;
+  /** Register a **free** tool (coexists with paid tools on the same server). */
+  tool: (options: RegisterToolOptions, handler: ToolHandler) => void;
+}
+/**
+ * Create a paid MCP server. Register free tools with `tool()` and priced tools
+ * with `paidTool()` (they coexist), then serve `fetchHandler` over HTTP.
+ *
+ * The server is **stateless**: `fetchHandler` builds a fresh `Server` per
+ * request (reading the live tool registry), so tools registered before the
+ * first request are all visible. Each priced tool memoises one initialised
+ * `ChargeMiddleware` (keyed by tool name, baking that tool's price and naming
+ * the tool as the challenge `resource`); a failed init is not cached, so a
+ * transient facilitator outage retries on the next call.
+ */
+declare const createPaidMcpServer: (config: PaidMcpServerConfig) => PaidMcpServer;
+export { type AuthedMcpFetchHandlerOptions, type AuthedMcpServerOptions, type McpAccessTokenClaims, type McpAuthProtect, type McpFetchHandler, type McpFetchHandlerOptions, OBSERVABILITY_TOOL_DEFINITIONS, type PaidMcpChargeConfig, type PaidMcpExecutionContext, type PaidMcpFetchHandler, type PaidMcpServer, type PaidMcpServerConfig, READ_ONLY_TOOL_DEFINITIONS, type RegisterPaidToolOptions, type RegisterToolOptions, type ToolDefinition, type ToolHandler, type ToolInputSchema, type ToolResult, WRITE_TOOL_DEFINITIONS, callTool, createAuthedMcpFetchHandler, createMcpFetchHandler, createPaidMcpServer, mcpTokenScopes, toolDefinitions };

package/dist/worker/index.mjs

@@ -0,0 +1 @@
+import{AGENT_RUN_INPUT_SCHEMA as r,AGENT_STATUS_TOOL_NAME as t,agentToolDefinitions as T,callAgentTool as a,parseAgentsEnv as _}from"../packem_shared/AGENT_RUN_INPUT_SCHEMA-hKbpa3Dg.mjs";import{createAuthedMcpFetchHandler as c,mcpTokenScopes as p}from"../packem_shared/createAuthedMcpFetchHandler-D_SQpDhH.mjs";import{createToolServer as s}from"../packem_shared/createToolServer-BtGuPyMU.mjs";import{createMcpFetchHandler as S}from"../packem_shared/createMcpFetchHandler-TkLzJUNn.mjs";import{createPaidMcpServer as A}from"../packem_shared/createPaidMcpServer-BH_mly77.mjs";import{R as n,W as f,c as m,t as x}from"../packem_shared/tools-BOfWz78m.mjs";import{DEFAULT_MAX_REQUEST_BYTES as D,serveStateless as L}from"../packem_shared/DEFAULT_MAX_REQUEST_BYTES-CbbpkHRK.mjs";import{O as M}from"../packem_shared/observability-tools-D4Z8dGS-.mjs";export{r as AGENT_RUN_INPUT_SCHEMA,t as AGENT_STATUS_TOOL_NAME,D as DEFAULT_MAX_REQUEST_BYTES,M as OBSERVABILITY_TOOL_DEFINITIONS,n as READ_ONLY_TOOL_DEFINITIONS,f as WRITE_TOOL_DEFINITIONS,T as agentToolDefinitions,a as callAgentTool,m as callTool,c as createAuthedMcpFetchHandler,S as createMcpFetchHandler,A as createPaidMcpServer,s as createToolServer,p as mcpTokenScopes,_ as parseAgentsEnv,L as serveStateless,x as toolDefinitions};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/mcp",
-  "version": "1.0.0-alpha.24",
+  "version": "1.0.0-alpha.241",
   "description": "Model Context Protocol server exposing a Lunora deployment to AI agents",
   "keywords": [
     "ai-agents",
@@ -43,16 +43,37 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs"
     },
+    "./docs": {
+      "types": "./dist/docs/index.d.ts",
+      "import": "./dist/docs/index.mjs"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "import": "./dist/node/index.mjs"
+    },
+    "./worker": {
+      "types": "./dist/worker/index.d.ts",
+      "import": "./dist/worker/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.22",
-    "@lunora/errors": "1.0.0-alpha.4",
-    "@lunora/x402": "1.0.0-alpha.2",
-    "@modelcontextprotocol/sdk": "^1.29.0"
+    "@cfworker/json-schema": "^4.1.1",
+    "@lunora/client": "1.0.0-alpha.207",
+    "@lunora/errors": ">=1.0.0-alpha.51 <2.0.0-0",
+    "@lunora/shard-engine": "1.0.0-alpha.128",
+    "@modelcontextprotocol/sdk": "^1.32.0"
+  },
+  "peerDependencies": {
+    "@lunora/x402": ">=1.0.0-alpha.21 <2.0.0-0"
+  },
+  "peerDependenciesMeta": {
+    "@lunora/x402": {
+      "optional": true
+    }
   },
   "engines": {
     "node": "^22.15.0 || >=24.11.0"

package/dist/packem_shared/AGENT_RUN_INPUT_SCHEMA-DWobae3P.mjs

@@ -1,168 +0,0 @@
-const AGENT_RUN_PATH = "agents:agentRun";
-const AGENT_THREAD_PATH = "agents:agentThread";
-const AGENT_MESSAGES_PATH = "agents:agentMessages";
-const AGENT_STATUS_TOOL_NAME = "lunora_agent_status";
-const TERMINAL_STATUSES = /* @__PURE__ */ new Set(["cancelled", "error", "idle"]);
-const DEFAULT_MAX_WAIT_MS = 6e4;
-const DEFAULT_POLL_INTERVAL_MS = 600;
-const AGENT_RUN_INPUT_SCHEMA = {
-  properties: {
-    prompt: { description: "The task or message for the agent.", type: "string" },
-    threadKey: { description: "Reuse to continue a conversation; omit to start a new thread.", type: "string" },
-    title: { description: "Optional thread title (first run only).", type: "string" }
-  },
-  required: ["prompt"],
-  type: "object"
-};
-const AGENT_STATUS_INPUT_SCHEMA = {
-  properties: {
-    threadKey: { description: "The thread key returned by an agent tool call.", type: "string" }
-  },
-  required: ["threadKey"],
-  type: "object"
-};
-const agentToolName = (exposure) => exposure.toolName ?? `agent_${exposure.name}`;
-const parseAgentsEnv = (raw) => {
-  if (raw === void 0) {
-    return [];
-  }
-  const exposures = [];
-  for (const entry of raw.split(";")) {
-    const trimmed = entry.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    const separator = trimmed.indexOf(":");
-    if (separator <= 0) {
-      continue;
-    }
-    const name = trimmed.slice(0, separator).trim();
-    const description = trimmed.slice(separator + 1).trim();
-    if (name.length === 0 || description.length === 0) {
-      continue;
-    }
-    exposures.push({ description, name });
-  }
-  return exposures;
-};
-const agentToolDefinitions = (exposures, allowAgents) => {
-  if (allowAgents !== true || exposures.length === 0) {
-    return [];
-  }
-  const perAgent = exposures.map((exposure) => {
-    return {
-      description: `${exposure.description} Starts a durable agent run and returns its final answer.`,
-      inputSchema: AGENT_RUN_INPUT_SCHEMA,
-      name: agentToolName(exposure)
-    };
-  });
-  return [
-    ...perAgent,
-    {
-      description: "Check the status of a durable agent run (and its answer if finished) by its threadKey.",
-      inputSchema: AGENT_STATUS_INPUT_SCHEMA,
-      name: AGENT_STATUS_TOOL_NAME
-    }
-  ];
-};
-const isAgentToolName = (name, exposures) => name === AGENT_STATUS_TOOL_NAME || exposures.some((exposure) => agentToolName(exposure) === name);
-const freshThreadKey = () => `mcp-${crypto.randomUUID()}`;
-const reference = (path) => {
-  return { __lunoraRef: path };
-};
-const defaultWait = async (ms) => {
-  await new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-};
-const ok = (value) => {
-  return { content: [{ text: JSON.stringify(value, void 0, 2), type: "text" }] };
-};
-const fail = (text) => {
-  return { content: [{ text, type: "text" }], isError: true };
-};
-const readString = (input, key) => {
-  const value = input[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-};
-const finalAnswer = (messages) => {
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const row = messages[index];
-    const toolCalls = row?.["toolCalls"];
-    const pending = Array.isArray(toolCalls) && toolCalls.length > 0;
-    if (row?.["role"] === "assistant" && !pending) {
-      return typeof row["content"] === "string" ? row["content"] : "";
-    }
-  }
-  return "";
-};
-const readThreadStatus = (thread) => {
-  if (thread !== null && typeof thread === "object" && typeof thread.status === "string") {
-    return thread.status;
-  }
-  return "unknown";
-};
-const readTerminal = async (client, threadKey, status, thread) => {
-  const messages = await client.query(reference(AGENT_MESSAGES_PATH), { key: threadKey });
-  if (status === "error") {
-    const error = thread !== null && typeof thread === "object" ? thread.error : void 0;
-    return ok({ error: typeof error === "string" ? error : "the agent run failed", status, threadKey });
-  }
-  return ok({ status, text: finalAnswer(messages), threadKey });
-};
-const callAgentStatus = async (client, input) => {
-  const threadKey = readString(input, "threadKey");
-  if (threadKey === void 0) {
-    return fail('"threadKey" is required and must be a non-empty string');
-  }
-  const thread = await client.query(reference(AGENT_THREAD_PATH), { key: threadKey });
-  const status = readThreadStatus(thread);
-  if (TERMINAL_STATUSES.has(status)) {
-    return readTerminal(client, threadKey, status, thread);
-  }
-  return ok({ status: status === "unknown" ? "running" : status, threadKey });
-};
-const callAgentTool = async (client, name, input, options) => {
-  try {
-    if (options.allowAgents !== true) {
-      return fail(`tool "${name}" is disabled: agent tools are off. Enable them with the LUNORA_MCP_ALLOW_AGENTS env var.`);
-    }
-    if (name === AGENT_STATUS_TOOL_NAME) {
-      return await callAgentStatus(client, input);
-    }
-    const exposure = options.exposures.find((candidate) => agentToolName(candidate) === name);
-    if (exposure === void 0) {
-      return fail(`agent tool "${name}" is not exposed by this MCP server`);
-    }
-    const prompt = readString(input, "prompt");
-    if (prompt === void 0) {
-      return fail('"prompt" is required and must be a non-empty string');
-    }
-    const threadKey = readString(input, "threadKey") ?? freshThreadKey();
-    const title = readString(input, "title");
-    const { id } = await client.mutation(reference(AGENT_RUN_PATH), {
-      agent: exposure.name,
-      input: prompt,
-      threadKey,
-      ...title === void 0 ? {} : { title }
-    });
-    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-    const maxWaitMs = options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
-    const wait = options.wait ?? defaultWait;
-    const maxPolls = Math.max(1, Math.ceil(maxWaitMs / pollIntervalMs));
-    for (let attempt = 0; attempt < maxPolls; attempt += 1) {
-      const thread = await client.query(reference(AGENT_THREAD_PATH), { key: threadKey });
-      const status = readThreadStatus(thread);
-      if (TERMINAL_STATUSES.has(status)) {
-        return await readTerminal(client, threadKey, status, thread);
-      }
-      await wait(pollIntervalMs);
-    }
-    return ok({ hint: "call lunora_agent_status with this threadKey to poll for the answer", runId: id, status: "running", threadKey });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return fail(message);
-  }
-};
-
-export { AGENT_RUN_INPUT_SCHEMA, AGENT_STATUS_TOOL_NAME, agentToolDefinitions, callAgentTool, finalAnswer, isAgentToolName, parseAgentsEnv };