@useagents/redop 0.1.0 → 0.1.1

package/dist/index.js

@@ -60,8 +60,9 @@ function createSessionStore(timeoutMs) {
   function gc() {
     const now = Date.now();
     for (const [id, s] of sessions) {
-      if (now - s.lastSeen > timeoutMs)
+      if (now - s.lastSeen > timeoutMs) {
         sessions.delete(id);
+      }
     }
   }
   const gcTimer = setInterval(gc, 30000);
@@ -73,8 +74,9 @@ function createSessionStore(timeoutMs) {
     },
     touch(id) {
       const s = sessions.get(id);
-      if (!s)
+      if (!s) {
         return false;
+      }
       s.lastSeen = Date.now();
       return true;
     },
@@ -87,8 +89,9 @@ function createSessionStore(timeoutMs) {
   };
 }
 function buildCorsHeaders(cors, requestOrigin) {
-  if (!cors)
+  if (!cors) {
     return {};
+  }
   if (cors === true) {
     return {
       "Access-Control-Allow-Origin": requestOrigin ?? "*",
@@ -151,7 +154,7 @@ async function handleJsonRpc(body, tools, runner, requestMeta, serverInfo, sessi
   if (method === "tools/call") {
     const p = params;
     const toolName = p?.name;
-    if (!toolName || !tools.has(toolName)) {
+    if (!(toolName && tools.has(toolName))) {
       return {
         jsonrpc: "2.0",
         id,
@@ -554,8 +557,9 @@ class Redop {
   }
   async _runTool(toolName, rawArgs, request = DEFAULT_REQUEST_META) {
     const tool = this._tools.get(toolName);
-    if (!tool)
+    if (!tool) {
       throw new Error(`Unknown tool: ${toolName}`);
+    }
     const ctx = {
       headers: request.headers,
       requestId: crypto.randomUUID(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useagents/redop",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Bun-native MCP server framework",
   "license": "MIT",
   "keywords": [
@@ -36,7 +36,7 @@
     "prepublishOnly": "bun run build && bun test"
   },
   "devDependencies": {
-    "bun-types": "^1.3.11",
+    "@types/bun": "latest",
     "typescript": "^5.4.0"
   },
   "peerDependencies": {},

package/dist/adapters/schema.d.ts

@@ -1,7 +0,0 @@
-import type { InferSchemaOutput, SchemaAdapter, StandardSchemaV1 } from "../types";
-type JsonSchema = Record<string, unknown>;
-export declare function standardSchemaAdapter<S extends StandardSchemaV1 = StandardSchemaV1>(): SchemaAdapter<S, InferSchemaOutput<S>>;
-export declare function zodAdapter<S extends StandardSchemaV1 = StandardSchemaV1>(): SchemaAdapter<S, InferSchemaOutput<S>>;
-export declare function jsonSchemaAdapter(): SchemaAdapter<JsonSchema, JsonSchema>;
-export declare function detectAdapter(schema: unknown): SchemaAdapter;
-export {};

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-export { detectAdapter, jsonSchemaAdapter, standardSchemaAdapter, zodAdapter, } from "./adapters/schema";
-export { analytics, apiKey, bearer, cache, logger, rateLimit, } from "./plugins/index";
-export { definePlugin, middleware, Redop } from "./redop";
-export type { AfterHook, BeforeHook, Context, CorsOptions, ErrorHook, InferSchemaOutput, ListenOptions, MapResponseHook, PluginDefinition, PluginFactory, PluginMeta, RequestMeta, RedopOptions, ResolvedTool, SchemaAdapter, StandardSchemaIssue, StandardSchemaJsonOptions, StandardSchemaResultFailure, StandardSchemaResultSuccess, StandardSchemaV1, ToolHandler, ToolHandlerEvent, ToolMiddleware, ToolMiddlewareEvent, ToolNext, ToolRequest, ToolDef, ToolAfterHook, ToolAfterHookEvent, ToolBeforeHook, ToolBeforeHookEvent, TransformHook, TransportKind, } from "./types";
-export { McpError, McpErrorCode } from "./types";

package/dist/plugins/index.d.ts

@@ -1,98 +0,0 @@
-import { Redop } from "../redop";
-import type { Context, ToolHandlerEvent } from "../types";
-type LogLevel = "debug" | "info" | "warn" | "error";
-interface LoggerOptions {
-    /** Minimum log level to emit. Default: `"info"`. */
-    level?: LogLevel;
-    /** Custom write function. Defaults to console.log. */
-    write?: (entry: Record<string, unknown>) => void;
-}
-/**
- * Log tool lifecycle events using a simple structured logger.
- *
- * Default: logs `info` and above with `console.log`.
- */
-export declare function logger(opts?: LoggerOptions): Redop;
-type AnalyticsSink = "console" | "posthog" | ((event: AnalyticsEvent) => void | Promise<void>);
-interface AnalyticsEvent {
-    durationMs: number;
-    requestId: string;
-    success: boolean;
-    tool: string;
-}
-interface AnalyticsOptions {
-    /** PostHog API key (required when sink = 'posthog') */
-    apiKey?: string;
-    /** Event sink. Default: `"console"`. */
-    sink?: AnalyticsSink;
-}
-/**
- * Emit tool execution analytics to console, PostHog, or a custom sink.
- *
- * Default: writes analytics events to the console.
- */
-export declare function analytics(opts?: AnalyticsOptions): Redop;
-interface HeaderAuthOptions {
-    /** Context key to populate after successful validation. */
-    ctxKey?: string;
-    /** Header to read from. Defaults vary by helper. */
-    headerName?: string;
-    /** Whether the header must be present. Default true for HTTP transport. */
-    required?: boolean;
-    /** Static secret to validate against */
-    secret?: string;
-    /** Custom validate function — return true to allow */
-    validate?: (token: string, event: ToolHandlerEvent<unknown, Context>) => boolean | Promise<boolean>;
-}
-interface BearerOptions extends Omit<HeaderAuthOptions, "headerName"> {
-    /** Override the auth scheme prefix. Default: 'Bearer' */
-    scheme?: string;
-}
-/**
- * Validate an API key header and store the value on `ctx`.
- *
- * Default header: `x-api-key`.
- *
- * @example
- * app.use(
- *   apiKey({
- *     secret: process.env.API_SECRET,
- *     ctxKey: "apiKey",
- *   })
- * );
- */
-export declare function apiKey(opts?: HeaderAuthOptions): Redop;
-/**
- * Validate `Authorization` bearer tokens and store the parsed token on `ctx`.
- *
- * Default header: `authorization`.
- * Default scheme: `"Bearer"`.
- */
-export declare function bearer(opts?: BearerOptions): Redop;
-interface RateLimitOptions {
-    /** Key to rate-limit on. Default: IP, session, then request ID fallback. */
-    keyBy?: (event: ToolHandlerEvent<unknown, Context>) => string;
-    /** Max calls per window. Default 60. */
-    max?: number;
-    /** Window duration as ms or string like '1m', '1h'. Default '1m'. */
-    window?: number | string;
-}
-/**
- * Limit tool execution frequency in memory.
- *
- * Default: `60` calls per `"1m"` window.
- */
-export declare function rateLimit(opts?: RateLimitOptions): Redop;
-interface CacheOptions {
-    /** Tools to cache. Defaults to all. */
-    tools?: string[];
-    /** TTL in ms. Default 60_000 (1 min). */
-    ttl?: number;
-}
-/**
- * Cache successful tool results in memory by tool name and parsed input.
- *
- * Default TTL: `60_000` ms.
- */
-export declare function cache(opts?: CacheOptions): Redop;
-export {};

package/dist/redop.d.ts

@@ -1,109 +0,0 @@
-import type { AfterHook, BeforeHook, Context, ErrorHook, InferSchemaOutput, ListenOptions, MapResponseHook, RedopOptions, PluginDefinition, PluginFactory, ResolvedTool, ToolDef, ToolMiddleware, TransformHook } from "./types";
-/**
- * Bun-native framework for building MCP servers with typed tools, hooks, and plugins.
- *
- * @example
- * const app = new Redop({
- *   name: "my-mcp-server",
- *   version: "0.1.0",
- * });
- */
-export declare class Redop<C extends Context = Context> {
-    private _hooks;
-    private _tools;
-    private _middlewares;
-    private _inputParsers;
-    private _schemaAdapter?;
-    private _serverInfo;
-    private _prefix;
-    /**
-     * Create a new redop app instance.
-     */
-    constructor(options?: RedopOptions);
-    /**
-     * Register a hook that runs before middleware and the final tool handler.
-     */
-    onBeforeHandle(hook: BeforeHook<C>): this;
-    /**
-     * Register a hook that runs after a tool returns successfully.
-     */
-    onAfterHandle(hook: AfterHook<C>): this;
-    /**
-     * Register a hook that runs when middleware or a tool handler throws.
-     */
-    onError(hook: ErrorHook<C>): this;
-    /**
-     * Register a hook that can mutate raw tool params before schema parsing.
-     */
-    onTransform(hook: TransformHook<C>): this;
-    /**
-     * Register a hook that maps successful tool results before transport output.
-     */
-    mapResponse(hook: MapResponseHook): this;
-    /**
-     * Register request-aware middleware around the tool handler pipeline.
-     */
-    middleware<I = unknown>(mw: ToolMiddleware<I, unknown, C>): this;
-    /**
-     * Register a tool with optional schema validation and typed handler input.
-     * Tool-local `before` / `after` hooks are useful for per-tool analytics and post-processing.
-     *
-     * @example
-     * app.tool("search", {
-     *   input: z.object({ query: z.string() }),
-     *   handler: ({ input }) => search(input.query),
-     * });
-     */
-    tool<S, I = InferSchemaOutput<S>, O = unknown>(name: string, def: ToolDef<S, I, C, O>): this;
-    /**
-     * Register multiple tools under a shared prefix.
-     */
-    group(prefix: string, callback: (scoped: Redop<C>) => void): this;
-    /**
-     * Merge another Redop instance as a plugin into this app.
-     */
-    use(plugin: Redop): this;
-    private _runTool;
-    /**
-     * Start serving the app over HTTP or stdio.
-     */
-    listen(opts?: ListenOptions): this;
-    /**
-     * Registered tool names in their final exposed form.
-     */
-    get toolNames(): string[];
-    /**
-     * MCP server identity advertised during initialize.
-     */
-    get serverInfo(): {
-        name: string;
-        version: string;
-    };
-    getTool(name: string): ResolvedTool | undefined;
-}
-/**
- * Wrap a middleware function in a reusable Redop plugin.
- *
- * @example
- * app.use(
- *   middleware(async ({ request, next }) => {
- *     console.log(request.transport);
- *     return next();
- *   })
- * );
- */
-export declare function middleware<I = unknown, C extends Context = Context>(fn: ToolMiddleware<I, unknown, C>): Redop<C>;
-/**
- * Create a reusable plugin factory with attached metadata.
- *
- * @example
- * const notesPlugin = definePlugin({
- *   name: "notes-plugin",
- *   version: "0.1.0",
- *   setup: ({ namespace = "notes" }) =>
- *     new Redop().group(namespace, (notes) => {
- *       notes.tool("list", { handler: () => [] });
- *     }),
- * });
- */
-export declare function definePlugin<Options, C extends Context = Context>(definition: PluginDefinition<Options, C>): PluginFactory<Options, C>;

package/dist/transports/http.d.ts

@@ -1,7 +0,0 @@
-import type { ListenOptions, RequestMeta, ResolvedTool, ServerInfoOptions } from "../types";
-type ToolRunner = (toolName: string, args: Record<string, unknown>, requestMeta: RequestMeta) => Promise<unknown>;
-export declare function startHttpTransport(tools: Map<string, ResolvedTool>, runner: ToolRunner, opts: ListenOptions, serverInfo: Required<ServerInfoOptions>): {
-    stop(): void;
-    broadcast(sessionId: string, event: string, data: unknown): void;
-};
-export {};

package/dist/transports/stdio.d.ts

@@ -1,4 +0,0 @@
-import type { RequestMeta, ResolvedTool, ServerInfoOptions } from "../types";
-type ToolRunner = (toolName: string, args: Record<string, unknown>, requestMeta: RequestMeta) => Promise<unknown>;
-export declare function startStdioTransport(tools: Map<string, ResolvedTool>, runner: ToolRunner, serverInfo: Required<ServerInfoOptions>): void;
-export {};

package/dist/types.d.ts

@@ -1,328 +0,0 @@
-export interface JsonRpcRequest {
-    id: string | number | null;
-    jsonrpc: "2.0";
-    method: string;
-    params?: Record<string, unknown>;
-}
-export interface JsonRpcResponse {
-    error?: {
-        code: number;
-        message: string;
-        data?: unknown;
-    };
-    id: string | number | null;
-    jsonrpc: "2.0";
-    result?: unknown;
-}
-export interface McpToolCallParams {
-    arguments?: Record<string, unknown>;
-    name: string;
-}
-export interface McpContent {
-    data?: string;
-    mimeType?: string;
-    text?: string;
-    type: "text" | "image" | "resource";
-}
-export interface McpToolResult {
-    content: McpContent[];
-    isError?: boolean;
-}
-export declare enum McpErrorCode {
-    ParseError = -32700,
-    InvalidRequest = -32600,
-    MethodNotFound = -32601,
-    InvalidParams = -32602,
-    InternalError = -32603,
-    ToolNotFound = -32000,
-    ValidationFailed = -32001,
-    Unauthorized = -32002,
-    RateLimited = -32003,
-    Timeout = -32004
-}
-export declare class McpError extends Error {
-    readonly code: McpErrorCode;
-    readonly data?: unknown | undefined;
-    constructor(code: McpErrorCode, message: string, data?: unknown | undefined);
-}
-export type TransportKind = "http" | "stdio" | "ws";
-/**
- * Normalized transport metadata for the current tool invocation.
- */
-export interface ToolRequest {
-    /** Lowercased request headers. */
-    headers: Record<string, string>;
-    /** Client IP when the active transport can provide it. */
-    ip?: string;
-    /** HTTP method for HTTP transport requests. */
-    method?: string;
-    /** Raw HTTP Request object when transport = `http`. */
-    raw?: Request;
-    /** MCP session id for streamable HTTP sessions. */
-    sessionId?: string;
-    /** Active transport handling the request. */
-    transport: TransportKind;
-    /** Full request URL for HTTP transport requests. */
-    url?: string;
-}
-export type RequestMeta = ToolRequest;
-/**
- * Mutable bag threaded through every hook for a single request.
- * Extend with your own fields via the generic parameter.
- *
- * @example
- * type AppCtx = Context<{ userId: string; startedAt: number }>
- */
-export type Context<T extends Record<string, unknown> = Record<string, unknown>> = {
-    /** Lowercased request headers mirrored from `request.headers`. */
-    headers: Record<string, string>;
-    /** Per-request unique id generated by redop. */
-    requestId: string;
-    /** MCP session id for streamable HTTP sessions. */
-    sessionId?: string;
-    /** Fully resolved tool name. */
-    tool: string;
-    /** Active transport handling the request. */
-    transport: TransportKind;
-    /** Raw tool arguments before schema parsing. */
-    rawParams: Record<string, unknown>;
-} & T;
-/**
- * Event object passed to every tool handler.
- */
-export interface ToolHandlerEvent<I = unknown, C extends Context = Context> {
-    /** Shared mutable per-request state. */
-    ctx: C;
-    /** Parsed tool input after schema validation/coercion. */
-    input: I;
-    /** Read-only transport metadata for the current invocation. */
-    request: ToolRequest;
-    /** Fully resolved tool name. */
-    tool: string;
-}
-/**
- * Event object passed to a tool-local `before` hook.
- */
-export interface ToolBeforeHookEvent<I = unknown, C extends Context = Context> {
-    /** Shared mutable per-request state. */
-    ctx: C;
-    /** Parsed tool input after schema validation/coercion. */
-    input: I;
-    /** Read-only transport metadata for the current invocation. */
-    request: ToolRequest;
-    /** Fully resolved tool name. */
-    tool: string;
-}
-/**
- * Event object passed to a tool-local `after` hook.
- */
-export interface ToolAfterHookEvent<I = unknown, R = unknown, C extends Context = Context> extends ToolBeforeHookEvent<I, C> {
-    /** Successful result returned by middleware/handler before global after hooks. */
-    result: R;
-}
-export type ToolHandler<I, O = unknown, C extends Context = Context> = (event: ToolHandlerEvent<I, C>) => O | Promise<O>;
-export type ToolNext<R = unknown> = () => Promise<R>;
-/**
- * Event object passed to middleware.
- */
-export interface ToolMiddlewareEvent<I = unknown, C extends Context = Context, R = unknown> extends ToolHandlerEvent<I, C> {
-    /** Continue to the next middleware or final handler. */
-    next: ToolNext<R>;
-}
-export type ToolMiddleware<I = unknown, R = unknown, C extends Context = Context> = (event: ToolMiddlewareEvent<I, C, R>) => R | Promise<R>;
-export type ToolBeforeHook<I = unknown, C extends Context = Context> = (event: ToolBeforeHookEvent<I, C>) => void | Promise<void>;
-export type ToolAfterHook<I = unknown, R = unknown, C extends Context = Context> = (event: ToolAfterHookEvent<I, R, C>) => void | Promise<void>;
-/**
- * Descriptive metadata for reusable plugins.
- */
-export interface PluginMeta {
-    description?: string;
-    name: string;
-    version: string;
-}
-/**
- * Definition object used by `definePlugin(...)`.
- */
-export interface PluginDefinition<Options, C extends Context = Context> extends PluginMeta {
-    /** Create a plugin instance from a single options object. */
-    setup: (options: Options) => import("./redop").Redop<C>;
-}
-/**
- * Callable plugin factory with attached metadata for docs and introspection.
- */
-export interface PluginFactory<Options, C extends Context = Context> {
-    (options: Options): import("./redop").Redop<C>;
-    meta: PluginMeta;
-}
-export interface BeforeHookEvent<C extends Context = Context, I = unknown> {
-    ctx: C;
-    input: I;
-    params: I;
-    request: ToolRequest;
-    tool: string;
-}
-export interface AfterHookEvent<C extends Context = Context, R = unknown, I = unknown> {
-    ctx: C;
-    input: I;
-    params: I;
-    request: ToolRequest;
-    result: R;
-    tool: string;
-}
-export interface ErrorHookEvent<C extends Context = Context, I = unknown> {
-    ctx: C;
-    error: unknown;
-    input: I;
-    params: I;
-    request: ToolRequest;
-    tool: string;
-}
-export interface TransformHookEvent<C extends Context = Context> {
-    ctx: C;
-    params: Record<string, unknown>;
-    request: ToolRequest;
-    tool: string;
-}
-export type BeforeHook<C extends Context = Context> = (event: BeforeHookEvent<C>) => void | Promise<void>;
-export type AfterHook<C extends Context = Context, R = unknown> = (event: AfterHookEvent<C, R>) => void | Promise<void>;
-export type ErrorHook<C extends Context = Context> = (event: ErrorHookEvent<C>) => void | Promise<void>;
-export type TransformHook<C extends Context = Context> = (event: TransformHookEvent<C>) => void | Record<string, unknown> | Promise<void | Record<string, unknown>>;
-export type MapResponseHook<R = unknown> = (result: R, tool: string) => unknown | Promise<unknown>;
-export interface StandardSchemaResultSuccess<Output> {
-    readonly issues?: undefined;
-    readonly value: Output;
-}
-export interface StandardSchemaIssue {
-    readonly message: string;
-    readonly path?: ReadonlyArray<PropertyKey | {
-        readonly key: PropertyKey;
-    }>;
-}
-export interface StandardSchemaResultFailure {
-    readonly issues: ReadonlyArray<StandardSchemaIssue>;
-}
-export interface StandardSchemaJsonOptions {
-    readonly libraryOptions?: Record<string, unknown>;
-    readonly target: string;
-}
-export interface StandardSchemaV1<Input = unknown, Output = Input> {
-    readonly "~standard": {
-        readonly jsonSchema?: {
-            readonly input: (options: StandardSchemaJsonOptions) => Record<string, unknown>;
-            readonly output: (options: StandardSchemaJsonOptions) => Record<string, unknown>;
-        };
-        readonly validate: (value: unknown, options?: {
-            readonly libraryOptions?: Record<string, unknown>;
-        }) => StandardSchemaResultSuccess<Output> | StandardSchemaResultFailure | Promise<StandardSchemaResultSuccess<Output> | StandardSchemaResultFailure>;
-        readonly types?: {
-            readonly input: Input;
-            readonly output: Output;
-        };
-        readonly vendor: string;
-        readonly version: 1;
-    };
-}
-export type InferSchemaOutput<S> = S extends StandardSchemaV1<any, infer Output> ? Output : S extends Record<string, unknown> ? Record<string, unknown> : unknown;
-/**
- * Implement this interface to plug any schema library into redop.
- *
- * @example
- * const zodAdapter: SchemaAdapter<ZodTypeAny> = {
- *   toJsonSchema: (s) => zodToJsonSchema(s),
- *   parse:        (s, input) => s.parse(input),
- * }
- */
-export interface SchemaAdapter<S = unknown, Parsed = InferSchemaOutput<S>> {
-    /** Runtime parse + coerce. Throw on failure. */
-    parse(schema: S, input: unknown): Parsed | Promise<Parsed>;
-    /** Convert schema to JSON Schema for MCP tool descriptions */
-    toJsonSchema(schema: S): Record<string, unknown>;
-}
-/**
- * Definition object for a single MCP tool.
- */
-export interface ToolDef<S = unknown, I = InferSchemaOutput<S>, C extends Context = Context, O = unknown> {
-    /** MCP tool annotations surfaced to compatible clients. */
-    annotations?: {
-        title?: string;
-        readOnlyHint?: boolean;
-        destructiveHint?: boolean;
-        idempotentHint?: boolean;
-        openWorldHint?: boolean;
-    };
-    /** Tool-local hook that runs after global before hooks and before middleware. */
-    before?: ToolBeforeHook<I, C>;
-    /** Human-friendly tool description shown in tool listings. */
-    description?: string;
-    /** Tool-local hook that runs after middleware/handler success and before global after hooks. */
-    after?: ToolAfterHook<I, O, C>;
-    /** Tool handler receiving parsed input, shared context, and request metadata. */
-    handler: ToolHandler<I, O, C>;
-    /** Schema instance (Zod, TypeBox, etc.) or plain JSON Schema object */
-    input?: S;
-}
-export interface ResolvedTool {
-    after?: ToolAfterHook<unknown, unknown>;
-    annotations?: Record<string, unknown>;
-    before?: ToolBeforeHook<unknown>;
-    description?: string;
-    handler: ToolHandler<unknown>;
-    inputSchema: Record<string, unknown>;
-    name: string;
-}
-/**
- * CORS configuration for the HTTP transport.
- */
-export interface CorsOptions {
-    /** Whether browsers may send credentials. Default: `true`. */
-    credentials?: boolean;
-    /** Allowed request headers. Default includes content type, auth, API key, and session id headers. */
-    headers?: string[];
-    /** Allowed HTTP methods. Default: `GET, POST, DELETE, OPTIONS`. */
-    methods?: string[];
-    /** Allowed origins. Default: `"*"`. */
-    origins?: string | string[];
-}
-export type TlsOptions = import("bun").TLSOptions;
-export interface ServerInfoOptions {
-    name?: string;
-    version?: string;
-}
-/**
- * Constructor options for `new Redop(...)`.
- */
-export interface RedopOptions {
-    /** MCP server identity advertised during initialize. Default: `"redop"`. */
-    name?: string;
-    /** Custom schema adapter. By default, redop auto-detects supported schemas. */
-    schemaAdapter?: SchemaAdapter;
-    /** MCP server version advertised during initialize. Default: `"0.1.0"`. */
-    version?: string;
-}
-/**
- * Runtime options for `app.listen(...)`.
- */
-export interface ListenOptions {
-    /** CORS — true = permissive dev mode. */
-    cors?: boolean | CorsOptions;
-    /** Bind address. "0.0.0.0" for all interfaces. */
-    hostname?: string;
-    /** Max request body in bytes. Default 4MB. */
-    maxBodySize?: number;
-    /** Fires once the server is bound. */
-    onListen?: (info: {
-        hostname: string;
-        port: number;
-        url: string;
-    }) => void;
-    /** MCP mount path. Defaults to "/mcp". */
-    path?: string;
-    /** TCP port (HTTP / WS only). Defaults to 3000. */
-    port?: number | string;
-    /** Idle session TTL in ms. Default 30_000. */
-    sessionTimeout?: number;
-    /** Bun TLS config */
-    tls?: TlsOptions;
-    /** Transport protocol. Auto-detects if omitted. */
-    transport?: TransportKind;
-}