@useagents/redop 0.1.0

package/dist/index.js

@@ -0,0 +1,925 @@
+// src/adapters/schema.ts
+function hasRecordShape(value) {
+  return typeof value === "object" && value !== null;
+}
+function isStandardSchema(schema) {
+  if (!hasRecordShape(schema) || !("~standard" in schema))
+    return false;
+  const standard = schema["~standard"];
+  return hasRecordShape(standard) && typeof standard.validate === "function" && standard.version === 1;
+}
+function isJsonSchema(schema) {
+  return hasRecordShape(schema) && (("type" in schema) || ("properties" in schema) || ("$schema" in schema));
+}
+function hasJsonSchemaSupport(schema) {
+  return typeof schema["~standard"].jsonSchema?.input === "function";
+}
+function createValidationError(issues) {
+  const error = new Error("Validation failed");
+  error.issues = issues;
+  return error;
+}
+function standardSchemaAdapter() {
+  return {
+    toJsonSchema(schema) {
+      if (!hasJsonSchemaSupport(schema)) {
+        throw new Error("[redop] Schema provides validation but not JSON Schema generation. Pass an explicit schemaAdapter.");
+      }
+      return schema["~standard"].jsonSchema.input({
+        target: "draft-07"
+      });
+    },
+    async parse(schema, input) {
+      const result = await schema["~standard"].validate(input);
+      if (result.issues) {
+        throw createValidationError(result.issues);
+      }
+      return result.value;
+    }
+  };
+}
+function zodAdapter() {
+  return standardSchemaAdapter();
+}
+function jsonSchemaAdapter() {
+  return {
+    toJsonSchema: (schema) => schema,
+    parse: (_schema, input) => input
+  };
+}
+function detectAdapter(schema) {
+  if (isStandardSchema(schema))
+    return standardSchemaAdapter();
+  if (isJsonSchema(schema))
+    return jsonSchemaAdapter();
+  throw new Error("[redop] Could not detect schema type. Pass a Standard Schema-compatible instance or a plain JSON Schema object.");
+}
+// src/transports/http.ts
+function createSessionStore(timeoutMs) {
+  const sessions = new Map;
+  function gc() {
+    const now = Date.now();
+    for (const [id, s] of sessions) {
+      if (now - s.lastSeen > timeoutMs)
+        sessions.delete(id);
+    }
+  }
+  const gcTimer = setInterval(gc, 30000);
+  return {
+    create() {
+      const id = crypto.randomUUID();
+      sessions.set(id, { id, createdAt: Date.now(), lastSeen: Date.now() });
+      return id;
+    },
+    touch(id) {
+      const s = sessions.get(id);
+      if (!s)
+        return false;
+      s.lastSeen = Date.now();
+      return true;
+    },
+    delete(id) {
+      sessions.delete(id);
+    },
+    stop() {
+      clearInterval(gcTimer);
+    }
+  };
+}
+function buildCorsHeaders(cors, requestOrigin) {
+  if (!cors)
+    return {};
+  if (cors === true) {
+    return {
+      "Access-Control-Allow-Origin": requestOrigin ?? "*",
+      "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization, X-API-Key, Mcp-Session-Id",
+      "Access-Control-Allow-Credentials": "true"
+    };
+  }
+  const origins = Array.isArray(cors.origins) ? cors.origins : cors.origins ? [cors.origins] : ["*"];
+  const allowedOrigin = requestOrigin && origins.includes(requestOrigin) ? requestOrigin : origins[0] ?? "*";
+  return {
+    "Access-Control-Allow-Origin": allowedOrigin,
+    "Access-Control-Allow-Methods": (cors.methods ?? ["GET", "POST", "DELETE", "OPTIONS"]).join(", "),
+    "Access-Control-Allow-Headers": (cors.headers ?? [
+      "Content-Type",
+      "Authorization",
+      "X-API-Key",
+      "Mcp-Session-Id"
+    ]).join(", "),
+    "Access-Control-Allow-Credentials": String(cors.credentials ?? true)
+  };
+}
+function getRequestHeaders(headers) {
+  return Object.fromEntries(Array.from(headers.entries()).map(([key, value]) => [
+    key.toLowerCase(),
+    value
+  ]));
+}
+async function handleJsonRpc(body, tools, runner, requestMeta, serverInfo, sessionId) {
+  const { id, method, params } = body;
+  if (method === "initialize") {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: { listChanged: false } },
+        serverInfo,
+        sessionId
+      }
+    };
+  }
+  if (method === "ping") {
+    return { jsonrpc: "2.0", id, result: {} };
+  }
+  if (method === "tools/list") {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        tools: Array.from(tools.values()).map((t) => ({
+          name: t.name,
+          description: t.description ?? "",
+          inputSchema: t.inputSchema,
+          ...t.annotations ? { annotations: t.annotations } : {}
+        }))
+      }
+    };
+  }
+  if (method === "tools/call") {
+    const p = params;
+    const toolName = p?.name;
+    if (!toolName || !tools.has(toolName)) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: -32602,
+          message: `Unknown tool: ${toolName ?? "(none)"}`
+        }
+      };
+    }
+    try {
+      const result = await runner(toolName, p?.arguments ?? {}, requestMeta);
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+          isError: false
+        }
+      };
+    } catch (err) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          content: [
+            {
+              type: "text",
+              text: String(err instanceof Error ? err.message : err)
+            }
+          ],
+          isError: true
+        }
+      };
+    }
+  }
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: { code: -32601, message: `Method not found: ${method}` }
+  };
+}
+function startHttpTransport(tools, runner, opts, serverInfo) {
+  const port = Number(opts.port ?? 3000);
+  const hostname = opts.hostname ?? "localhost";
+  const mcpPath = opts.path ?? "/mcp";
+  const sessionTimeout = opts.sessionTimeout ?? 30000;
+  const maxBodySize = opts.maxBodySize ?? 4 * 1024 * 1024;
+  const sessions = createSessionStore(sessionTimeout);
+  const sseClients = new Map;
+  const server = Bun.serve({
+    port,
+    hostname,
+    ...opts.tls ? { tls: opts.tls } : {},
+    async fetch(req, server2) {
+      const url2 = new URL(req.url);
+      const origin = req.headers.get("origin");
+      const corsHeaders = buildCorsHeaders(opts.cors, origin);
+      if (req.method === "OPTIONS") {
+        return new Response(null, { status: 204, headers: corsHeaders });
+      }
+      if (req.method === "GET" && url2.pathname === `${mcpPath}/health`) {
+        return Response.json({ ok: true, tools: tools.size }, { headers: corsHeaders });
+      }
+      if (req.method === "GET" && url2.pathname === `${mcpPath}/schema`) {
+        const schema = {
+          openapi: "3.1.0",
+          info: {
+            title: `${serverInfo.name} MCP server`,
+            version: serverInfo.version
+          },
+          paths: Object.fromEntries(Array.from(tools.values()).map((t) => [
+            `/tools/${t.name}`,
+            {
+              post: {
+                summary: t.description,
+                requestBody: {
+                  content: { "application/json": { schema: t.inputSchema } }
+                }
+              }
+            }
+          ]))
+        };
+        return Response.json(schema, { headers: corsHeaders });
+      }
+      if (req.method === "GET" && url2.pathname === mcpPath) {
+        let sessionId = req.headers.get("mcp-session-id") ?? "";
+        if (!sessions.touch(sessionId)) {
+          sessionId = sessions.create();
+        }
+        const stream = new ReadableStream({
+          start(controller) {
+            sseClients.set(sessionId, controller);
+            const event = `event: endpoint
+data: ${JSON.stringify({
+              uri: `${url2.origin}${mcpPath}`,
+              sessionId
+            })}
+
+`;
+            controller.enqueue(new TextEncoder().encode(event));
+          },
+          cancel() {
+            sseClients.delete(sessionId);
+            sessions.delete(sessionId);
+          }
+        });
+        return new Response(stream, {
+          headers: {
+            ...corsHeaders,
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "Mcp-Session-Id": sessionId
+          }
+        });
+      }
+      if (req.method === "POST" && url2.pathname === mcpPath) {
+        const contentLength = Number(req.headers.get("content-length") ?? 0);
+        if (contentLength > maxBodySize) {
+          return new Response("Payload Too Large", {
+            status: 413,
+            headers: corsHeaders
+          });
+        }
+        let body;
+        try {
+          body = await req.json();
+        } catch {
+          return Response.json({
+            jsonrpc: "2.0",
+            id: null,
+            error: { code: -32700, message: "Parse error" }
+          }, { status: 400, headers: corsHeaders });
+        }
+        let sessionId = req.headers.get("mcp-session-id") ?? "";
+        if (!sessions.touch(sessionId)) {
+          sessionId = sessions.create();
+        }
+        const result = await handleJsonRpc(body, tools, runner, {
+          headers: getRequestHeaders(req.headers),
+          ip: server2.requestIP(req)?.address,
+          method: req.method,
+          raw: req,
+          sessionId,
+          transport: "http",
+          url: req.url
+        }, serverInfo, sessionId);
+        return Response.json(result, {
+          headers: {
+            ...corsHeaders,
+            "Mcp-Session-Id": sessionId
+          }
+        });
+      }
+      if (req.method === "DELETE" && url2.pathname === mcpPath) {
+        const sessionId = req.headers.get("mcp-session-id") ?? "";
+        const ctrl = sseClients.get(sessionId);
+        if (ctrl) {
+          try {
+            ctrl.close();
+          } catch {}
+          sseClients.delete(sessionId);
+        }
+        sessions.delete(sessionId);
+        return Response.json({ ok: true, sessionId: sessionId || null, terminated: true }, { headers: corsHeaders });
+      }
+      return new Response("Not Found", { status: 404, headers: corsHeaders });
+    },
+    error(err) {
+      console.error("[redop] server error:", err);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  });
+  const url = `http${opts.tls ? "s" : ""}://${hostname}:${port}${mcpPath}`;
+  opts.onListen?.({ hostname, port, url });
+  return {
+    stop() {
+      sessions.stop();
+      server.stop();
+    },
+    broadcast(sessionId, event, data) {
+      const ctrl = sseClients.get(sessionId);
+      if (ctrl) {
+        const msg = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+        ctrl.enqueue(new TextEncoder().encode(msg));
+      }
+    }
+  };
+}
+
+// src/transports/stdio.ts
+function buildToolList(tools) {
+  return Array.from(tools.values()).map((t) => ({
+    name: t.name,
+    description: t.description ?? "",
+    inputSchema: t.inputSchema,
+    ...t.annotations ? { annotations: t.annotations } : {}
+  }));
+}
+async function handleMessage(msg, tools, runner, serverInfo) {
+  const { id, method, params } = msg;
+  const respond = (result) => process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + `
+`);
+  const error = (code, message) => process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + `
+`);
+  if (method === "initialize") {
+    respond({
+      protocolVersion: "2024-11-05",
+      capabilities: { tools: { listChanged: false } },
+      serverInfo
+    });
+    return;
+  }
+  if (method === "notifications/initialized") {
+    return;
+  }
+  if (method === "ping") {
+    respond({});
+    return;
+  }
+  if (method === "tools/list") {
+    respond({ tools: buildToolList(tools) });
+    return;
+  }
+  if (method === "tools/call") {
+    const p = params;
+    const toolName = p?.name;
+    if (!toolName || !tools.has(toolName)) {
+      error(-32602, `Unknown tool: ${toolName ?? "(none)"}`);
+      return;
+    }
+    try {
+      const result = await runner(toolName, p?.arguments ?? {}, {
+        headers: {},
+        transport: "stdio"
+      });
+      respond({
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        isError: false
+      });
+    } catch (err) {
+      respond({
+        content: [
+          { type: "text", text: String(err instanceof Error ? err.message : err) }
+        ],
+        isError: true
+      });
+    }
+    return;
+  }
+  error(-32601, `Method not found: ${method}`);
+}
+function startStdioTransport(tools, runner, serverInfo) {
+  process.stdin.setEncoding("utf8");
+  let buffer = "";
+  process.stdin.on("data", async (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      let msg;
+      try {
+        msg = JSON.parse(trimmed);
+      } catch {
+        process.stdout.write(JSON.stringify({
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: -32700, message: "Parse error" }
+        }) + `
+`);
+        continue;
+      }
+      await handleMessage(msg, tools, runner, serverInfo);
+    }
+  });
+  process.stdin.on("end", () => process.exit(0));
+  process.stdin.resume();
+}
+
+// src/redop.ts
+var DEFAULT_REQUEST_META = {
+  headers: {},
+  transport: "stdio"
+};
+var DEFAULT_SERVER_INFO = {
+  name: "redop",
+  version: "0.1.0"
+};
+
+class Redop {
+  _hooks = {
+    before: [],
+    after: [],
+    error: [],
+    transform: [],
+    mapResponse: []
+  };
+  _tools = new Map;
+  _middlewares = [];
+  _inputParsers = new Map;
+  _schemaAdapter;
+  _serverInfo = { ...DEFAULT_SERVER_INFO };
+  _prefix = "";
+  constructor(options = {}) {
+    const serverInfo = {
+      ...DEFAULT_SERVER_INFO,
+      ...options.name ? { name: options.name } : {},
+      ...options.version ? { version: options.version } : {}
+    };
+    this._serverInfo = serverInfo;
+    if (options?.schemaAdapter) {
+      this._schemaAdapter = options.schemaAdapter;
+    }
+  }
+  onBeforeHandle(hook) {
+    this._hooks.before.push(hook);
+    return this;
+  }
+  onAfterHandle(hook) {
+    this._hooks.after.push(hook);
+    return this;
+  }
+  onError(hook) {
+    this._hooks.error.push(hook);
+    return this;
+  }
+  onTransform(hook) {
+    this._hooks.transform.push(hook);
+    return this;
+  }
+  mapResponse(hook) {
+    this._hooks.mapResponse.push(hook);
+    return this;
+  }
+  middleware(mw) {
+    this._middlewares.push(mw);
+    return this;
+  }
+  tool(name, def) {
+    const fullName = this._prefix ? `${this._prefix}_${name}` : name;
+    let inputSchema = {
+      type: "object",
+      properties: {}
+    };
+    if (def.input) {
+      const adapter = this._schemaAdapter ?? detectAdapter(def.input);
+      inputSchema = adapter.toJsonSchema(def.input);
+      this._inputParsers.set(fullName, (input) => adapter.parse(def.input, input));
+    }
+    this._tools.set(fullName, {
+      name: fullName,
+      before: def.before,
+      after: def.after,
+      description: def.description,
+      annotations: def.annotations,
+      inputSchema,
+      handler: def.handler
+    });
+    return this;
+  }
+  group(prefix, callback) {
+    const scoped = new Redop({
+      name: this._serverInfo.name,
+      schemaAdapter: this._schemaAdapter,
+      version: this._serverInfo.version
+    });
+    scoped._prefix = this._prefix ? `${this._prefix}_${prefix}` : prefix;
+    scoped._hooks = this._hooks;
+    scoped._middlewares = this._middlewares;
+    callback(scoped);
+    for (const [name, tool] of scoped._tools) {
+      this._tools.set(name, tool);
+    }
+    for (const [name, parser] of scoped._inputParsers) {
+      this._inputParsers.set(name, parser);
+    }
+    return this;
+  }
+  use(plugin) {
+    this._hooks.before.push(...plugin._hooks.before);
+    this._hooks.after.push(...plugin._hooks.after);
+    this._hooks.error.push(...plugin._hooks.error);
+    this._hooks.transform.push(...plugin._hooks.transform);
+    this._hooks.mapResponse.push(...plugin._hooks.mapResponse);
+    this._middlewares.push(...plugin._middlewares);
+    for (const [name, tool] of plugin._tools) {
+      this._tools.set(name, tool);
+    }
+    for (const [name, parser] of plugin._inputParsers) {
+      this._inputParsers.set(name, parser);
+    }
+    return this;
+  }
+  async _runTool(toolName, rawArgs, request = DEFAULT_REQUEST_META) {
+    const tool = this._tools.get(toolName);
+    if (!tool)
+      throw new Error(`Unknown tool: ${toolName}`);
+    const ctx = {
+      headers: request.headers,
+      requestId: crypto.randomUUID(),
+      sessionId: request.sessionId,
+      tool: toolName,
+      transport: request.transport,
+      rawParams: rawArgs
+    };
+    let params = { ...rawArgs };
+    for (const hook of this._hooks.transform) {
+      const out = await hook({ tool: toolName, params, ctx, request });
+      if (out && typeof out === "object") {
+        params = out;
+      }
+    }
+    let input = params;
+    const parser = this._inputParsers.get(toolName);
+    if (parser) {
+      try {
+        input = await parser(params);
+      } catch (err) {
+        const validationError = new Error(`Validation failed for tool "${toolName}": ${err instanceof Error ? err.message : String(err)}`);
+        validationError.cause = err;
+        if (typeof err === "object" && err !== null && "issues" in err) {
+          validationError.issues = err.issues;
+        }
+        throw validationError;
+      }
+    }
+    const handlerEvent = {
+      ctx,
+      input,
+      request,
+      tool: toolName
+    };
+    try {
+      for (const hook of this._hooks.before) {
+        await hook({
+          tool: toolName,
+          ctx,
+          input,
+          params: input,
+          request
+        });
+      }
+      if (tool.before) {
+        await tool.before(handlerEvent);
+      }
+      const dispatch = async (index) => {
+        if (index >= this._middlewares.length) {
+          return tool.handler(handlerEvent);
+        }
+        const mw = this._middlewares[index];
+        if (!mw) {
+          return tool.handler(handlerEvent);
+        }
+        return mw({
+          ...handlerEvent,
+          next: () => dispatch(index + 1)
+        });
+      };
+      let result = await dispatch(0);
+      if (tool.after) {
+        await tool.after({
+          ...handlerEvent,
+          result
+        });
+      }
+      for (const hook of this._hooks.after) {
+        await hook({
+          tool: toolName,
+          ctx,
+          input,
+          params: input,
+          request,
+          result
+        });
+      }
+      for (const hook of this._hooks.mapResponse) {
+        result = await hook(result, toolName);
+      }
+      return result;
+    } catch (err) {
+      for (const hook of this._hooks.error) {
+        await hook({
+          tool: toolName,
+          ctx,
+          error: err,
+          input,
+          params: input,
+          request
+        });
+      }
+      throw err;
+    }
+  }
+  listen(opts = {}) {
+    const runner = (name, args, requestMeta) => this._runTool(name, args, requestMeta);
+    const transport = opts.transport ?? (opts.port ? "http" : "stdio");
+    if (transport === "stdio") {
+      startStdioTransport(this._tools, runner, this._serverInfo);
+      return this;
+    }
+    if (transport === "http") {
+      startHttpTransport(this._tools, runner, opts, this._serverInfo);
+      return this;
+    }
+    throw new Error(`[redop] Unknown transport: ${transport}`);
+  }
+  get toolNames() {
+    return Array.from(this._tools.keys());
+  }
+  get serverInfo() {
+    return { ...this._serverInfo };
+  }
+  getTool(name) {
+    return this._tools.get(name);
+  }
+}
+function middleware(fn) {
+  return new Redop().middleware(fn);
+}
+function definePlugin(definition) {
+  const factory = (options) => definition.setup(options);
+  const meta = {
+    name: definition.name,
+    version: definition.version,
+    ...definition.description ? { description: definition.description } : {}
+  };
+  factory.meta = meta;
+  return factory;
+}
+
+// src/plugins/index.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function logger(opts = {}) {
+  const minLevel = LOG_LEVELS[opts.level ?? "info"];
+  const write = opts.write ?? ((e) => console.log(JSON.stringify(e)));
+  const log = (level, data) => {
+    if (LOG_LEVELS[level] >= minLevel) {
+      write({ ts: new Date().toISOString(), level, ...data });
+    }
+  };
+  return new Redop().onBeforeHandle(({ tool, ctx, request }) => {
+    log("info", {
+      event: "tool.start",
+      tool,
+      requestId: ctx.requestId,
+      transport: request.transport
+    });
+  }).onAfterHandle(({ tool, ctx }) => {
+    const ms = ctx.startedAt ? performance.now() - ctx.startedAt : undefined;
+    log("info", {
+      event: "tool.end",
+      tool,
+      requestId: ctx.requestId,
+      ...ms != null ? { ms: +ms.toFixed(2) } : {}
+    });
+  }).onError(({ tool, error, ctx }) => {
+    log("error", {
+      event: "tool.error",
+      tool,
+      requestId: ctx.requestId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  });
+}
+function analytics(opts = {}) {
+  const { sink = "console", apiKey } = opts;
+  async function emit(event) {
+    if (typeof sink === "function") {
+      await sink(event);
+      return;
+    }
+    if (sink === "console") {
+      console.log("[redop:analytics]", event);
+      return;
+    }
+    if (sink === "posthog" && apiKey) {
+      fetch("https://app.posthog.com/capture/", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          api_key: apiKey,
+          event: "redop_tool_call",
+          distinct_id: event.requestId,
+          properties: event
+        })
+      }).catch(() => {});
+    }
+  }
+  return new Redop().onBeforeHandle(({ ctx }) => {
+    ctx.startedAt = performance.now();
+    ctx.analyticsSuccess = true;
+  }).onError(({ ctx }) => {
+    ctx.analyticsSuccess = false;
+  }).onAfterHandle(({ tool, ctx }) => {
+    const startedAt = ctx.startedAt;
+    const durationMs = startedAt != null ? +(performance.now() - startedAt).toFixed(2) : 0;
+    emit({
+      tool,
+      durationMs,
+      success: ctx.analyticsSuccess ?? true,
+      requestId: ctx.requestId
+    });
+  });
+}
+function apiKey(opts = {}) {
+  return createHeaderAuthPlugin({
+    ...opts,
+    ctxKey: opts.ctxKey ?? "apiKey",
+    headerName: opts.headerName ?? "x-api-key"
+  });
+}
+function bearer(opts = {}) {
+  const scheme = opts.scheme ?? "Bearer";
+  return createHeaderAuthPlugin({
+    ...opts,
+    ctxKey: opts.ctxKey ?? "token",
+    headerName: "authorization",
+    aliases: ["authToken"],
+    transform(value) {
+      const [providedScheme, ...rest] = value.trim().split(/\s+/);
+      if (!providedScheme || providedScheme.toLowerCase() !== scheme.toLowerCase()) {
+        throw new Error(`Unauthorized: expected ${scheme} token`);
+      }
+      const token = rest.join(" ").trim();
+      if (!token) {
+        throw new Error(`Unauthorized: missing ${scheme} token`);
+      }
+      return token;
+    }
+  });
+}
+function createHeaderAuthPlugin(opts) {
+  return middleware(async ({ ctx, request, input, tool, next }) => {
+    if (request.transport !== "http")
+      return next();
+    const headerName = (opts.headerName ?? "authorization").toLowerCase();
+    const headerValue = request.headers[headerName];
+    if (!opts.secret && !opts.validate) {
+      throw new Error(`[redop] ${headerName} auth requires either a secret or validate()`);
+    }
+    if (!headerValue) {
+      if (opts.required ?? true) {
+        throw new Error(`Unauthorized: missing ${headerName} header`);
+      }
+      return next();
+    }
+    const token = opts.transform ? opts.transform(headerValue) : headerValue.trim();
+    const valid = opts.validate ? await opts.validate(token, { ctx, input, request, tool }) : token === opts.secret;
+    if (!valid) {
+      throw new Error(`Unauthorized: invalid ${headerName}`);
+    }
+    ctx[opts.ctxKey ?? "auth"] = token;
+    for (const alias of opts.aliases ?? []) {
+      ctx[alias] = token;
+    }
+    return next();
+  });
+}
+function parseWindow(w) {
+  if (typeof w === "number")
+    return w;
+  const match = w.match(/^(\d+)(ms|s|m|h|d)$/);
+  if (!match)
+    return 60000;
+  const n = match[1];
+  const unit = match[2];
+  if (!n || !unit)
+    return 60000;
+  const multipliers = {
+    ms: 1,
+    s: 1000,
+    m: 60000,
+    h: 3600000,
+    d: 86400000
+  };
+  return parseInt(n) * (multipliers[unit] ?? 1);
+}
+function defaultRateLimitKey(event) {
+  return event.request.ip ?? event.request.headers["x-forwarded-for"]?.split(",")[0]?.trim() ?? event.request.sessionId ?? event.ctx.requestId.slice(0, 8);
+}
+function rateLimit(opts = {}) {
+  const max = opts.max ?? 60;
+  const windowMs = parseWindow(opts.window ?? "1m");
+  const buckets = new Map;
+  return middleware(async (event) => {
+    const key = opts.keyBy ? opts.keyBy(event) : defaultRateLimitKey(event);
+    const now = Date.now();
+    const timestamps = (buckets.get(key) ?? []).filter((ts) => now - ts < windowMs);
+    if (timestamps.length >= max) {
+      throw new Error(`Rate limit exceeded: ${max} calls per ${windowMs}ms`);
+    }
+    timestamps.push(now);
+    buckets.set(key, timestamps);
+    return event.next();
+  });
+}
+function cache(opts = {}) {
+  const ttl = opts.ttl ?? 60000;
+  const allowedTools = opts.tools ? new Set(opts.tools) : null;
+  const store = new Map;
+  function hashKey(tool, input) {
+    return `${tool}:${JSON.stringify(input)}`;
+  }
+  return middleware(async ({ tool, input, next }) => {
+    if (allowedTools && !allowedTools.has(tool)) {
+      return next();
+    }
+    const key = hashKey(tool, input);
+    const entry = store.get(key);
+    if (entry && Date.now() < entry.expiresAt) {
+      return entry.result;
+    }
+    const result = await next();
+    store.set(key, { result, expiresAt: Date.now() + ttl });
+    return result;
+  });
+}
+// src/types.ts
+var McpErrorCode;
+((McpErrorCode2) => {
+  McpErrorCode2[McpErrorCode2["ParseError"] = -32700] = "ParseError";
+  McpErrorCode2[McpErrorCode2["InvalidRequest"] = -32600] = "InvalidRequest";
+  McpErrorCode2[McpErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound";
+  McpErrorCode2[McpErrorCode2["InvalidParams"] = -32602] = "InvalidParams";
+  McpErrorCode2[McpErrorCode2["InternalError"] = -32603] = "InternalError";
+  McpErrorCode2[McpErrorCode2["ToolNotFound"] = -32000] = "ToolNotFound";
+  McpErrorCode2[McpErrorCode2["ValidationFailed"] = -32001] = "ValidationFailed";
+  McpErrorCode2[McpErrorCode2["Unauthorized"] = -32002] = "Unauthorized";
+  McpErrorCode2[McpErrorCode2["RateLimited"] = -32003] = "RateLimited";
+  McpErrorCode2[McpErrorCode2["Timeout"] = -32004] = "Timeout";
+})(McpErrorCode ||= {});
+
+class McpError extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "McpError";
+  }
+}
+export {
+  zodAdapter,
+  standardSchemaAdapter,
+  rateLimit,
+  middleware,
+  logger,
+  jsonSchemaAdapter,
+  detectAdapter,
+  definePlugin,
+  cache,
+  bearer,
+  apiKey,
+  analytics,
+  Redop,
+  McpErrorCode,
+  McpError
+};