theokit 0.19.4 → 0.20.0

package/dist/server/define/index.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { UIMessageChunk } from 'ai';
-import { b as WebSocketLike } from '../../define-websocket-CdK94O-D.js';
-export { W as WebSocketHandler, a as WebSocketHandlerWeb, d as defineWebSocket, c as defineWebSocketWeb } from '../../define-websocket-CdK94O-D.js';
+import { W as WebSocketHandler, b as WebSocketLike } from '../../define-websocket-CdK94O-D.js';
+export { a as WebSocketHandlerWeb, d as defineWebSocket, c as defineWebSocketWeb } from '../../define-websocket-CdK94O-D.js';
 import { IncomingMessage } from 'node:http';
-import { T as TheoPlugin } from '../../plugin-types-DNJGxr4Z.js';
+import { T as TheoPlugin, f as OnRequestHook, i as PreHandlerHook, g as OnResponseHook, O as OnErrorHook } from '../../plugin-types-DNJGxr4Z.js';
 export { H as HEALTH_PATH, a as HealthRouteConfig, b as READY_PATH, c as ReadyRouteConfig, d as ReservedResponse, R as ReservedRoutes, e as defineHealthRoute, f as defineReadyRoute, s as serveReservedRoute } from '../../health-route-C0hk64_U.js';
 
 /**
@@ -64,6 +64,65 @@ interface RouteConfig<TQuery extends z.ZodType = z.ZodUndefined, TBody extends z
  */
 declare function defineRoute<TQuery extends z.ZodType = z.ZodUndefined, TBody extends z.ZodType = z.ZodUndefined, TParams extends z.ZodType = z.ZodUndefined, TCtx = unknown, TResponse = unknown>(config: RouteConfig<TQuery, TBody, TParams, TCtx, TResponse>): RouteConfig<TQuery, TBody, TParams, TCtx, TResponse>;
 
+/**
+ * M31 Phase 3 — `route()`, the fluent builder that replaces `defineRoute({...})`.
+ *
+ * Pure type-state (mirrors `tool-builder.ts`). `.query/.body/.params` set Zod schemas whose
+ * `z.infer<>` flows into the handler's `ctx`; `.handler()` is required before `.build()`. `.build()`
+ * delegates to the internal {@link defineRoute} (an identity fn), emitting the identical
+ * `RouteConfig` — the scan/execute path is UNCHANGED (identity-shape delegation, blueprint §2).
+ *
+ *   export const POST = route()
+ *     .params(z.object({ id: z.string() }))
+ *     .body(z.object({ text: z.string() }))
+ *     .handler(({ params, body }) => save(params.id, body.text))
+ *     .build()
+ */
+
+/** Compile-error carrier: `.build()` called before `.handler()`. */
+interface MissingHandlerError {
+    readonly __theokitError: 'a route needs .handler(fn) before .build()';
+}
+/**
+ * The fluent route builder. `TQuery/TBody/TParams` track the input schemas (default `z.ZodUndefined`,
+ * matching {@link RouteConfig}); `TResponse` tracks the handler return; `THandlerSet` gates `.build()`.
+ */
+interface RouteBuilder<TQuery extends z.ZodType = z.ZodUndefined, TBody extends z.ZodType = z.ZodUndefined, TParams extends z.ZodType = z.ZodUndefined, TCtx = unknown, TResponse = unknown, THandlerSet extends boolean = false> {
+    /** Set the URL search-params schema. Inferred into `ctx.query`. */
+    query<S extends z.ZodType>(schema: S): RouteBuilder<S, TBody, TParams, TCtx, TResponse, THandlerSet>;
+    /** Set the request-body schema. Inferred into `ctx.body`. */
+    body<S extends z.ZodType>(schema: S): RouteBuilder<TQuery, S, TParams, TCtx, TResponse, THandlerSet>;
+    /** Set the path-params schema. Inferred into `ctx.params`. */
+    params<S extends z.ZodType>(schema: S): RouteBuilder<TQuery, TBody, S, TCtx, TResponse, THandlerSet>;
+    /** Runtime-only validation of the handler's plain-object return (500 on mismatch). Not inferred (YAGNI). */
+    response(schema: z.ZodType): RouteBuilder<TQuery, TBody, TParams, TCtx, TResponse, THandlerSet>;
+    /** Override the HTTP status for a plain-object return (default 200; 204 for void). */
+    status(code: number): RouteBuilder<TQuery, TBody, TParams, TCtx, TResponse, THandlerSet>;
+    /** Opt out of CSRF enforcement for this route (webhooks / OAuth callbacks). */
+    csrf(disabled: false): RouteBuilder<TQuery, TBody, TParams, TCtx, TResponse, THandlerSet>;
+    /**
+     * Set the handler. Its `ctx` infers `query/body/params` from the schemas set above. Required
+     * before `.build()`.
+     */
+    handler<R>(fn: (ctx: {
+        query: z.infer<TQuery>;
+        body: z.infer<TBody>;
+        params: z.infer<TParams>;
+        request: Request;
+        ctx: TCtx;
+    }) => R | Promise<R>): RouteBuilder<TQuery, TBody, TParams, TCtx, R, true>;
+    /**
+     * Resolve to the `RouteConfig` — the SAME value `defineRoute({...})` returns. COMPILE ERROR when
+     * `.handler()` was never called.
+     */
+    build(...guard: THandlerSet extends true ? [] : [error: MissingHandlerError]): RouteConfig<TQuery, TBody, TParams, TCtx, TResponse>;
+}
+/**
+ * Start a fluent route definition. Chain `.query/.body/.params/.response/.status/.csrf` (all
+ * optional), then `.handler()` (required) and `.build()` for the `RouteConfig`.
+ */
+declare function route(): RouteBuilder;
+
 /**
  * Action wire-protocol accept mode per plan g3-server-actions-and-useaction
  * v1.2 ADR D1. Default behavior (when omitted) is `'json'`. `'form'` opts the
@@ -112,6 +171,62 @@ interface ActionConfig<TInput extends z.ZodType, TCtx = unknown> {
  */
 declare function defineAction<TInput extends z.ZodType, TCtx = unknown>(config: ActionConfig<TInput, TCtx>): ActionConfig<TInput, TCtx>;
 
+/**
+ * M31 Phase 3 — `action()`, the fluent builder that replaces `defineAction({...})`.
+ *
+ * Pure type-state (mirrors `route-builder.ts`). `.input()` (required) sets the Zod schema whose
+ * `z.infer<>` types the handler's `ctx.input`; `.handler()` (required) closes the chain. `.build()`
+ * delegates to the internal {@link defineAction} (identity) — the action-execute path is UNCHANGED.
+ *
+ *   export const createUser = action()
+ *     .input(z.object({ email: z.string().email() }))
+ *     .handler(({ input }) => createUser(input.email))
+ *     .build()
+ */
+
+/** Compile-error carrier: `.execute`/`.build()` reached before `.input()`. */
+interface MissingInputError$1 {
+    readonly __theokitError: 'call .input(schema) before .handler(fn)';
+}
+/** Compile-error carrier: `.build()` before both `.input()` and `.handler()` are set. */
+interface IncompleteActionError {
+    readonly __theokitError: 'an action needs .input(schema) and .handler(fn) before .build()';
+}
+/** A required-but-unset field. Branded so no ordinary value satisfies it (tRPC UnsetMarker). */
+type UnsetMarker$1 = 'theokit.unset' & {
+    readonly __brand: 'theokit.unset';
+};
+/**
+ * The fluent action builder. `TInput` tracks the Zod schema (drives `ctx.input` inference);
+ * `THandlerSet` gates `.build()`.
+ */
+interface ActionBuilder<TInput extends z.ZodType | UnsetMarker$1 = UnsetMarker$1, TCtx = unknown, THandlerSet extends boolean = false> {
+    /** Set the Zod input schema. Required — every action declares its input contract (zod-is-SSOT). */
+    input<S extends z.ZodType>(schema: S): ActionBuilder<S, TCtx, THandlerSet>;
+    /** Wire-protocol accept mode (`'json'` default, `'form'` for FormData multipart). */
+    accept(mode: ActionAccept): ActionBuilder<TInput, TCtx, THandlerSet>;
+    /** Opt out of CSRF enforcement for this action. */
+    csrf(disabled: false): ActionBuilder<TInput, TCtx, THandlerSet>;
+    /**
+     * Set the handler. COMPILE ERROR before `.input()` — the param type collapses to
+     * {@link MissingInputError}. `ctx.input` is inferred via `z.infer<TInput>`.
+     */
+    handler(fn: TInput extends z.ZodType ? (ctx: {
+        input: z.infer<TInput>;
+        ctx: TCtx;
+    }) => unknown : MissingInputError$1): ActionBuilder<TInput, TCtx, true>;
+    /**
+     * Resolve to the `ActionConfig` — the SAME value `defineAction({...})` returns. COMPILE ERROR when
+     * `.input()` or `.handler()` was never called.
+     */
+    build(...guard: THandlerSet extends true ? TInput extends z.ZodType ? [] : [error: IncompleteActionError] : [error: IncompleteActionError]): ActionConfig<TInput extends z.ZodType ? TInput : z.ZodType, TCtx>;
+}
+/**
+ * Start a fluent action definition. Chain `.input()` (required), optionally `.accept()` / `.csrf()`,
+ * then `.handler()` (required) and `.build()` for the `ActionConfig`.
+ */
+declare function action(): ActionBuilder;
+
 type MiddlewareHandler = (request: Request, next: (request: Request) => Promise<Response>) => Response | Promise<Response>;
 /**
  * Define a middleware handler.
@@ -119,6 +234,36 @@ type MiddlewareHandler = (request: Request, next: (request: Request) => Promise<
  */
 declare function defineMiddleware(handler: MiddlewareHandler): MiddlewareHandler;
 
+/**
+ * M31 Phase 3 — `middleware()`, the fluent builder that replaces `defineMiddleware(fn)`.
+ *
+ * A middleware IS a single function `(request, next) => Response`. The builder's `.handle()` sets it
+ * (required); `.build()` delegates to the internal {@link defineMiddleware} (identity) and returns
+ * the handler the runtime expects.
+ *
+ *   export default middleware()
+ *     .handle(async (request, next) => {
+ *       const res = await next(request)
+ *       res.headers.set('x-mw', '1')
+ *       return res
+ *     })
+ *     .build()
+ */
+
+/** Compile-error carrier: `.build()` called before `.handle()`. */
+interface MissingHandleError {
+    readonly __theokitError: 'middleware needs .handle(fn) before .build()';
+}
+/** The fluent middleware builder. `THandleSet` gates `.build()`. */
+interface MiddlewareBuilder<THandleSet extends boolean = false> {
+    /** Set the `(request, next) => Response` handler. Required before `.build()`. */
+    handle(fn: MiddlewareHandler): MiddlewareBuilder<true>;
+    /** Resolve to the `MiddlewareHandler`. COMPILE ERROR when `.handle()` was never called. */
+    build(...guard: THandleSet extends true ? [] : [error: MissingHandleError]): MiddlewareHandler;
+}
+/** Start a fluent middleware definition. Chain `.handle()` (required), then `.build()`. */
+declare function middleware(): MiddlewareBuilder;
+
 declare function uiMessageStreamResponse(chunks: AsyncIterable<UIMessageChunk>): Response;
 
 /**
@@ -225,6 +370,95 @@ declare function defineAgentTool<T extends z.ZodType, R = string>(spec: DefineAg
  */
 declare function applyTransform(tool: CustomTool, result: unknown, target: 'display' | 'transcript'): unknown;
 
+/**
+ * M31 Phase 1 — `tool()`, the fluent builder that replaces `defineAgentTool({...})`.
+ *
+ * Pure type-state (tRPC `UnsetMarker` technique, mirroring `agent-builder.ts`). The runtime is a
+ * plain accumulator; `.build()` delegates to the internal {@link defineAgentTool}, so the emitted
+ * `CustomTool` is byte-for-byte the legacy shape — the SDK/agent compile path is UNCHANGED
+ * (identity-shape delegation, blueprint §2).
+ *
+ * PURE metadata (G2 / sdk-runtime.md): a tool describes a capability; it NEVER calls an LLM.
+ *
+ *   tool('read')
+ *     .describe('Read a UTF-8 file')
+ *     .input(z.object({ path: z.string() }))
+ *     .execute(async ({ path }, ctx) => readFile(resolveInProject(ctx, path)))
+ *     .build()
+ */
+
+/** A required-but-unset builder field. Branded so no ordinary value satisfies it (tRPC UnsetMarker). */
+type UnsetMarker = 'theokit.unset' & {
+    readonly __brand: 'theokit.unset';
+};
+/** Compile-error carrier: `.execute()` called before `.input()`. */
+interface MissingInputError {
+    readonly __theokitError: 'call .input(schema) before .execute(handler)';
+}
+/** Compile-error carrier: `.build()` called before both `.input()` and `.execute()` are set. */
+interface IncompleteToolError {
+    readonly __theokitError: 'a tool needs .input(schema) and .execute(handler) before .build()';
+}
+/** The run context a tool handler receives (M7). */
+interface ToolCtx {
+    signal?: AbortSignal;
+    context?: unknown;
+}
+/**
+ * The fluent tool builder. Each method returns a NEW builder type with the relevant type parameter
+ * advanced. `TInput` tracks the Zod schema (drives `execute` input inference); `R` tracks the
+ * handler result; `THandlerSet` gates `.build()`.
+ */
+interface ToolBuilder<TName extends string = string, TInput extends z.ZodType | UnsetMarker = UnsetMarker, R = string, THandlerSet extends boolean = false> {
+    /** Set the LLM-facing description. Optional; an empty description warns at build (LLM selection). */
+    describe(description: string): ToolBuilder<TName, TInput, R, THandlerSet>;
+    /** Set the Zod input schema (must be `z.object(...)` at the root). Required before `.execute()`. */
+    input<S extends z.ZodType>(schema: S): ToolBuilder<TName, S, R, THandlerSet>;
+    /**
+     * Set the handler. COMPILE ERROR when `.input()` was not called first — the parameter type
+     * collapses to {@link MissingInputError}. The `input` argument is inferred via `z.infer<TInput>`.
+     */
+    execute<R2>(handler: TInput extends z.ZodType ? (input: z.infer<TInput>, ctx?: ToolCtx) => R2 | Promise<R2> : MissingInputError): ToolBuilder<TName, TInput, R2, true>;
+    /** M18 — map a rich handler result to the model-visible string. */
+    toModelOutput(fn: (result: R) => string): ToolBuilder<TName, TInput, R, THandlerSet>;
+    /** M18 — per-target formatters (`display` / `transcript`) for the app UI/transcript. */
+    transform(t: ToolTransform<R>): ToolBuilder<TName, TInput, R, THandlerSet>;
+    /**
+     * Resolve to the `CustomTool` — the SAME value `defineAgentTool({...})` returns. COMPILE ERROR
+     * when `.input()` or `.execute()` was never called.
+     */
+    build(...guard: THandlerSet extends true ? TInput extends z.ZodType ? [] : [error: IncompleteToolError] : [error: IncompleteToolError]): CustomTool;
+}
+/**
+ * Start a fluent tool definition. Chain `.input()` + `.execute()` (both required), optionally
+ * `.describe()` / `.toModelOutput()` / `.transform()`, then `.build()` for the `CustomTool`.
+ */
+declare function tool<TName extends string>(name: TName): ToolBuilder<TName>;
+
+/**
+ * M31 Phase 3 — `websocket()`, the fluent builder that replaces `defineWebSocket({...})`.
+ *
+ * Lifecycle setters (`onOpen/onMessage/onClose/onError`), all optional; `.build()` delegates to the
+ * internal {@link defineWebSocket} (identity) — the ws handler loading path is UNCHANGED.
+ *
+ *   export default websocket()
+ *     .onOpen((ws) => ws.send('hi'))
+ *     .onMessage((ws, data) => ws.send(`echo:${data}`))
+ *     .build()
+ */
+
+/** The fluent WebSocket builder. Each lifecycle hook is optional; `.build()` returns the handler. */
+interface WebSocketBuilder {
+    onOpen(fn: NonNullable<WebSocketHandler['onOpen']>): WebSocketBuilder;
+    onMessage(fn: NonNullable<WebSocketHandler['onMessage']>): WebSocketBuilder;
+    onClose(fn: NonNullable<WebSocketHandler['onClose']>): WebSocketBuilder;
+    onError(fn: NonNullable<WebSocketHandler['onError']>): WebSocketBuilder;
+    /** Resolve to the `WebSocketHandler` — the SAME value `defineWebSocket({...})` returns. */
+    build(): WebSocketHandler;
+}
+/** Start a fluent WebSocket definition. Chain any of the lifecycle hooks, then `.build()`. */
+declare function websocket(): WebSocketBuilder;
+
 interface ChannelHandler<TMessage = unknown> {
     onSubscribe?: (ws: WebSocketLike, room: string, req: IncomingMessage) => void;
     onMessage?: (ws: WebSocketLike, room: string, data: TMessage) => void;
@@ -279,4 +513,35 @@ declare function defineWebChannel<TMessage = unknown>(handler: WebChannelHandler
  */
 declare function defineTheoPlugin(plugin: TheoPlugin): TheoPlugin;
 
-export { type ActionAccept, type ActionConfig, type ChannelHandler, type CustomTool, type DefineAgentToolSpec, type MiddlewareHandler, type RouteConfig, type ToolTransform, type WebChannelHandler, WebSocketLike, applyTransform, defineAction, defineAgentTool, defineChannel, defineMiddleware, defineRoute, defineTheoPlugin, defineWebChannel, uiMessageStreamResponse };
+/**
+ * M31 Phase 3 — `plugin()`, the fluent builder that replaces `definePlugin({...})`.
+ *
+ * Collects lifecycle hooks + request decorations and SYNTHESIZES the `register(app)` function, so
+ * authors never write the imperative `register` body. `.build()` returns a `TheoPlugin` the plugin
+ * runner consumes UNCHANGED.
+ *
+ *   export default plugin('request-id')
+ *     .onRequest((ctx) => { ctx.ctx.requestId = crypto.randomUUID() })
+ *     .onResponse((ctx) => { ctx.response.setHeader('x-request-id', String(ctx.ctx.requestId)) })
+ *     .build()
+ */
+
+/** The fluent plugin builder. `name` is set at entry; every hook is optional and may repeat. */
+interface PluginBuilder {
+    /** Register an `onRequest` hook (runs before the CSRF gate). May be called multiple times. */
+    onRequest(fn: OnRequestHook): PluginBuilder;
+    /** Register a `preHandler` hook (after CSRF, before the route handler). */
+    preHandler(fn: PreHandlerHook): PluginBuilder;
+    /** Register an `onResponse` hook (after the handler returns). */
+    onResponse(fn: OnResponseHook): PluginBuilder;
+    /** Register an `onError` hook (error path). */
+    onError(fn: OnErrorHook): PluginBuilder;
+    /** Decorate every request with a key/value pair (available on `ctx.ctx[key]`). */
+    decorateRequest<T>(key: string, value: T): PluginBuilder;
+    /** Resolve to the `TheoPlugin` — a synthesized `{ name, register }` the runner consumes. */
+    build(): TheoPlugin;
+}
+/** Start a fluent plugin definition. `name` is required; chain hooks/decorations, then `.build()`. */
+declare function plugin(name: string): PluginBuilder;
+
+export { type ActionAccept, type ActionBuilder, type ActionConfig, type ChannelHandler, type CustomTool, type DefineAgentToolSpec, type MiddlewareBuilder, type MiddlewareHandler, type PluginBuilder, type RouteBuilder, type RouteConfig, type ToolBuilder, type ToolTransform, type WebChannelHandler, type WebSocketBuilder, WebSocketHandler, WebSocketLike, action, applyTransform, defineAction, defineAgentTool, defineChannel, defineMiddleware, defineRoute, defineTheoPlugin, defineWebChannel, middleware, plugin, route, tool, uiMessageStreamResponse, websocket };

package/dist/server/define/index.js

@@ -1,4 +1,5 @@
 import {
+  action,
   applyTransform,
   defineAction,
   defineAgentTool,
@@ -8,8 +9,13 @@ import {
   defineTheoPlugin,
   defineWebChannel,
   defineWebSocket,
-  defineWebSocketWeb
-} from "../../chunk-CWVBDUDC.js";
+  defineWebSocketWeb,
+  middleware,
+  plugin,
+  route,
+  tool,
+  websocket
+} from "../../chunk-WLKFWVOM.js";
 import {
   uiMessageStreamResponse
 } from "../../chunk-JZHT3LW7.js";
@@ -24,6 +30,7 @@ import "../../chunk-DGUM43GV.js";
 export {
   HEALTH_PATH,
   READY_PATH,
+  action,
   applyTransform,
   defineAction,
   defineAgentTool,
@@ -36,7 +43,12 @@ export {
   defineWebChannel,
   defineWebSocket,
   defineWebSocketWeb,
+  middleware,
+  plugin,
+  route,
   serveReservedRoute,
-  uiMessageStreamResponse
+  tool,
+  uiMessageStreamResponse,
+  websocket
 };
 //# sourceMappingURL=index.js.map

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
 import { RouteConfig, CustomTool } from './define/index.js';
-export { ActionAccept, ActionConfig, ChannelHandler, DefineAgentToolSpec, MiddlewareHandler, ToolTransform, WebChannelHandler, applyTransform, defineAction, defineAgentTool, defineChannel, defineMiddleware, defineRoute, defineTheoPlugin, defineWebChannel, uiMessageStreamResponse } from './define/index.js';
+export { ActionAccept, ActionBuilder, ActionConfig, ChannelHandler, DefineAgentToolSpec, MiddlewareBuilder, MiddlewareHandler, PluginBuilder, RouteBuilder, ToolBuilder, ToolTransform, WebChannelHandler, WebSocketBuilder, action, applyTransform, defineAction, defineAgentTool, defineChannel, defineMiddleware, defineRoute, defineTheoPlugin, defineWebChannel, middleware, plugin, route, tool, uiMessageStreamResponse, websocket } from './define/index.js';
 export { W as WebSocketHandler, a as WebSocketHandlerWeb, b as WebSocketLike, d as defineWebSocket, c as defineWebSocketWeb } from '../define-websocket-CdK94O-D.js';
 export { H as HEALTH_PATH, a as HealthRouteConfig, b as READY_PATH, c as ReadyRouteConfig, d as ReservedResponse, R as ReservedRoutes, e as defineHealthRoute, f as defineReadyRoute, s as serveReservedRoute } from '../health-route-C0hk64_U.js';
 export { B as BATCH_PATH, a as BatchExecuteFn, b as BatchPathConflictError, c as BatchPayload, d as BatchRequestItem, e as BatchResponse, f as BatchResultItem, C as CookieOptions, g as CorsConfig, h as CorsHandler, i as CorsOrigin, j as CorsWebHandler, k as CustomErrorPages, E as ExecuteActionOptions, l as ExecuteRouteContext, H as HandleBatchOptions, M as MAX_ERROR_HTML_BYTES, m as MiddlewareResult, N as NotFoundError, S as STRIPPED_HEADERS, n as SendErrorInput, o as SendErrorOptions, T as TRACE_HEADER, p as TRACE_PARENT_HEADER, q as TheoError, r as TheoTransformer, _ as _resetMiddlewareCacheForTests, s as appendCookieToHeaders, t as appendDeleteCookieToHeaders, u as createCorsHandler, v as createCorsWebHandler, w as deleteCookie, x as envelopeCodeToStatus, y as executeAction, z as executeRoute, A as extractTraceId, D as extractTraceIdFromRequest, F as fromUnknown, G as getCookie, I as getCookieFromRequest, J as handleBatchRequest, K as handleRequestError, L as handleWebRequestError, O as jsonTransformer, P as loadCustomErrorPages, Q as matchesOrigin, R as parseCookieHeader, U as parseTraceparent, V as resolveTransformer, W as runMiddlewareAndContext, X as sendError, Y as sendJson, Z as serializeCookie, $ as serveStaticFile, a0 as serverErrorToEnvelope, a1 as setCookie, a2 as superjsonTransformer } from '../index-B40qUSrQ.js';

package/dist/server/index.js

@@ -165,17 +165,24 @@ import "../chunk-6NEXVBPY.js";
 import "../chunk-7MQOHNHE.js";
 import "../chunk-X2VVCJ4V.js";
 import {
+  action,
   applyTransform,
   defineAction,
   defineAgentTool,
   defineChannel,
   defineMiddleware,
+  definePlugin,
   defineRoute,
   defineTheoPlugin,
   defineWebChannel,
   defineWebSocket,
-  defineWebSocketWeb
-} from "../chunk-CWVBDUDC.js";
+  defineWebSocketWeb,
+  middleware,
+  plugin,
+  route,
+  tool,
+  websocket
+} from "../chunk-WLKFWVOM.js";
 import {
   uiMessageStreamResponse
 } from "../chunk-JZHT3LW7.js";
@@ -1218,9 +1225,9 @@ function createVendorAgentTool(config) {
 
 // src/server/agent/code-mode.ts
 var CodeModePermissionDeniedError = class extends Error {
-  constructor(tool, reason) {
+  constructor(tool2, reason) {
     const suffix = reason ? `: ${reason}` : "";
-    super(`code-mode: tool '${tool}' denied by permission gate${suffix}`);
+    super(`code-mode: tool '${tool2}' denied by permission gate${suffix}`);
     this.name = "CodeModePermissionDeniedError";
   }
 };
@@ -1237,11 +1244,11 @@ function createCodeMode(config) {
     );
   }
   const api = {};
-  for (const tool of config.tools) {
-    api[tool.name] = async (args) => {
-      const decision = await config.onPermissionRequest({ tool: tool.name, args });
-      if (!decision.granted) throw new CodeModePermissionDeniedError(tool.name, decision.reason);
-      return tool.handler(args);
+  for (const tool2 of config.tools) {
+    api[tool2.name] = async (args) => {
+      const decision = await config.onPermissionRequest({ tool: tool2.name, args });
+      if (!decision.granted) throw new CodeModePermissionDeniedError(tool2.name, decision.reason);
+      return tool2.handler(args);
     };
   }
   return {
@@ -1349,11 +1356,6 @@ function deserializeResponse(serialized) {
   return superjson.deserialize(serialized);
 }
 
-// src/server/plugin-types.ts
-function definePlugin(plugin) {
-  return plugin;
-}
-
 // src/server/index.ts
 if (typeof globalThis !== "undefined") {
   const WARN_KEY = "__theokit_server_umbrella_warn_emitted__";
@@ -1429,6 +1431,7 @@ export {
   _resetKeyCacheForTests,
   _resetMiddlewareCacheForTests,
   _resetWarnOnceForTests,
+  action,
   appendCookieToHeaders,
   appendDeleteCookieToHeaders,
   applySecurityHeaders,
@@ -1542,6 +1545,7 @@ export {
   matchRoute,
   matchRoutePattern,
   matchesOrigin,
+  middleware,
   normalizeLegacy,
   normalizeNew,
   parseChannelPath,
@@ -1549,6 +1553,7 @@ export {
   parseRequestBody,
   parseTraceparent,
   pkceChallengeFromVerifier,
+  plugin,
   readAppResource,
   readRawBody,
   recordAttempt,
@@ -1560,6 +1565,7 @@ export {
   revalidateTag,
   rotateIfNeeded,
   rotateIfNeededWeb,
+  route,
   runMiddlewareAndContext,
   safeAudit,
   scanCrons,
@@ -1581,6 +1587,7 @@ export {
   setCookie,
   superjsonTransformer,
   timingSafeEqual,
+  tool,
   totpUri,
   trackAgentRun,
   trackAgentTools,
@@ -1602,6 +1609,7 @@ export {
   verifyOAuthState,
   verifyTotp,
   warnOnce,
+  websocket,
   writeCronManifest,
   writeJobManifest,
   writeManifest