@flink-app/flink 0.14.3 → 2.0.0-alpha.48

package/src/FlinkApp.ts

@@ -9,15 +9,20 @@ import morgan from "morgan";
 import ms from "ms";
 import { AsyncTask, CronJob, SimpleIntervalJob, ToadScheduler } from "toad-scheduler";
 import { v4 } from "uuid";
+import { FlinkAgentFile } from "./ai/FlinkAgent";
+import { FlinkToolFile } from "./ai/FlinkTool";
+import { LLMAdapter } from "./ai/LLMAdapter";
+import { ToolExecutor } from "./ai/ToolExecutor";
 import { FlinkAuthPlugin } from "./auth/FlinkAuthPlugin";
 import { FlinkContext } from "./FlinkContext";
 import { FlinkError, internalServerError, notFound, unauthorized } from "./FlinkErrors";
-import { FlinkRequest, Handler, HandlerFile, HttpMethod, QueryParamMetadata, RouteProps } from "./FlinkHttpHandler";
+import { FlinkRequest, Handler, HandlerFile, HttpMethod, QueryParamMetadata, RouteProps, ValidationMode } from "./FlinkHttpHandler";
 import { FlinkJobFile } from "./FlinkJob";
 import { log } from "./FlinkLog";
 import { FlinkPlugin } from "./FlinkPlugin";
 import { FlinkRepo } from "./FlinkRepo";
 import { FlinkResponse } from "./FlinkResponse";
+import { StreamWriterFactory } from "./handlers/StreamWriterFactory";
 import generateMockData from "./mock-data-generator";
 import { formatValidationErrors, getPathParams, isError } from "./utils";
 
@@ -63,6 +68,18 @@ export const autoRegisteredRepos: {
  */
 export const autoRegisteredJobs: FlinkJobFile[] = [];
 
+/**
+ * This will be populated at compile time when the apps tools
+ * are picked up by TypeScript compiler
+ */
+export const autoRegisteredTools: FlinkToolFile[] = [];
+
+/**
+ * This will be populated at compile time when the apps agents
+ * are picked up by TypeScript compiler
+ */
+export const autoRegisteredAgents: FlinkAgentFile[] = [];
+
 export interface FlinkOptions {
     /**
      * Name of application, will only show in logs and in HTTP header.
@@ -175,6 +192,15 @@ export interface FlinkOptions {
         //     autoAssignCollection?: string;
     };
 
+    /**
+     * AI configuration for agents and tools
+     * Register LLM adapters with custom IDs (e.g., "anthropic", "openai", "anthropic-eu", etc.)
+     * This allows multiple adapters of the same type with different configurations
+     */
+    ai?: {
+        llms?: { [id: string]: LLMAdapter };
+    };
+
     /**
      * If true, the HTTP server will be disabled.
      * Only useful when starting a Flink app for testing purposes.
@@ -294,6 +320,10 @@ export class FlinkApp<C extends FlinkContext> {
 
     private repos: { [x: string]: FlinkRepo<C, any> } = {};
 
+    private llmAdapters: Map<string, LLMAdapter> = new Map();
+    private tools: { [x: string]: ToolExecutor<C> } = {};
+    private agents: { [x: string]: any } = {}; // FlinkAgent<C> instances
+
     /**
      * Internal cache used to track registered handlers and potentially any overlapping routes
      */
@@ -314,14 +344,20 @@ export class FlinkApp<C extends FlinkContext> {
         this.rawContentTypes = Array.isArray(opts.rawContentTypes)
             ? opts.rawContentTypes
             : typeof opts.rawContentTypes === "string"
-            ? [opts.rawContentTypes]
-            : undefined;
+              ? [opts.rawContentTypes]
+              : undefined;
         this.auth = opts.auth;
         this.jsonOptions = opts.jsonOptions || { limit: "1mb" };
         this.schedulingOptions = opts.scheduling;
         this.disableHttpServer = !!opts.disableHttpServer;
         this.accessLog = { enabled: true, format: "dev", ...opts.accessLog };
         this.onError = opts.onError;
+
+        // Register LLM adapters if configured
+        if (opts.ai?.llms) {
+            // Convert plain object to Map for internal use
+            this.llmAdapters = new Map(Object.entries(opts.ai.llms));
+        }
     }
 
     get ctx() {
@@ -342,6 +378,7 @@ export class FlinkApp<C extends FlinkContext> {
             log.bgColorLog("cyan", `Init db took ${offsetTime - startTime} ms`);
         }
 
+        // Build initial context (without agents - they'll be added later)
         await this.buildContext();
 
         if (this.debug) {
@@ -349,6 +386,30 @@ export class FlinkApp<C extends FlinkContext> {
             offsetTime = Date.now();
         }
 
+        // Register tools (needs context for ToolExecutor)
+        await this.registerAutoRegisterableTools();
+
+        if (this.debug) {
+            log.bgColorLog("cyan", `Register tools took ${Date.now() - offsetTime} ms`);
+            offsetTime = Date.now();
+        }
+
+        // Register agents (creates agent instances)
+        await this.registerAutoRegisterableAgents();
+
+        if (this.debug) {
+            log.bgColorLog("cyan", `Register agents took ${Date.now() - offsetTime} ms`);
+            offsetTime = Date.now();
+        }
+
+        // Initialize agents now that context and tools are ready
+        await this.initializeAgents();
+
+        if (this.debug) {
+            log.bgColorLog("cyan", `Initialize agents took ${Date.now() - offsetTime} ms`);
+            offsetTime = Date.now();
+        }
+
         if (this.isSchedulingEnabled) {
             this.scheduler = new ToadScheduler();
         } else {
@@ -519,7 +580,7 @@ export class FlinkApp<C extends FlinkContext> {
         this.handlers.push(handlerConfig);
 
         const { routeProps, schema = {} } = handlerConfig;
-        const { method } = routeProps;
+        const { method, streamFormat } = routeProps;
 
         if (!method) {
             log.error(`Route ${routeProps.path} is missing http method`);
@@ -535,11 +596,16 @@ export class FlinkApp<C extends FlinkContext> {
             let validateReq: ValidateFunction<any> | undefined;
             let validateRes: ValidateFunction<any> | undefined;
 
-            if (schema.reqSchema) {
+            // Determine validation mode (default to Validate if not specified)
+            const validationMode = routeProps.validation || ValidationMode.Validate;
+
+            // Compile request schema if validation mode requires it
+            if (schema.reqSchema && validationMode !== ValidationMode.SkipValidation && validationMode !== ValidationMode.ValidateResponse) {
                 validateReq = ajv.compile(schema.reqSchema);
             }
 
-            if (schema.resSchema) {
+            // Skip response validation for streaming handlers (responses are stream chunks, not final JSON)
+            if (!streamFormat && schema.resSchema && validationMode !== ValidationMode.SkipValidation && validationMode !== ValidationMode.ValidateRequest) {
                 validateRes = ajv.compile(schema.resSchema);
             }
 
@@ -568,7 +634,8 @@ export class FlinkApp<C extends FlinkContext> {
                     }
                 }
 
-                if (routeProps.mockApi && schema.resSchema) {
+                // Skip mock API for streaming handlers
+                if (routeProps.mockApi && schema.resSchema && !streamFormat) {
                     log.warn(`Mock response for ${req.method.toUpperCase()} ${req.path}`);
 
                     const data = generateMockData(schema.resSchema);
@@ -580,6 +647,27 @@ export class FlinkApp<C extends FlinkContext> {
                     return;
                 }
 
+                // Normalize query parameters to predictable string or string[] types
+                // Express query parser can produce numbers, booleans, objects, etc.
+                // We normalize everything to strings or string arrays for consistency
+                if (req.query && typeof req.query === "object") {
+                    const normalizedQuery: Record<string, string | string[]> = {};
+                    for (const [key, value] of Object.entries(req.query)) {
+                        if (Array.isArray(value)) {
+                            // Handle array values (e.g., ?tag=a&tag=b)
+                            normalizedQuery[key] = value.map((v) => String(v));
+                        } else if (value !== undefined && value !== null) {
+                            // Convert single values to strings
+                            normalizedQuery[key] = String(value);
+                        }
+                        // Skip undefined/null values - they won't appear in the normalized query
+                    }
+                    req.query = normalizedQuery;
+                }
+
+                // Create stream writer if streaming handler
+                const stream = streamFormat ? StreamWriterFactory.create(res, streamFormat) : undefined;
+
                 let handlerRes: FlinkResponse<any>;
 
                 try {
@@ -588,8 +676,19 @@ export class FlinkApp<C extends FlinkContext> {
                         req: req as FlinkRequest,
                         ctx: this.ctx,
                         origin: routeProps.origin,
+                        stream,
                     });
                 } catch (err: any) {
+                    // Handle errors for streaming handlers
+                    if (streamFormat && stream) {
+                        log.error(`Streaming handler error on ${req.method.toUpperCase()} ${req.path}: ${err.message}`, {
+                            error: err,
+                            path: req.path,
+                            method: req.method,
+                        });
+                        stream.error(err);
+                        return;
+                    }
                     let errorResponse: FlinkResponse<FlinkError>;
 
                     // duck typing to check if it is a FlinkError
@@ -633,6 +732,16 @@ export class FlinkApp<C extends FlinkContext> {
                     return res.status(errorResponse.status || 500).json(errorResponse);
                 }
 
+                // Skip response handling for streaming handlers (stream controls response lifecycle)
+                if (streamFormat) {
+                    return;
+                }
+
+                // Ensure handlerRes is defined for non-streaming handlers
+                if (!handlerRes) {
+                    return res.status(204).send();
+                }
+
                 if (validateRes && !isError(handlerRes)) {
                     const valid = validateRes(JSON.parse(JSON.stringify(handlerRes.data)));
 
@@ -661,7 +770,7 @@ export class FlinkApp<C extends FlinkContext> {
                 return process.exit(1); // TODO: Do we need to exit?
             } else {
                 this.handlerRouteCache.set(methodAndRoute, JSON.stringify(routeProps));
-                log.info(`Registered route ${methodAndRoute}`);
+                log.info(`Registered ${streamFormat ? 'streaming ' : ''}route ${methodAndRoute}${streamFormat ? ` (${streamFormat})` : ''}`);
             }
         }
     }
@@ -813,6 +922,151 @@ export class FlinkApp<C extends FlinkContext> {
         // repoInstance.ctx = this.ctx;
     }
 
+    private async registerAutoRegisterableTools() {
+        const { ToolExecutor } = require("./ai/ToolExecutor");
+        const { getRepoInstanceName } = require("./utils");
+
+        for (const toolFile of autoRegisteredTools) {
+            if (!toolFile.Tool) {
+                log.error(`Missing FlinkToolProps export in tool ${toolFile.__file}`);
+                continue;
+            }
+
+            if (!toolFile.default) {
+                log.error(`Missing exported tool function in tool ${toolFile.__file}`);
+                continue;
+            }
+
+            const toolId = toolFile.Tool.id;
+            if (!toolId) {
+                log.error(`Tool ${toolFile.__file} missing 'id' property`);
+                continue;
+            }
+
+            const toolInstanceName = getRepoInstanceName(toolId);
+
+            const toolExecutor = new ToolExecutor(toolFile.Tool, toolFile.default, this.ctx);
+            this.tools[toolInstanceName] = toolExecutor;
+
+            log.info(`Registered tool ${toolInstanceName} (${toolId})`);
+        }
+    }
+
+    private async registerAutoRegisterableAgents() {
+        const { getRepoInstanceName, toKebabCase } = require("./utils");
+        const { SubAgentExecutor } = require("./ai/SubAgentExecutor");
+
+        for (const agentFile of autoRegisteredAgents) {
+            // agentFile now exports a class, not a config object
+            const AgentClass = agentFile.default;
+
+            if (!AgentClass) {
+                log.error(`Missing default export in agent ${agentFile.__file}`);
+                continue;
+            }
+
+            // Instantiate agent (similar to repo instantiation)
+            const agentInstance = new AgentClass();
+
+            // Derive instance name from class name (camelCase)
+            const agentInstanceName = getRepoInstanceName(AgentClass.name);
+
+            // Get agent ID (kebab-case) - either explicit or derived
+            const agentId = agentInstance.id || toKebabCase(AgentClass.name);
+
+            // Check for duplicate instance name
+            if (this.agents[agentInstanceName]) {
+                const existingAgent = this.agents[agentInstanceName];
+                throw new Error(
+                    `Duplicate agent instance name: "${agentInstanceName}". ` +
+                    `Agent class "${AgentClass.name}" conflicts with existing agent "${existingAgent.constructor.name}". ` +
+                    `Instance names are derived by lowercasing the first letter of the class name. ` +
+                    `Rename one of the classes or use a unique explicit 'id' property.`
+                );
+            }
+
+            // Check for duplicate agent ID
+            const existingAgentWithSameId = Object.values(this.agents).find(
+                (agent: any) => {
+                    const existingId = agent.id || toKebabCase(agent.constructor.name);
+                    return existingId === agentId;
+                }
+            );
+
+            if (existingAgentWithSameId) {
+                throw new Error(
+                    `Duplicate agent ID: "${agentId}". ` +
+                    `Agent class "${AgentClass.name}" conflicts with existing agent "${existingAgentWithSameId.constructor.name}". ` +
+                    `Agent IDs are derived from class names using kebab-case (e.g., CarAgent → car-agent). ` +
+                    `Use an explicit 'id' property to resolve this conflict:\n` +
+                    `  id = "my-unique-id";`
+                );
+            }
+
+            // Validate tools exist
+            for (const toolRef of agentInstance.tools) {
+                // Handle both string IDs and tool file references
+                const toolId = typeof toolRef === "string"
+                    ? toolRef
+                    : toolRef.Tool.id; // Extract ID from FlinkToolFile
+
+                const tool = this.tools[toolId];
+
+                if (!tool) {
+                    log.error(`Agent ${AgentClass.name} references tool ${toolId} which is not registered`);
+                    throw new Error(`Invalid tool reference in agent ${AgentClass.name}`);
+                }
+            }
+
+            // Validate and register sub-agents
+            if (agentInstance.agents && agentInstance.agents.length > 0) {
+                for (const agentRef of agentInstance.agents) {
+                    // Get instance name directly from class reference or string
+                    const subAgentInstanceName = typeof agentRef === "string" ? agentRef : getRepoInstanceName(agentRef.name);
+
+                    // Validate that sub-agent will exist (will be registered in this loop)
+                    // For now, just log - actual validation happens at runtime
+                    log.debug(`Agent ${AgentClass.name} references sub-agent ${subAgentInstanceName}`);
+
+                    // Create a SubAgentExecutor as a special tool
+                    const subAgentToolName = `ask_${subAgentInstanceName}`;
+                    const subAgentExecutor = new SubAgentExecutor(subAgentInstanceName, this.ctx);
+
+                    // Register as a tool so it appears in the agent's tool list
+                    this.tools[subAgentToolName] = subAgentExecutor as any;
+                    log.debug(`Created sub-agent tool ${subAgentToolName} for ${subAgentInstanceName}`);
+                }
+            }
+
+            // Register agent (duplicate checks already performed above)
+            this.agents[agentInstanceName] = agentInstance;
+            log.info(`Registered agent ${agentInstanceName} (${AgentClass.name}) with ID: ${agentId}`);
+        }
+
+        // Second pass: validate all sub-agent references
+        for (const agentFile of autoRegisteredAgents) {
+            const AgentClass = agentFile.default;
+
+            if (!AgentClass) {
+                continue;
+            }
+
+            const agentInstance = new AgentClass();
+
+            if (agentInstance.agents && agentInstance.agents.length > 0) {
+                for (const agentRef of agentInstance.agents) {
+                    // Get instance name directly from class reference or string
+                    const subAgentInstanceName = typeof agentRef === "string" ? agentRef : getRepoInstanceName(agentRef.name);
+
+                    if (!this.agents[subAgentInstanceName]) {
+                        log.error(`Agent ${AgentClass.name} references sub-agent ${subAgentInstanceName} which is not registered`);
+                        throw new Error(`Invalid sub-agent reference in agent ${AgentClass.name}: ${subAgentInstanceName}`);
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * Constructs the app context. Will inject context in all components
      * except for handlers which are handled in later stage.
@@ -842,6 +1096,7 @@ export class FlinkApp<C extends FlinkContext> {
             repos: this.repos,
             plugins: pluginCtx,
             auth: this.auth,
+            agents: this.agents,
         } as C;
 
         for (const repo of Object.values(this.repos)) {
@@ -849,6 +1104,18 @@ export class FlinkApp<C extends FlinkContext> {
         }
     }
 
+    /**
+     * Initialize agents after they've been registered and context is ready
+     * Must be called after registerAutoRegisterableAgents()
+     */
+    private async initializeAgents() {
+        // Inject context and initialize agents
+        for (const agent of Object.values(this.agents)) {
+            agent.ctx = this.ctx;
+            agent.__init(this.llmAdapters, this.tools);
+        }
+    }
+
     /**
      * Connects to database.
      */

package/src/FlinkContext.ts

@@ -1,5 +1,6 @@
 import { FlinkAuthPlugin } from "./auth/FlinkAuthPlugin";
 import { FlinkRepo } from "./FlinkRepo";
+import { FlinkAgent } from "./ai/FlinkAgent";
 
 export interface FlinkContext<P = any> {
     repos: {
@@ -12,4 +13,25 @@ export interface FlinkContext<P = any> {
      * Type of authentication, if any.
      */
     auth?: FlinkAuthPlugin;
+
+    /**
+     * AI namespace containing agents
+     *
+     * Define agents directly in your context interface:
+     *
+     * @example
+     * interface AppCtx extends FlinkContext<PluginCtx> {
+     *     auth: JwtAuthPlugin;
+     *     repos: {
+     *         carRepo: CarRepo;
+     *     };
+     *     agents: {
+     *         carAgent: CarAgent;
+     *         userAgent: UserAgent;
+     *     };
+     * }
+     */
+    agents?: {
+        [x: string]: FlinkAgent<any>;
+    };
 }

package/src/FlinkHttpHandler.ts

@@ -12,24 +12,104 @@ export enum HttpMethod {
     patch = "patch",
 }
 
-type Params = Request["params"];
+/**
+ * Validation mode for handler request and response schemas.
+ *
+ * Controls whether request and/or response data is validated against JSON schemas.
+ *
+ * **Security Note:** Skipping validation can introduce security risks. Only use
+ * SkipValidation or ValidateResponse when you have implemented custom validation
+ * or the endpoint is internal/trusted.
+ *
+ * - Validate: Validate both request and response (default behavior)
+ * - SkipValidation: Skip both request and response validation
+ * - ValidateRequest: Validate only request, skip response validation
+ * - ValidateResponse: Validate only response, skip request validation
+ *
+ * @example
+ * ```typescript
+ * // Skip validation for webhook with custom signature verification
+ * export const Route: RouteProps = {
+ *   path: "/webhook",
+ *   validation: ValidationMode.SkipValidation
+ * };
+ *
+ * // Validate request but allow flexible response during development
+ * export const Route: RouteProps = {
+ *   path: "/api/data",
+ *   validation: ValidationMode.ValidateRequest
+ * };
+ * ```
+ */
+export enum ValidationMode {
+    Validate = "Validate",
+    SkipValidation = "SkipValidation",
+    ValidateRequest = "ValidateRequest",
+    ValidateResponse = "ValidateResponse",
+}
+
+type Params = Record<string, string>;
 
 /**
  * Query type for request query parameters.
- * Does currently not allow nested objects, although
- * underlying express Request does allow it.
  *
- * Uses index signature to allow both Record types and interface types
- * to be assignable to Query without requiring explicit index signatures.
+ * All query parameter values are normalized to strings or string arrays:
+ * - Single values: string (e.g., ?name=John becomes { name: "John" })
+ * - Multiple values: string[] (e.g., ?tag=a&tag=b becomes { tag: ["a", "b"] })
+ *
+ * Does not allow nested objects, although underlying Express Request does allow it.
  */
-type Query = {
-    [x: string]: string | string[] | undefined;
-};
+type Query = Record<string, string | string[]>;
 
 /**
- * Flink request extends express Request but adds reqId and user object.
+ * Stream format for streaming handlers.
+ * - sse: Server-Sent Events (text/event-stream)
+ * - ndjson: Newline-Delimited JSON (application/x-ndjson)
  */
-export type FlinkRequest<T = any, P = Params, Q = Query> = Request<P, any, T, Q> & { reqId: string; user?: any };
+export type StreamFormat = "sse" | "ndjson";
+
+/**
+ * Stream writer interface for SSE/NDJSON streaming.
+ *
+ * Provides methods to write data chunks, handle errors, and manage the stream lifecycle.
+ * Only available in handlers where streamFormat is specified in RouteProps.
+ */
+export interface StreamWriter<T = any> {
+    /**
+     * Write data to the stream.
+     * Data is automatically JSON-stringified and formatted according to streamFormat.
+     */
+    write(data: T): void;
+
+    /**
+     * Send error to client and close the stream.
+     */
+    error(error: Error | string): void;
+
+    /**
+     * Close the stream gracefully.
+     */
+    end(): void;
+
+    /**
+     * Check if stream is still open (client connected).
+     * Returns false if client has disconnected.
+     */
+    isOpen(): boolean;
+}
+
+/**
+ * Flink request extends express Request but adds reqId, user object, and userPermissions.
+ *
+ * userPermissions is populated by auth plugins during authentication and contains
+ * the resolved permissions array based on the plugin's configuration (roles, dynamic
+ * roles, custom permissions, etc.)
+ */
+export type FlinkRequest<T = any, P = Params, Q = Query> = Request<P, any, T, Q> & {
+    reqId: string;
+    user?: any;
+    userPermissions?: string[]; // Resolved permissions from auth plugin
+};
 
 /**
  * Route props to control routing.
@@ -64,6 +144,27 @@ export interface RouteProps {
 
     /**
      * Set permissions needed to access route if route requires authentication.
+     *
+     * When an array is provided, the user must have **ALL** permissions in the array (AND logic).
+     * To require any one of multiple permissions (OR logic), implement custom permission
+     * checking in the handler using the `user.permissions` array.
+     *
+     * @example
+     * ```typescript
+     * // Single permission
+     * permissions: "car:create"
+     *
+     * // Multiple permissions (user must have ALL)
+     * permissions: ["car:create", "car:premium"]
+     *
+     * // OR logic requires custom implementation
+     * const handler = async ({ ctx, user }) => {
+     *   if (!user.permissions.includes("car:admin") && !user.permissions.includes("car:moderator")) {
+     *     throw forbidden("Need admin or moderator permission");
+     *   }
+     *   // ... handler logic
+     * };
+     * ```
      */
     permissions?: string | string[];
 
@@ -91,16 +192,69 @@ export interface RouteProps {
      * to avoid conflicts you can set a negative order.
      */
     order?: number;
+
+    /**
+     * Validation mode for request and response schemas.
+     *
+     * Controls schema validation behavior for this handler. Use with caution as
+     * skipping validation can introduce security vulnerabilities.
+     *
+     * **Options:**
+     * - Validate: Validate both request and response (default)
+     * - SkipValidation: Skip both request and response validation
+     * - ValidateRequest: Validate only request, skip response validation
+     * - ValidateResponse: Validate only response, skip request validation
+     *
+     * **When to skip validation:**
+     * - Webhook handlers with custom signature verification
+     * - Performance-critical internal endpoints
+     * - Handlers using alternative validation methods (e.g., Zod, Joi)
+     *
+     * @default ValidationMode.Validate
+     */
+    validation?: ValidationMode;
+
+    /**
+     * Stream format for streaming handlers (SSE or NDJSON).
+     *
+     * When specified, the handler becomes a streaming handler and receives a `stream`
+     * parameter for writing data chunks. Response validation is automatically skipped
+     * for streaming handlers (chunks are progressive, not a final JSON response).
+     *
+     * **Formats:**
+     * - sse: Server-Sent Events (text/event-stream) - ideal for browser EventSource API
+     * - ndjson: Newline-Delimited JSON (application/x-ndjson) - ideal for LLM text streaming
+     *
+     * **Example:**
+     * ```typescript
+     * export const Route: RouteProps = {
+     *   path: "/ai/stream",
+     *   streamFormat: "sse"
+     * };
+     *
+     * const handler: GetHandler<{}, void> = async ({ ctx, stream }) => {
+     *   if (!stream) throw new Error("Stream not available");
+     *   stream.write({ message: "Hello" });
+     *   stream.end();
+     * };
+     * ```
+     */
+    streamFormat?: StreamFormat;
 }
 
 /**
  * Http handler function that handlers implements in order to
  * handle HTTP requests and return a JSON response.
+ *
+ * For streaming handlers (when streamFormat is specified in RouteProps),
+ * the stream parameter is available. Streaming handlers should still return
+ * a FlinkResponse (can be empty), but it will be ignored by the framework.
  */
 export type Handler<Ctx extends FlinkContext, ReqSchema = any, ResSchema = any, P extends Params = Params, Q extends Query = Query> = (props: {
     req: FlinkRequest<ReqSchema, P, Q>;
     ctx: Ctx;
     origin?: string;
+    stream?: StreamWriter;
 }) => Promise<FlinkResponse<ResSchema | FlinkError>>;
 
 /**