@prism-llm-labs/mcp-sdk 0.2.0

package/dist/index.d.mts

@@ -0,0 +1,310 @@
+type McpPrimitiveType = "tool" | "resource" | "prompt" | "sampling";
+interface McpEvent {
+    event_id: string;
+    timestamp: string;
+    session_id: string;
+    org_id: string;
+    project_id: string;
+    team_id: string;
+    user_id: string;
+    environment: string;
+    mcp_server_name: string;
+    /** tool name, resource URI, prompt name, or model hint for sampling */
+    tool_name: string;
+    downstream_resource: string;
+    execution_latency_ms: number;
+    tool_cost_usd: number;
+    status: "ok" | "error" | "timeout";
+    error_message: string;
+    llm_request_id: string;
+    primitive_type: McpPrimitiveType;
+    /**
+     * Whether tool_cost_usd is an estimate from the built-in catalog ("estimated")
+     * or a real figure provided by the tool via ctx.reportActualCost() ("actual").
+     */
+    cost_status: "estimated" | "actual";
+    tags: Record<string, string>;
+}
+interface PrismMcpOptions {
+    /** Prism API key — or set PRISM_API_KEY env var */
+    prismKey?: string;
+    /** Project ID for cost attribution */
+    project?: string;
+    /** Team attribution tag */
+    team?: string;
+    /** "production" | "staging" | "development" */
+    environment?: string;
+    /** Explicit session ID. Auto-generated UUID if omitted. */
+    sessionId?: string;
+    /** MCP server name shown in the dashboard */
+    serverName?: string;
+    /** Override ingest URL (for testing) */
+    ingestUrl?: string;
+    /**
+     * Session budget in USD. Tool/resource/prompt calls are blocked when the
+     * combined session cost exceeds this value.
+     */
+    sessionBudgetUsd?: number;
+    /**
+     * Maximum MCP primitive calls per session. Blocks further calls when exceeded.
+     * Loop detection guard — default unlimited.
+     */
+    maxToolCallsPerSession?: number;
+    /**
+     * Log call arguments into tags['tool_input'] (truncated to 1000 chars).
+     * Opt-in only — disabled by default for privacy.
+     */
+    captureInputs?: boolean;
+    /**
+     * Log call results into tags['tool_output'] (truncated to 1000 chars).
+     * Opt-in only — disabled by default for privacy.
+     */
+    captureOutputs?: boolean;
+    /**
+     * Keys to redact from captured inputs/outputs.
+     * Default: ['password', 'token', 'key', 'secret', 'api_key', 'authorization']
+     */
+    redactKeys?: string[];
+}
+declare class PrismSessionBudgetExceededError extends Error {
+    constructor(sessionId: string, budgetUsd: number);
+}
+declare class PrismToolCallLimitError extends Error {
+    constructor(sessionId: string, limit: number);
+}
+
+/**
+ * PrismMCP — instruments any MCP Server with full observability:
+ *   - tools/call   → wrapToolCall() / patchHandler()
+ *   - resources/read → wrapResourceRead() / patchResourceHandler()
+ *   - prompts/get  → wrapPromptGet() / patchPromptHandler()
+ *   - sampling/createMessage → wrapSamplingHandler()
+ *
+ * Features:
+ *   - Session budget circuit breaker (throws before execution if over budget)
+ *   - Tool loop detection (throws if max_tool_calls_per_session exceeded)
+ *   - Opt-in I/O capture (captureInputs / captureOutputs)
+ *   - Streaming tool latency: correctly measures time-to-stream-end, not first-chunk
+ */
+
+declare class WrapContext {
+    /** @internal - read by _wrap() after fn() completes */
+    _actualCostUsd: number | null;
+    /**
+     * Override the catalog-estimated tool cost with the real billing figure.
+     * Call this inside your tool handler when you have access to actual cost data
+     * (e.g. from AWS SDK response metadata, a billing header, or a usage API).
+     *
+     * @example
+     * await prismMcp.wrapToolCall("invoke_lambda", async (ctx) => {
+     *   const res = await lambda.invoke({ FunctionName: "fn", Payload: payload });
+     *   const billedMs = res.$metadata.httpHeaders?.["x-amz-billed-duration-ms"] ?? "0";
+     *   ctx.reportActualCost(parseInt(billedMs) * 0.000016667 / 1000);
+     *   return res;
+     * });
+     */
+    reportActualCost(usd: number): void;
+}
+declare class PrismMCP {
+    private readonly tracker;
+    private readonly budget;
+    private readonly redactKeys;
+    private readonly opts;
+    constructor(options?: PrismMcpOptions);
+    /**
+     * Internal wrapper used by all four MCP primitives.
+     * Handles: budget check, I/O capture, streaming proxy, fire-and-forget telemetry,
+     * and actual cost self-reporting via ctx.reportActualCost().
+     */
+    private _wrap;
+    /**
+     * Wrap a tools/call execution with Prism instrumentation.
+     */
+    wrapToolCall<T>(toolName: string, fn: (ctx: WrapContext) => Promise<T>, extra?: {
+        llmRequestId?: string;
+        tags?: Record<string, string>;
+        downstreamResource?: string;
+        /** Raw tool arguments — captured if captureInputs: true */
+        inputs?: Record<string, unknown>;
+    }): Promise<T>;
+    /**
+     * Drop-in patch for MCP SDK's CallToolRequestSchema handler.
+     * Automatically passes req.params.arguments as inputs when captureInputs: true.
+     * ctx is available for reportActualCost() inside the handler.
+     */
+    patchHandler<TReq extends {
+        params: {
+            name: string;
+            arguments?: Record<string, unknown>;
+        };
+    }, TRes>(handler: (req: TReq, ctx: WrapContext) => Promise<TRes>): (req: TReq) => Promise<TRes>;
+    /**
+     * Wrap a resources/read execution with Prism instrumentation.
+     *
+     * @param resourceUri - The resource URI being read (e.g. "file:///path/to/file")
+     */
+    wrapResourceRead<T>(resourceUri: string, fn: (ctx: WrapContext) => Promise<T>, extra?: {
+        llmRequestId?: string;
+        tags?: Record<string, string>;
+    }): Promise<T>;
+    patchResourceHandler<TReq extends {
+        params: {
+            uri: string;
+        };
+    }, TRes>(handler: (req: TReq, ctx: WrapContext) => Promise<TRes>): (req: TReq) => Promise<TRes>;
+    wrapPromptGet<T>(promptName: string, fn: (ctx: WrapContext) => Promise<T>, extra?: {
+        llmRequestId?: string;
+        tags?: Record<string, string>;
+    }): Promise<T>;
+    patchPromptHandler<TReq extends {
+        params: {
+            name: string;
+        };
+    }, TRes>(handler: (req: TReq, ctx: WrapContext) => Promise<TRes>): (req: TReq) => Promise<TRes>;
+    /**
+     * Wrap the MCP client's sampling/createMessage callback so LLM calls
+     * requested by the MCP server appear in the session timeline.
+     *
+     * Usage with @modelcontextprotocol/sdk:
+     *   client.setRequestHandler(
+     *     CreateMessageRequestSchema,
+     *     prismMcp.wrapSamplingHandler(async (req) => {
+     *       const res = await openai.chat.completions.create({ ... });
+     *       return { role: "assistant", content: [{ type: "text", text: res.choices[0].message.content }] };
+     *     })
+     *   );
+     */
+    wrapSamplingHandler<TReq extends {
+        params?: {
+            modelPreferences?: {
+                hints?: Array<{
+                    name?: string;
+                }>;
+            };
+        };
+    }, TRes>(handler: (req: TReq) => Promise<TRes>): (req: TReq) => Promise<TRes>;
+    /** The session_id assigned to this instance (useful for logging). */
+    get sessionId(): string;
+}
+
+/**
+ * PrismSession — shared session context for multi-server agent runs.
+ *
+ * Creates a single session_id that is automatically threaded through:
+ *   - Multiple PrismMCP server instances (files, database, search, etc.)
+ *   - LLM SDK clients (OpenAI, Anthropic) via toLLMOptions()
+ *
+ * This ensures every LLM call and every tool/resource/prompt call in one
+ * agent run appears under the same session in /dashboard/sessions/[id].
+ *
+ * Usage:
+ *   const session = new PrismSession({
+ *     prismKey: process.env.PRISM_API_KEY,
+ *     project:  "customer-support",
+ *     sessionBudgetUsd: 2.00,   // hard cap for the whole agent run
+ *   });
+ *
+ *   // MCP servers — all share session.sessionId automatically
+ *   const filesMcp  = session.createServer({ serverName: "files" });
+ *   const dbMcp     = session.createServer({ serverName: "database" });
+ *   const searchMcp = session.createServer({ serverName: "search" });
+ *
+ *   // LLM SDK client — same session_id
+ *   import { OpenAI } from "@prism-llm-labs/sdk";
+ *   const openai = new OpenAI(session.toLLMOptions());
+ */
+
+interface PrismSessionOptions {
+    /** Prism API key — or set PRISM_API_KEY env var */
+    prismKey?: string;
+    /** Project ID for cost attribution */
+    project?: string;
+    /** Team attribution tag */
+    team?: string;
+    /** "production" | "staging" | "development" */
+    environment?: string;
+    /**
+     * Explicit session ID. Auto-generated UUID if omitted.
+     * Pass an explicit ID when the session ID is determined by an external
+     * orchestrator (e.g. a LangGraph run ID, a task queue job ID).
+     */
+    sessionId?: string;
+    /** Hard cost cap across ALL servers in this session */
+    sessionBudgetUsd?: number;
+    /** Hard tool-call cap across ALL servers in this session */
+    maxToolCallsPerSession?: number;
+    /** Opt-in I/O capture for all servers created from this session */
+    captureInputs?: boolean;
+    captureOutputs?: boolean;
+    redactKeys?: string[];
+    /** Override ingest URL (for testing) */
+    ingestUrl?: string;
+}
+/** Options for individual servers within a session */
+type PerServerOptions = Omit<PrismMcpOptions, "prismKey" | "project" | "team" | "environment" | "sessionId" | "sessionBudgetUsd" | "maxToolCallsPerSession" | "captureInputs" | "captureOutputs" | "redactKeys" | "ingestUrl">;
+declare class PrismSession {
+    readonly sessionId: string;
+    private readonly key;
+    private readonly project;
+    private readonly team;
+    private readonly environment;
+    private readonly sharedOpts;
+    constructor(options?: PrismSessionOptions);
+    /**
+     * Create a PrismMCP instance bound to this session.
+     * All servers created from the same session share the same session_id.
+     */
+    createServer(perServer?: PerServerOptions): PrismMCP;
+    /**
+     * Returns options to pass to the Prism LLM SDK clients (@prism-llm-labs/sdk)
+     * so that LLM completions share this session's session_id.
+     *
+     *   import { OpenAI } from "@prism-llm-labs/sdk";
+     *   const openai = new OpenAI(session.toLLMOptions());
+     */
+    toLLMOptions(): {
+        prismKey: string;
+        project: string;
+        team: string;
+        environment: string;
+        sessionId: string;
+    };
+}
+
+declare class McpEventTracker {
+    private readonly key;
+    private readonly ingestUrl;
+    private readonly serverName;
+    private readonly orgId;
+    constructor(key: string, serverName: string, ingestUrl?: string);
+    capture(event: Omit<McpEvent, "event_id" | "org_id" | "mcp_server_name">): Promise<void>;
+}
+
+/**
+ * Session budget circuit breaker.
+ * Checks Redis session cost + tool-call counters before each tool invocation.
+ * If the UPSTASH env vars are absent, checks are skipped (graceful degradation).
+ */
+declare class SessionBudgetChecker {
+    private readonly url;
+    private readonly token;
+    private readonly orgId;
+    constructor(orgId: string);
+    /**
+     * Throws PrismSessionBudgetExceededError or PrismToolCallLimitError
+     * if the session has exceeded its configured limits.
+     */
+    checkOrThrow(sessionId: string, sessionBudgetUsd?: number, maxToolCallsPerSession?: number): Promise<void>;
+}
+
+/**
+ * Built-in tool cost estimates (USD per call).
+ * Mirrors apps/web/lib/pricing/tool-catalog.ts — keep in sync.
+ */
+/**
+ * Look up estimated cost for a tool name.
+ * Exact match, then prefix match ("pinecone_*"), then 0.
+ */
+declare function lookupToolCost(toolName: string, overrides?: Record<string, number>): number;
+
+export { type McpEvent, McpEventTracker, type McpPrimitiveType, type PerServerOptions, PrismMCP, type PrismMcpOptions, PrismSession, PrismSessionBudgetExceededError, type PrismSessionOptions, PrismToolCallLimitError, SessionBudgetChecker, WrapContext, lookupToolCost };

package/dist/index.d.ts

@@ -0,0 +1,310 @@
+type McpPrimitiveType = "tool" | "resource" | "prompt" | "sampling";
+interface McpEvent {
+    event_id: string;
+    timestamp: string;
+    session_id: string;
+    org_id: string;
+    project_id: string;
+    team_id: string;
+    user_id: string;
+    environment: string;
+    mcp_server_name: string;
+    /** tool name, resource URI, prompt name, or model hint for sampling */
+    tool_name: string;
+    downstream_resource: string;
+    execution_latency_ms: number;
+    tool_cost_usd: number;
+    status: "ok" | "error" | "timeout";
+    error_message: string;
+    llm_request_id: string;
+    primitive_type: McpPrimitiveType;
+    /**
+     * Whether tool_cost_usd is an estimate from the built-in catalog ("estimated")
+     * or a real figure provided by the tool via ctx.reportActualCost() ("actual").
+     */
+    cost_status: "estimated" | "actual";
+    tags: Record<string, string>;
+}
+interface PrismMcpOptions {
+    /** Prism API key — or set PRISM_API_KEY env var */
+    prismKey?: string;
+    /** Project ID for cost attribution */
+    project?: string;
+    /** Team attribution tag */
+    team?: string;
+    /** "production" | "staging" | "development" */
+    environment?: string;
+    /** Explicit session ID. Auto-generated UUID if omitted. */
+    sessionId?: string;
+    /** MCP server name shown in the dashboard */
+    serverName?: string;
+    /** Override ingest URL (for testing) */
+    ingestUrl?: string;
+    /**
+     * Session budget in USD. Tool/resource/prompt calls are blocked when the
+     * combined session cost exceeds this value.
+     */
+    sessionBudgetUsd?: number;
+    /**
+     * Maximum MCP primitive calls per session. Blocks further calls when exceeded.
+     * Loop detection guard — default unlimited.
+     */
+    maxToolCallsPerSession?: number;
+    /**
+     * Log call arguments into tags['tool_input'] (truncated to 1000 chars).
+     * Opt-in only — disabled by default for privacy.
+     */
+    captureInputs?: boolean;
+    /**
+     * Log call results into tags['tool_output'] (truncated to 1000 chars).
+     * Opt-in only — disabled by default for privacy.
+     */
+    captureOutputs?: boolean;
+    /**
+     * Keys to redact from captured inputs/outputs.
+     * Default: ['password', 'token', 'key', 'secret', 'api_key', 'authorization']
+     */
+    redactKeys?: string[];
+}
+declare class PrismSessionBudgetExceededError extends Error {
+    constructor(sessionId: string, budgetUsd: number);
+}
+declare class PrismToolCallLimitError extends Error {
+    constructor(sessionId: string, limit: number);
+}
+
+/**
+ * PrismMCP — instruments any MCP Server with full observability:
+ *   - tools/call   → wrapToolCall() / patchHandler()
+ *   - resources/read → wrapResourceRead() / patchResourceHandler()
+ *   - prompts/get  → wrapPromptGet() / patchPromptHandler()
+ *   - sampling/createMessage → wrapSamplingHandler()
+ *
+ * Features:
+ *   - Session budget circuit breaker (throws before execution if over budget)
+ *   - Tool loop detection (throws if max_tool_calls_per_session exceeded)
+ *   - Opt-in I/O capture (captureInputs / captureOutputs)
+ *   - Streaming tool latency: correctly measures time-to-stream-end, not first-chunk
+ */
+
+declare class WrapContext {
+    /** @internal - read by _wrap() after fn() completes */
+    _actualCostUsd: number | null;
+    /**
+     * Override the catalog-estimated tool cost with the real billing figure.
+     * Call this inside your tool handler when you have access to actual cost data
+     * (e.g. from AWS SDK response metadata, a billing header, or a usage API).
+     *
+     * @example
+     * await prismMcp.wrapToolCall("invoke_lambda", async (ctx) => {
+     *   const res = await lambda.invoke({ FunctionName: "fn", Payload: payload });
+     *   const billedMs = res.$metadata.httpHeaders?.["x-amz-billed-duration-ms"] ?? "0";
+     *   ctx.reportActualCost(parseInt(billedMs) * 0.000016667 / 1000);
+     *   return res;
+     * });
+     */
+    reportActualCost(usd: number): void;
+}
+declare class PrismMCP {
+    private readonly tracker;
+    private readonly budget;
+    private readonly redactKeys;
+    private readonly opts;
+    constructor(options?: PrismMcpOptions);
+    /**
+     * Internal wrapper used by all four MCP primitives.
+     * Handles: budget check, I/O capture, streaming proxy, fire-and-forget telemetry,
+     * and actual cost self-reporting via ctx.reportActualCost().
+     */
+    private _wrap;
+    /**
+     * Wrap a tools/call execution with Prism instrumentation.
+     */
+    wrapToolCall<T>(toolName: string, fn: (ctx: WrapContext) => Promise<T>, extra?: {
+        llmRequestId?: string;
+        tags?: Record<string, string>;
+        downstreamResource?: string;
+        /** Raw tool arguments — captured if captureInputs: true */
+        inputs?: Record<string, unknown>;
+    }): Promise<T>;
+    /**
+     * Drop-in patch for MCP SDK's CallToolRequestSchema handler.
+     * Automatically passes req.params.arguments as inputs when captureInputs: true.
+     * ctx is available for reportActualCost() inside the handler.
+     */
+    patchHandler<TReq extends {
+        params: {
+            name: string;
+            arguments?: Record<string, unknown>;
+        };
+    }, TRes>(handler: (req: TReq, ctx: WrapContext) => Promise<TRes>): (req: TReq) => Promise<TRes>;
+    /**
+     * Wrap a resources/read execution with Prism instrumentation.
+     *
+     * @param resourceUri - The resource URI being read (e.g. "file:///path/to/file")
+     */
+    wrapResourceRead<T>(resourceUri: string, fn: (ctx: WrapContext) => Promise<T>, extra?: {
+        llmRequestId?: string;
+        tags?: Record<string, string>;
+    }): Promise<T>;
+    patchResourceHandler<TReq extends {
+        params: {
+            uri: string;
+        };
+    }, TRes>(handler: (req: TReq, ctx: WrapContext) => Promise<TRes>): (req: TReq) => Promise<TRes>;
+    wrapPromptGet<T>(promptName: string, fn: (ctx: WrapContext) => Promise<T>, extra?: {
+        llmRequestId?: string;
+        tags?: Record<string, string>;
+    }): Promise<T>;
+    patchPromptHandler<TReq extends {
+        params: {
+            name: string;
+        };
+    }, TRes>(handler: (req: TReq, ctx: WrapContext) => Promise<TRes>): (req: TReq) => Promise<TRes>;
+    /**
+     * Wrap the MCP client's sampling/createMessage callback so LLM calls
+     * requested by the MCP server appear in the session timeline.
+     *
+     * Usage with @modelcontextprotocol/sdk:
+     *   client.setRequestHandler(
+     *     CreateMessageRequestSchema,
+     *     prismMcp.wrapSamplingHandler(async (req) => {
+     *       const res = await openai.chat.completions.create({ ... });
+     *       return { role: "assistant", content: [{ type: "text", text: res.choices[0].message.content }] };
+     *     })
+     *   );
+     */
+    wrapSamplingHandler<TReq extends {
+        params?: {
+            modelPreferences?: {
+                hints?: Array<{
+                    name?: string;
+                }>;
+            };
+        };
+    }, TRes>(handler: (req: TReq) => Promise<TRes>): (req: TReq) => Promise<TRes>;
+    /** The session_id assigned to this instance (useful for logging). */
+    get sessionId(): string;
+}
+
+/**
+ * PrismSession — shared session context for multi-server agent runs.
+ *
+ * Creates a single session_id that is automatically threaded through:
+ *   - Multiple PrismMCP server instances (files, database, search, etc.)
+ *   - LLM SDK clients (OpenAI, Anthropic) via toLLMOptions()
+ *
+ * This ensures every LLM call and every tool/resource/prompt call in one
+ * agent run appears under the same session in /dashboard/sessions/[id].
+ *
+ * Usage:
+ *   const session = new PrismSession({
+ *     prismKey: process.env.PRISM_API_KEY,
+ *     project:  "customer-support",
+ *     sessionBudgetUsd: 2.00,   // hard cap for the whole agent run
+ *   });
+ *
+ *   // MCP servers — all share session.sessionId automatically
+ *   const filesMcp  = session.createServer({ serverName: "files" });
+ *   const dbMcp     = session.createServer({ serverName: "database" });
+ *   const searchMcp = session.createServer({ serverName: "search" });
+ *
+ *   // LLM SDK client — same session_id
+ *   import { OpenAI } from "@prism-llm-labs/sdk";
+ *   const openai = new OpenAI(session.toLLMOptions());
+ */
+
+interface PrismSessionOptions {
+    /** Prism API key — or set PRISM_API_KEY env var */
+    prismKey?: string;
+    /** Project ID for cost attribution */
+    project?: string;
+    /** Team attribution tag */
+    team?: string;
+    /** "production" | "staging" | "development" */
+    environment?: string;
+    /**
+     * Explicit session ID. Auto-generated UUID if omitted.
+     * Pass an explicit ID when the session ID is determined by an external
+     * orchestrator (e.g. a LangGraph run ID, a task queue job ID).
+     */
+    sessionId?: string;
+    /** Hard cost cap across ALL servers in this session */
+    sessionBudgetUsd?: number;
+    /** Hard tool-call cap across ALL servers in this session */
+    maxToolCallsPerSession?: number;
+    /** Opt-in I/O capture for all servers created from this session */
+    captureInputs?: boolean;
+    captureOutputs?: boolean;
+    redactKeys?: string[];
+    /** Override ingest URL (for testing) */
+    ingestUrl?: string;
+}
+/** Options for individual servers within a session */
+type PerServerOptions = Omit<PrismMcpOptions, "prismKey" | "project" | "team" | "environment" | "sessionId" | "sessionBudgetUsd" | "maxToolCallsPerSession" | "captureInputs" | "captureOutputs" | "redactKeys" | "ingestUrl">;
+declare class PrismSession {
+    readonly sessionId: string;
+    private readonly key;
+    private readonly project;
+    private readonly team;
+    private readonly environment;
+    private readonly sharedOpts;
+    constructor(options?: PrismSessionOptions);
+    /**
+     * Create a PrismMCP instance bound to this session.
+     * All servers created from the same session share the same session_id.
+     */
+    createServer(perServer?: PerServerOptions): PrismMCP;
+    /**
+     * Returns options to pass to the Prism LLM SDK clients (@prism-llm-labs/sdk)
+     * so that LLM completions share this session's session_id.
+     *
+     *   import { OpenAI } from "@prism-llm-labs/sdk";
+     *   const openai = new OpenAI(session.toLLMOptions());
+     */
+    toLLMOptions(): {
+        prismKey: string;
+        project: string;
+        team: string;
+        environment: string;
+        sessionId: string;
+    };
+}
+
+declare class McpEventTracker {
+    private readonly key;
+    private readonly ingestUrl;
+    private readonly serverName;
+    private readonly orgId;
+    constructor(key: string, serverName: string, ingestUrl?: string);
+    capture(event: Omit<McpEvent, "event_id" | "org_id" | "mcp_server_name">): Promise<void>;
+}
+
+/**
+ * Session budget circuit breaker.
+ * Checks Redis session cost + tool-call counters before each tool invocation.
+ * If the UPSTASH env vars are absent, checks are skipped (graceful degradation).
+ */
+declare class SessionBudgetChecker {
+    private readonly url;
+    private readonly token;
+    private readonly orgId;
+    constructor(orgId: string);
+    /**
+     * Throws PrismSessionBudgetExceededError or PrismToolCallLimitError
+     * if the session has exceeded its configured limits.
+     */
+    checkOrThrow(sessionId: string, sessionBudgetUsd?: number, maxToolCallsPerSession?: number): Promise<void>;
+}
+
+/**
+ * Built-in tool cost estimates (USD per call).
+ * Mirrors apps/web/lib/pricing/tool-catalog.ts — keep in sync.
+ */
+/**
+ * Look up estimated cost for a tool name.
+ * Exact match, then prefix match ("pinecone_*"), then 0.
+ */
+declare function lookupToolCost(toolName: string, overrides?: Record<string, number>): number;
+
+export { type McpEvent, McpEventTracker, type McpPrimitiveType, type PerServerOptions, PrismMCP, type PrismMcpOptions, PrismSession, PrismSessionBudgetExceededError, type PrismSessionOptions, PrismToolCallLimitError, SessionBudgetChecker, WrapContext, lookupToolCost };