Function buildAIRouterRuntimeHandler

src/server/model/aiRouter.ts:1130–1302

(args: {
  protocol: AIRouterProtocol;
  schema: z.ZodType<Record<string, unknown>>;
  runAttempts?: AIRouterRuntimeAttemptRunner;
})

}

function buildAIRouterRuntimeHandler(args: {
  protocol: AIRouterProtocol;
  schema: z.ZodType<Record<string, unknown>>;
  runAttempts?: AIRouterRuntimeAttemptRunner;
}): RequestHandler {
  return async (req, res) => {
    const start = Date.now();
    const { workspaceId, routerId } = z
      .object({
        workspaceId: z.string(),
        routerId: z.string(),
      })
      .parse(req.params);

    try {
      const requestPayload = args.schema.parse(req.body);
      const stream = requestPayload.stream === true;
      let stopKeepAlive: (() => void) | undefined;

      if (stream) {
        setAIGatewayStreamHeaders(res);
        stopKeepAlive = startAIGatewayStreamKeepAlive(res, {
          writeInitial: true,
        });
      }

      try {
        const runAttempts = args.runAttempts ?? runAIRouterAttempts;
        const outcome = await runAttempts({
          workspaceId,
          routerId,
          protocol: args.protocol,
          requestPayload,
          executeAttempt: ({ node, payload }) => {
            const gatewayHandler = buildAIRouterGatewayHandlerForNode({
              protocol: args.protocol,
              node,
            });

            if (!gatewayHandler) {
              const modelProvider = getAIRouterNodeProvider(node);

              return Promise.resolve({
                ok: false,
                committed: false,
                gatewayId: node.gatewayId,
                statusCode: 400,
                failure: {
                  message: `AI Router provider ${modelProvider ?? 'unknown'} cannot serve protocol ${args.protocol}`,
                  errorType: 'unknown',
                },
              });
            }

            return executeBufferedAIGatewayAttempt({
              req,
              protocol: args.protocol,
              node,