@burtson-labs/bandit-engine 2.0.34 → 2.0.36

package/dist/cli/cli.js

@@ -30,7 +30,7 @@ var import_commander = require("commander");
 // package.json
 var package_default = {
   name: "@burtson-labs/bandit-engine",
-  version: "2.0.34",
+  version: "2.0.36",
   license: "BUSL-1.1",
   main: "dist/index.js",
   module: "dist/index.mjs",
@@ -214,23 +214,52 @@ var buildPackageJson = (ctx) => formatJson({
     "vite": "^7.1.9"
   }
 });
-var buildEnvExample = (ctx) => ensureTrailingNewline(
-  normalizeLineEndings(
-    `# Frontend configuration
-VITE_DEV_PORT=${ctx.frontendPort}
-VITE_GATEWAY_URL=${ctx.defaultGatewayUrl}
-VITE_DEFAULT_MODEL=${ctx.defaultModelId}
-VITE_FALLBACK_MODEL=${ctx.fallbackModelId ?? ""}
-VITE_GATEWAY_PROVIDER=${ctx.defaultProvider}
-VITE_BRANDING_TEXT=${ctx.brandingText}
-
-# Gateway configuration
-# OPENAI_API_KEY=sk-................................
-# OLLAMA_URL=http://localhost:11434
-# PORT=${ctx.gatewayPort}
-`
-  )
-);
+var buildEnvExample = (ctx) => {
+  const lines = [
+    "# Frontend configuration",
+    `VITE_DEV_PORT=${ctx.frontendPort}`,
+    `VITE_GATEWAY_URL=${ctx.defaultGatewayUrl}`,
+    `VITE_DEFAULT_MODEL=${ctx.defaultModelId}`,
+    `VITE_FALLBACK_MODEL=${ctx.fallbackModelId ?? ""}`,
+    `VITE_GATEWAY_PROVIDER=${ctx.defaultProvider}`,
+    `VITE_BRANDING_TEXT=${ctx.brandingText}`,
+    "",
+    "# Gateway configuration",
+    "# These values power server/gateway.js \u2014 update them before running in production."
+  ];
+  switch (ctx.defaultProvider) {
+    case "openai":
+      lines.push("OPENAI_API_KEY=");
+      break;
+    case "azure":
+      lines.push("AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com");
+      lines.push("AZURE_OPENAI_API_KEY=");
+      lines.push("AZURE_OPENAI_API_VERSION=2024-08-01-preview");
+      lines.push("AZURE_OPENAI_CHAT_DEPLOYMENT=gpt-4o");
+      lines.push("AZURE_OPENAI_COMPLETIONS_DEPLOYMENT=gpt-35-turbo-instruct");
+      lines.push("AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT=text-embedding-3-large");
+      break;
+    case "anthropic":
+      lines.push("ANTHROPIC_API_KEY=");
+      lines.push("ANTHROPIC_BASE_URL=https://api.anthropic.com");
+      lines.push("ANTHROPIC_API_VERSION=2023-06-01");
+      lines.push("ANTHROPIC_MAX_TOKENS=1024");
+      break;
+    case "xai":
+      lines.push("XAI_API_KEY=");
+      lines.push("XAI_BASE_URL=https://api.x.ai/v1");
+      break;
+    case "ollama":
+    default:
+      lines.push("OLLAMA_URL=http://localhost:11434");
+      break;
+  }
+  lines.push(`PORT=${ctx.gatewayPort}`);
+  lines.push(
+    "# If you switch providers later, copy the relevant block above and update the credentials."
+  );
+  return ensureTrailingNewline(normalizeLineEndings(lines.join("\n")));
+};
 var buildTsConfig = () => formatJson({
   compilerOptions: {
     target: "ESNext",
@@ -429,7 +458,7 @@ const gatewayBaseUrl = (import.meta.env.VITE_GATEWAY_URL ?? "${ctx.defaultGatewa
 const defaultModelId = import.meta.env.VITE_DEFAULT_MODEL ?? "${ctx.defaultModelId}";
 const fallbackModelId = import.meta.env.VITE_FALLBACK_MODEL ?? ${ctx.fallbackModelId ? `${QUOTE}${ctx.fallbackModelId}${QUOTE}` : "undefined"};
 const brandingText = import.meta.env.VITE_BRANDING_TEXT ?? "${ctx.brandingText}";
-const provider = (import.meta.env.VITE_GATEWAY_PROVIDER ?? "${ctx.defaultProvider}") as "openai" | "ollama";
+const provider = (import.meta.env.VITE_GATEWAY_PROVIDER ?? "${ctx.defaultProvider}") as "openai" | "ollama" | "azure" | "anthropic" | "xai";
 
 const gatewayApiUrl = gatewayBaseUrl.endsWith("/api") ? gatewayBaseUrl : gatewayBaseUrl + "/api";
 const banditHeadLogoUrl = "https://cdn.burtson.ai/images/bandit-head.png";
@@ -611,7 +640,7 @@ function App() {
               {brandingText}
             </Typography>
             <Typography variant="body1" color="text.secondary">
-              Build, brand, and launch your assistant with a drop-in chat surface plus a secure gateway for OpenAI or Ollama.
+              Build, brand, and launch your assistant with a drop-in chat surface plus a secure gateway for OpenAI, Azure OpenAI, Anthropic, XAI, or Ollama.
             </Typography>
             <Stack direction={{ xs: "column", sm: "row" }} spacing={2}>
               <Button component={RouterLink} to="/chat" variant="contained" color="primary">
@@ -658,7 +687,7 @@ function App() {
                 Ship secure gateways
               </Typography>
               <Typography variant="body2" color="text.secondary">
-                Keep API keys server-side while proxying requests to OpenAI or Ollama through the included Express gateway.
+                Keep API keys server-side while proxying requests to OpenAI, Azure OpenAI, Anthropic, XAI, or Ollama through the included Express gateway.
               </Typography>
             </CardContent>
           </Card>
@@ -820,6 +849,664 @@ var buildBrandingConfig = (ctx) => formatJson({
   },
   knowledgeDocs: []
 });
+var NEXT_CHAT_ROUTE_TEMPLATE = `import { NextRequest, NextResponse } from "next/server";
+
+export const dynamic = "force-dynamic";
+
+const DEFAULT_PROVIDER = "__DEFAULT_PROVIDER__";
+const DEFAULT_MODEL = "__DEFAULT_MODEL__";
+const FALLBACK_MODEL = __FALLBACK_MODEL__;
+
+const OLLAMA_URL = (process.env.OLLAMA_URL ?? "http://localhost:11434").replace(/\\/$/, "");
+const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+const AZURE_OPENAI_ENDPOINT = process.env.AZURE_OPENAI_ENDPOINT ? process.env.AZURE_OPENAI_ENDPOINT.replace(/\\/$/, "") : undefined;
+const AZURE_OPENAI_API_KEY = process.env.AZURE_OPENAI_API_KEY;
+const AZURE_OPENAI_API_VERSION = process.env.AZURE_OPENAI_API_VERSION ?? "2024-08-01-preview";
+const AZURE_OPENAI_CHAT_DEPLOYMENT = process.env.AZURE_OPENAI_CHAT_DEPLOYMENT;
+const AZURE_OPENAI_COMPLETIONS_DEPLOYMENT = process.env.AZURE_OPENAI_COMPLETIONS_DEPLOYMENT ?? AZURE_OPENAI_CHAT_DEPLOYMENT;
+const AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT = process.env.AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT;
+const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+const ANTHROPIC_BASE_URL = (process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com").replace(/\\/$/, "");
+const ANTHROPIC_API_VERSION = process.env.ANTHROPIC_API_VERSION ?? "2023-06-01";
+const ANTHROPIC_MAX_TOKENS = Number.isFinite(Number(process.env.ANTHROPIC_MAX_TOKENS))
+  ? Number(process.env.ANTHROPIC_MAX_TOKENS)
+  : 1024;
+const XAI_API_KEY = process.env.XAI_API_KEY;
+const XAI_BASE_URL = (process.env.XAI_BASE_URL ?? "https://api.x.ai/v1").replace(/\\/$/, "");
+
+interface GatewayChatBody {
+  provider?: string;
+  model?: string;
+  messages?: Array<{ role: string; content: unknown }>;
+  prompt?: string;
+  stream?: boolean;
+  temperature?: number;
+  max_tokens?: number;
+  top_p?: number;
+  stop?: string | string[];
+  stop_sequences?: string | string[];
+  tools?: unknown;
+  tool_choice?: unknown;
+  metadata?: unknown;
+  thinking?: unknown;
+  images?: string[];
+  [key: string]: unknown;
+}
+
+const normalizeProvider = (input: string): "openai" | "azure" | "anthropic" | "ollama" | "xai" => {
+  const value = input.toLowerCase();
+  if (value === "azure-openai" || value === "azureopenai" || value === "azure") return "azure";
+  if (value === "anthropic" || value === "claude") return "anthropic";
+  if (value === "ollama") return "ollama";
+  if (value === "xai" || value === "grok") return "xai";
+  return "openai";
+};
+
+const stripPrefix = (model: unknown, prefix: string, fallback: string): string => {
+  if (typeof model === "string") {
+    return model.replace(new RegExp(\`^\${prefix}:\`), "");
+  }
+  return fallback;
+};
+
+const requireOpenAIKey = () => {
+  if (!OPENAI_API_KEY) {
+    throw new Error("Missing OPENAI_API_KEY. Add it to your .env file to route requests to OpenAI.");
+  }
+  return OPENAI_API_KEY;
+};
+
+const requireXAIKey = () => {
+  if (!XAI_API_KEY) {
+    throw new Error("Missing XAI_API_KEY. Add it to your .env file to route requests to xAI.");
+  }
+  return XAI_API_KEY;
+};
+
+const requireAnthropicKey = () => {
+  if (!ANTHROPIC_API_KEY) {
+    throw new Error("Missing ANTHROPIC_API_KEY. Add it to your .env file to route requests to Anthropic.");
+  }
+  return ANTHROPIC_API_KEY;
+};
+
+const isAzureConfigured = () => Boolean(AZURE_OPENAI_ENDPOINT && AZURE_OPENAI_API_KEY);
+
+const requireAzureBaseConfig = () => {
+  if (!AZURE_OPENAI_ENDPOINT) {
+    throw new Error("Missing AZURE_OPENAI_ENDPOINT. Add it to your .env file to route requests to Azure OpenAI.");
+  }
+  if (!AZURE_OPENAI_API_KEY) {
+    throw new Error("Missing AZURE_OPENAI_API_KEY. Add it to your .env file to route requests to Azure OpenAI.");
+  }
+  return {
+    endpoint: AZURE_OPENAI_ENDPOINT,
+    apiKey: AZURE_OPENAI_API_KEY,
+  };
+};
+
+const buildAzureDeploymentUrl = (deployment: string | undefined, suffix: string) => {
+  if (!deployment) {
+    throw new Error(\`Missing Azure OpenAI \${suffix.split("/")[0]} deployment name.\`);
+  }
+  const { endpoint } = requireAzureBaseConfig();
+  const normalized = suffix.replace(/^\\/+/, "");
+  return \`\${endpoint}/openai/deployments/\${deployment}/\${normalized}?api-version=\${AZURE_OPENAI_API_VERSION}\`;
+};
+
+const resolveAzureDeployment = (model: unknown, fallback: string | undefined, kind: "chat" | "completions" | "embeddings") => {
+  const explicit = typeof model === "string" ? model.replace(/^azure:/, "") : undefined;
+  if (explicit) return explicit;
+  if (kind === "embeddings") return AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT ?? fallback;
+  if (kind === "completions") return AZURE_OPENAI_COMPLETIONS_DEPLOYMENT ?? fallback;
+  return AZURE_OPENAI_CHAT_DEPLOYMENT ?? fallback;
+};
+
+const flattenGatewayContent = (content: unknown): string => {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && "type" in part) {
+          const typed = part as { type?: string; text?: string; image_url?: { url?: string } };
+          if (typed.type === "text" && typeof typed.text === "string") return typed.text;
+          if (typed.type === "image_url" && typed.image_url?.url) return \`[Image: \${typed.image_url.url}]\`;
+        }
+        return JSON.stringify(part ?? {});
+      })
+      .join("\\n");
+  }
+  if (content && typeof content === "object") return JSON.stringify(content);
+  return "";
+};
+
+const toAnthropicMessages = (messages: Array<{ role: string; content: unknown }> = []) => {
+  const anthropicMessages: Array<{ role: "user" | "assistant"; content: Array<{ type: "text"; text: string }> }> = [];
+  let systemPrompt = "";
+
+  for (const message of messages) {
+    if (!message) continue;
+    const text = flattenGatewayContent(message.content);
+    if (message.role === "system") {
+      systemPrompt = systemPrompt ? \`\${systemPrompt}\\n\\n\${text}\` : text;
+      continue;
+    }
+    const role = message.role === "assistant" ? "assistant" : "user";
+    anthropicMessages.push({
+      role,
+      content: [{ type: "text", text }],
+    });
+  }
+
+  return { messages: anthropicMessages, system: systemPrompt || undefined };
+};
+
+const convertAnthropicResponseToGateway = (responseBody: any, modelName: string) => {
+  if (!responseBody) {
+    return {
+      id: \`anthropic-\${Date.now()}\`,
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1000),
+      model: modelName.startsWith("anthropic:") ? modelName : \`anthropic:\${modelName}\`,
+      choices: [],
+    };
+  }
+
+  const textContent = Array.isArray(responseBody.content)
+    ? responseBody.content
+        .filter((item: any) => item && item.type === "text" && typeof item.text === "string")
+        .map((item: any) => item.text)
+        .join("\\n")
+    : typeof responseBody.content === "string"
+      ? responseBody.content
+      : "";
+
+  const promptTokens = responseBody.usage?.input_tokens ?? 0;
+  const completionTokens = responseBody.usage?.output_tokens ?? 0;
+
+  return {
+    id: responseBody.id ?? \`anthropic-\${Date.now()}\`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model: modelName.startsWith("anthropic:") ? modelName : \`anthropic:\${modelName}\`,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: responseBody.role ?? "assistant",
+          content: textContent,
+        },
+        finish_reason: responseBody.stop_reason ?? responseBody.stop_sequence ?? null,
+      },
+    ],
+    usage: responseBody.usage
+      ? {
+          prompt_tokens: promptTokens,
+          completion_tokens: completionTokens,
+          total_tokens: promptTokens + completionTokens,
+        }
+      : undefined,
+  };
+};
+
+const passthroughResponse = (upstream: Response) => {
+  const headers = new Headers(upstream.headers);
+  return new Response(upstream.body, {
+    status: upstream.status,
+    statusText: upstream.statusText,
+    headers,
+  });
+};
+
+const jsonResponse = async (upstream: Response) => {
+  const data = await upstream.json().catch(async () => ({ raw: await upstream.text() }));
+  return NextResponse.json(data, { status: upstream.status });
+};
+
+const errorResponse = (status: number, error: unknown) =>
+  NextResponse.json(
+    {
+      error: error instanceof Error ? error.message : String(error ?? "Unknown error"),
+    },
+    { status }
+  );
+
+export async function POST(request: NextRequest) {
+  const body = (await request.json()) as GatewayChatBody;
+  const provider = normalizeProvider(body.provider ?? DEFAULT_PROVIDER);
+  const stream = body.stream !== false;
+
+  try {
+    switch (provider) {
+      case "openai": {
+        const openaiKey = requireOpenAIKey();
+        const { provider: _provider, ...cleanBody } = body;
+        const requestBody = {
+          ...cleanBody,
+          stream,
+          model: stripPrefix(body.model ?? DEFAULT_MODEL, "openai", "gpt-4o"),
+        };
+        const response = await fetch("https://api.openai.com/v1/chat/completions", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: \`Bearer \${openaiKey}\`,
+          },
+          body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+          const details = await response.text();
+          return NextResponse.json({ error: \`OpenAI chat failed: \${response.status}\`, details }, { status: response.status });
+        }
+        return stream ? passthroughResponse(response) : jsonResponse(response);
+      }
+
+      case "xai": {
+        const xaiKey = requireXAIKey();
+        const { provider: _provider, ...cleanBody } = body;
+        const requestBody = {
+          ...cleanBody,
+          stream,
+          model: stripPrefix(body.model ?? DEFAULT_MODEL, "xai", "grok-2-latest"),
+        };
+        const response = await fetch(XAI_BASE_URL + "/chat/completions", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer " + xaiKey,
+          },
+          body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+          const details = await response.text();
+          return NextResponse.json({ error: "xAI chat failed: " + response.status, details }, { status: response.status });
+        }
+        return stream ? passthroughResponse(response) : jsonResponse(response);
+      }
+
+      case "anthropic": {
+        const anthropicKey = requireAnthropicKey();
+        const requestedModel = stripPrefix(body.model ?? DEFAULT_MODEL, "anthropic", "claude-3-5-haiku-latest");
+        const stopSequences = Array.isArray(body.stop)
+          ? body.stop
+          : Array.isArray(body.stop_sequences)
+            ? body.stop_sequences
+            : body.stop
+              ? [body.stop]
+              : undefined;
+        const { messages, system } = toAnthropicMessages(Array.isArray(body.messages) ? body.messages : []);
+        const fallbackText = typeof body.prompt === "string" && body.prompt.trim().length > 0
+          ? body.prompt
+          : "Hello from Bandit quickstart gateway";
+
+        const requestBody: Record<string, unknown> = {
+          model: requestedModel,
+          messages: messages.length > 0
+            ? messages
+            : [
+                {
+                  role: "user",
+                  content: [{ type: "text", text: fallbackText }],
+                },
+              ],
+          stream,
+          max_tokens: typeof body.max_tokens === "number" && body.max_tokens > 0 ? body.max_tokens : ANTHROPIC_MAX_TOKENS,
+        };
+
+        if (system) requestBody.system = system;
+        if (typeof body.temperature === "number") requestBody.temperature = body.temperature;
+        if (typeof body.top_p === "number") requestBody.top_p = body.top_p;
+        if (typeof body.top_k === "number") requestBody.top_k = body.top_k;
+        if (stopSequences) requestBody.stop_sequences = stopSequences;
+        if (body.metadata) requestBody.metadata = body.metadata;
+        if (body.tools) requestBody.tools = body.tools;
+        if (body.tool_choice) requestBody.tool_choice = body.tool_choice;
+        if (body.thinking) requestBody.thinking = body.thinking;
+
+        const response = await fetch(\`\${ANTHROPIC_BASE_URL}/v1/messages\`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": anthropicKey,
+            "anthropic-version": ANTHROPIC_API_VERSION,
+          },
+          body: JSON.stringify(requestBody),
+        });
+
+        if (!response.ok) {
+          const details = await response.text();
+          return NextResponse.json({ error: \`Anthropic chat failed: \${response.status}\`, details }, { status: response.status });
+        }
+
+        if (stream) {
+          return passthroughResponse(response);
+        }
+
+        const data = await response.json();
+        const normalized = convertAnthropicResponseToGateway(data, requestedModel);
+        return NextResponse.json(normalized);
+      }
+
+      case "azure": {
+        const { apiKey } = requireAzureBaseConfig();
+        const deployment = resolveAzureDeployment(body.model, AZURE_OPENAI_CHAT_DEPLOYMENT, "chat");
+        const { provider: _provider, model: _model, ...cleanBody } = body;
+        const requestBody = {
+          ...cleanBody,
+          stream,
+        };
+
+        const response = await fetch(buildAzureDeploymentUrl(deployment, "chat/completions"), {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "api-key": apiKey,
+          },
+          body: JSON.stringify(requestBody),
+        });
+
+        if (!response.ok) {
+          const details = await response.text();
+          return NextResponse.json({ error: \`Azure OpenAI chat failed: \${response.status}\`, details }, { status: response.status });
+        }
+
+        return stream ? passthroughResponse(response) : jsonResponse(response);
+      }
+
+      case "ollama": {
+        const { provider: _provider, ...cleanBody } = body;
+        const requestBody = {
+          ...cleanBody,
+          stream,
+          model: stripPrefix(body.model ?? DEFAULT_MODEL, "ollama", "llama3.1"),
+        };
+
+        const response = await fetch(\`\${OLLAMA_URL}/api/chat\`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify(requestBody),
+        });
+
+        if (!response.ok) {
+          const details = await response.text();
+          return NextResponse.json({ error: \`Ollama chat failed: \${response.status}\`, details }, { status: response.status });
+        }
+
+        return stream ? passthroughResponse(response) : jsonResponse(response);
+      }
+
+      default:
+        return errorResponse(400, \`Unsupported provider: \${provider}\`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = message.startsWith("Missing") ? 400 : 500;
+    return errorResponse(status, error);
+  }
+}
+
+`;
+var NEXT_HEALTH_ROUTE_TEMPLATE = `import { NextResponse } from "next/server";
+
+export const dynamic = "force-dynamic";
+
+const QUICKSTART_VERSION = "0.1.0";
+const OLLAMA_URL = (process.env.OLLAMA_URL ?? "http://localhost:11434").replace(/\\/$/, "");
+const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+const AZURE_OPENAI_ENDPOINT = process.env.AZURE_OPENAI_ENDPOINT ? process.env.AZURE_OPENAI_ENDPOINT.replace(/\\/$/, "") : undefined;
+const AZURE_OPENAI_API_KEY = process.env.AZURE_OPENAI_API_KEY;
+const AZURE_OPENAI_API_VERSION = process.env.AZURE_OPENAI_API_VERSION ?? "2024-08-01-preview";
+const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+const ANTHROPIC_BASE_URL = (process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com").replace(/\\/$/, "");
+const ANTHROPIC_API_VERSION = process.env.ANTHROPIC_API_VERSION ?? "2023-06-01";
+const XAI_API_KEY = process.env.XAI_API_KEY;
+const XAI_BASE_URL = (process.env.XAI_BASE_URL ?? "https://api.x.ai/v1").replace(/\\/$/, "");
+
+const isAzureConfigured = () => Boolean(AZURE_OPENAI_ENDPOINT && AZURE_OPENAI_API_KEY);
+
+const buildAzurePath = (path: string) => {
+  const normalized = path.replace(/^\\/+/, "");
+  if (!AZURE_OPENAI_ENDPOINT) {
+    throw new Error("Missing AZURE_OPENAI_ENDPOINT. Add it to your .env file to route requests to Azure OpenAI.");
+  }
+  return \`\${AZURE_OPENAI_ENDPOINT}/openai/\${normalized}?api-version=\${AZURE_OPENAI_API_VERSION}\`;
+};
+
+export async function GET() {
+  const providers: Array<Record<string, unknown>> = [];
+
+  // OpenAI
+  try {
+    if (OPENAI_API_KEY) {
+      const response = await fetch("https://api.openai.com/v1/models", {
+        headers: { Authorization: \`Bearer \${OPENAI_API_KEY}\` },
+      });
+      providers.push({
+        name: "openai",
+        status: response.ok ? "healthy" : "unhealthy",
+        provider: "openai",
+      });
+    } else {
+      providers.push({
+        name: "openai",
+        status: "unconfigured",
+        provider: "openai",
+        error: "API key not configured",
+      });
+    }
+  } catch (error) {
+    providers.push({
+      name: "openai",
+      status: "unhealthy",
+      provider: "openai",
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+
+  // Azure
+  if (AZURE_OPENAI_ENDPOINT || AZURE_OPENAI_API_KEY) {
+    if (!isAzureConfigured()) {
+      providers.push({
+        name: "azure",
+        status: "unconfigured",
+        provider: "azure",
+        error: "Endpoint or API key not configured",
+        endpoint: AZURE_OPENAI_ENDPOINT,
+      });
+    } else {
+      try {
+        const response = await fetch(buildAzurePath("deployments"), {
+          headers: { "api-key": AZURE_OPENAI_API_KEY ?? "" },
+        });
+        providers.push({
+          name: "azure",
+          status: response.ok ? "healthy" : "unhealthy",
+          provider: "azure",
+          endpoint: AZURE_OPENAI_ENDPOINT,
+        });
+      } catch (error) {
+        providers.push({
+          name: "azure",
+          status: "unhealthy",
+          provider: "azure",
+          endpoint: AZURE_OPENAI_ENDPOINT,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+  } else {
+    providers.push({
+      name: "azure",
+      status: "unconfigured",
+      provider: "azure",
+      error: "Endpoint or API key not configured",
+    });
+  }
+
+  // Anthropic
+  if (ANTHROPIC_API_KEY) {
+    try {
+      const response = await fetch(\`\${ANTHROPIC_BASE_URL}/v1/models\`, {
+        headers: {
+          "x-api-key": ANTHROPIC_API_KEY,
+          "anthropic-version": ANTHROPIC_API_VERSION,
+        },
+      });
+      providers.push({
+        name: "anthropic",
+        status: response.ok ? "healthy" : "unhealthy",
+        provider: "anthropic",
+        endpoint: ANTHROPIC_BASE_URL,
+      });
+    } catch (error) {
+      providers.push({
+        name: "anthropic",
+        status: "unhealthy",
+        provider: "anthropic",
+        endpoint: ANTHROPIC_BASE_URL,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  } else {
+    providers.push({
+      name: "anthropic",
+      status: "unconfigured",
+      provider: "anthropic",
+      error: "API key not configured",
+    });
+  }
+
+  // xAI
+  if (XAI_API_KEY) {
+    try {
+      const response = await fetch(XAI_BASE_URL + "/models", {
+        headers: { Authorization: "Bearer " + XAI_API_KEY },
+      });
+      providers.push({
+        name: "xai",
+        status: response.ok ? "healthy" : "unhealthy",
+        provider: "xai",
+        endpoint: XAI_BASE_URL,
+      });
+    } catch (error) {
+      providers.push({
+        name: "xai",
+        status: "unhealthy",
+        provider: "xai",
+        endpoint: XAI_BASE_URL,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  } else {
+    providers.push({
+      name: "xai",
+      status: "unconfigured",
+      provider: "xai",
+      error: "API key not configured",
+      endpoint: XAI_BASE_URL,
+    });
+  }
+
+  // Ollama
+  try {
+    const response = await fetch(\`\${OLLAMA_URL}/api/tags\`);
+    providers.push({
+      name: "ollama",
+      status: response.ok ? "healthy" : "unhealthy",
+      provider: "ollama",
+      url: OLLAMA_URL,
+    });
+  } catch (error) {
+    providers.push({
+      name: "ollama",
+      status: "offline",
+      provider: "ollama",
+      url: OLLAMA_URL,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+
+  const overallHealthy = providers.some((provider) => provider.status === "healthy");
+
+  return NextResponse.json({
+    status: overallHealthy ? "healthy" : "unhealthy",
+    version: QUICKSTART_VERSION,
+    uptime: Math.round(process.uptime()),
+    providers,
+  });
+}
+
+`;
+var NEXT_MODELS_ROUTE_TEMPLATE = `import { NextResponse } from "next/server";
+
+export const dynamic = "force-dynamic";
+
+const BASE_GATEWAY_MODELS = __GATEWAY_MODELS__;
+
+export function toGatewayModels() {
+  return BASE_GATEWAY_MODELS.map((model) => ({
+    ...model,
+    created: Date.now(),
+    modified_at: new Date().toISOString(),
+    size: 0,
+    digest: "",
+    details: {
+      format: "chat",
+      family: model.provider,
+      families: [model.provider],
+      parameter_size: "",
+      quantization_level: "",
+    },
+  }));
+}
+
+export async function GET() {
+  return NextResponse.json({ models: toGatewayModels() });
+}
+
+`;
+var NEXT_GATEWAY_README_TEMPLATE = `# Next.js Gateway API
+
+This directory contains a minimal Next.js App Router implementation of the Bandit gateway API. It mirrors the Express gateway in
+\`server/gateway.js\` but is ready to drop into a Next.js project.
+
+## Routes
+
+- \`app/api/health/route.ts\` \u2013 provider health and availability checks
+- \`app/api/chat/completions/route.ts\` \u2013 provider-aware chat completions endpoint (OpenAI, Azure OpenAI, Anthropic, xAI, Ollama)
+- \`app/api/models/route.ts\` \u2013 exposes the scaffolded gateway model metadata used by the frontend
+
+## Usage
+
+1. Copy the contents of \`server/next-app/\` into the \`app/\` directory of a Next.js project.
+2. Ensure the environment variables listed in \`.env.example\` are available to the Next.js runtime. At minimum you will want the
+   provider API keys you plan to use (OpenAI, Azure OpenAI, Anthropic, xAI, or Ollama).
+3. Start Next.js with \`npm run dev\` (or your project\u2019s equivalent). The routes are server-only (\`export const dynamic = "force-dynamic"\`)
+   and can coexist with any frontend pages.
+
+The generated routes favour clarity over cleverness so you can extend them with custom auth, logging, and provider routing logic.
+`;
+var buildNextChatRoute = (ctx) => {
+  const fallbackModel = ctx.fallbackModelId ? `"${ctx.fallbackModelId}"` : "undefined";
+  return ensureTrailingNewline(
+    normalizeLineEndings(
+      NEXT_CHAT_ROUTE_TEMPLATE.replace(/__DEFAULT_PROVIDER__/g, ctx.defaultProvider).replace(/__DEFAULT_MODEL__/g, ctx.defaultModelId).replace(/__FALLBACK_MODEL__/g, fallbackModel)
+    )
+  );
+};
+var buildNextHealthRoute = () => ensureTrailingNewline(normalizeLineEndings(NEXT_HEALTH_ROUTE_TEMPLATE));
+var buildNextModelsRoute = (ctx) => {
+  const modelsDefinition = JSON.stringify(ctx.gatewayModels, null, 2);
+  return ensureTrailingNewline(
+    normalizeLineEndings(
+      NEXT_MODELS_ROUTE_TEMPLATE.replace("__GATEWAY_MODELS__", modelsDefinition)
+    )
+  );
+};
+var buildNextGatewayReadme = () => ensureTrailingNewline(normalizeLineEndings(NEXT_GATEWAY_README_TEMPLATE));
 var buildGatewayServer = (ctx) => {
   const modelsDefinition = JSON.stringify(ctx.gatewayModels, null, 2);
   const gatewaySource = `import express from "express";
@@ -837,6 +1524,20 @@ const QUICKSTART_VERSION = "0.1.0";
 const DEFAULT_PROVIDER = "${ctx.defaultProvider}";
 const BASE_GATEWAY_MODELS = ${modelsDefinition};
 const OLLAMA_BASE_URL = (process.env.OLLAMA_URL ?? "http://localhost:11434").replace(/\\/$/, "");
+const AZURE_OPENAI_ENDPOINT = process.env.AZURE_OPENAI_ENDPOINT ? process.env.AZURE_OPENAI_ENDPOINT.replace(/\\/$/, "") : undefined;
+const AZURE_OPENAI_API_KEY = process.env.AZURE_OPENAI_API_KEY;
+const AZURE_OPENAI_API_VERSION = process.env.AZURE_OPENAI_API_VERSION ?? "2024-08-01-preview";
+const AZURE_OPENAI_CHAT_DEPLOYMENT = process.env.AZURE_OPENAI_CHAT_DEPLOYMENT;
+const AZURE_OPENAI_COMPLETIONS_DEPLOYMENT = process.env.AZURE_OPENAI_COMPLETIONS_DEPLOYMENT ?? AZURE_OPENAI_CHAT_DEPLOYMENT;
+const AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT = process.env.AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT;
+const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+const ANTHROPIC_BASE_URL = (process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com").replace(/\\/$/, "");
+const ANTHROPIC_API_VERSION = process.env.ANTHROPIC_API_VERSION ?? "2023-06-01";
+const ANTHROPIC_MAX_TOKENS = Number.isFinite(Number(process.env.ANTHROPIC_MAX_TOKENS))
+  ? Number(process.env.ANTHROPIC_MAX_TOKENS)
+  : 1024;
+const XAI_API_KEY = process.env.XAI_API_KEY;
+const XAI_BASE_URL = (process.env.XAI_BASE_URL ?? "https://api.x.ai/v1").replace(/\\/$/, "");
 
 const toGatewayModels = () =>
   BASE_GATEWAY_MODELS.map((model) => ({
@@ -854,113 +1555,1177 @@ const toGatewayModels = () =>
     },
   }));
 
-const requireOpenAIKey = () => {
-  const key = process.env.OPENAI_API_KEY;
-  if (!key) {
-    throw new Error("Missing OPENAI_API_KEY. Add it to your .env file to route requests to OpenAI.");
+const stripAzureModelPrefix = (value) =>
+  typeof value === "string" ? value.replace(/^azure:/, "") : undefined;
+
+const isAzureConfigured = () => Boolean(AZURE_OPENAI_ENDPOINT && AZURE_OPENAI_API_KEY);
+
+const requireAzureBaseConfig = () => {
+  if (!AZURE_OPENAI_ENDPOINT) {
+    throw new Error("Missing AZURE_OPENAI_ENDPOINT. Add it to your .env file to route requests to Azure OpenAI.");
+  }
+  if (!AZURE_OPENAI_API_KEY) {
+    throw new Error("Missing AZURE_OPENAI_API_KEY. Add it to your .env file to route requests to Azure OpenAI.");
+  }
+  return {
+    endpoint: AZURE_OPENAI_ENDPOINT,
+    apiKey: AZURE_OPENAI_API_KEY,
+    apiVersion: AZURE_OPENAI_API_VERSION,
+  };
+};
+
+const resolveAzureDeployment = (explicitValue, fallbackValue, kind) => {
+  const fromRequest = stripAzureModelPrefix(explicitValue);
+  if (fromRequest) {
+    return fromRequest;
+  }
+  if (fallbackValue) {
+    return fallbackValue;
+  }
+  throw new Error(\`Missing Azure OpenAI \${kind} deployment name. Set AZURE_OPENAI_\${kind.toUpperCase()}_DEPLOYMENT in your .env file.\`);
+};
+
+const buildAzureDeploymentUrl = (deployment, suffix) => {
+  const { endpoint } = requireAzureBaseConfig();
+  const normalizedSuffix = suffix.replace(/^\\//, "");
+  return \`\${endpoint}/openai/deployments/\${deployment}/\${normalizedSuffix}?api-version=\${AZURE_OPENAI_API_VERSION}\`;
+};
+
+const buildAzurePath = (suffix) => {
+  const { endpoint } = requireAzureBaseConfig();
+  const normalizedSuffix = suffix.replace(/^\\//, "");
+  const hasQuery = normalizedSuffix.includes("?");
+  const separator = hasQuery ? "&" : "?";
+  return \`\${endpoint}/openai/\${normalizedSuffix}\${separator}api-version=\${AZURE_OPENAI_API_VERSION}\`;
+};
+
+const stripAnthropicModelPrefix = (value) =>
+  typeof value === "string" ? value.replace(/^anthropic:/, "") : undefined;
+
+const isAnthropicConfigured = () => Boolean(ANTHROPIC_API_KEY);
+
+const requireAnthropicKey = () => {
+  if (!ANTHROPIC_API_KEY) {
+    throw new Error("Missing ANTHROPIC_API_KEY. Add it to your .env file to route requests to Anthropic.");
+  }
+  return ANTHROPIC_API_KEY;
+};
+
+const buildAnthropicUrl = (path) => {
+  const normalized = path.replace(/^\\//, "");
+  return \`\${ANTHROPIC_BASE_URL}/v1/\${normalized}\`;
+};
+
+const buildAnthropicHeaders = () => ({
+  "Content-Type": "application/json",
+  "x-api-key": requireAnthropicKey(),
+  "anthropic-version": ANTHROPIC_API_VERSION,
+});
+
+const flattenGatewayContent = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") {
+          return part;
+        }
+        if (part?.type === "text" && typeof part.text === "string") {
+          return part.text;
+        }
+        if (part?.type === "image_url" && part.image_url?.url) {
+          return \`[Image: \${part.image_url.url}]\`;
+        }
+        return JSON.stringify(part ?? {});
+      })
+      .join("\\n");
+  }
+  if (content && typeof content === "object") {
+    return JSON.stringify(content);
+  }
+  return "";
+};
+
+const toAnthropicMessages = (messages = []) => {
+  const anthropicMessages = [];
+  let systemPrompt = "";
+
+  for (const message of messages) {
+    if (!message) continue;
+    const text = flattenGatewayContent(message.content);
+
+    if (message.role === "system") {
+      systemPrompt = systemPrompt ? \`\${systemPrompt}\\n\\n\${text}\` : text;
+      continue;
+    }
+
+    const role = message.role === "assistant" ? "assistant" : "user";
+    anthropicMessages.push({
+      role,
+      content: [{ type: "text", text }],
+    });
+  }
+
+  return { messages: anthropicMessages, system: systemPrompt || undefined };
+};
+
+const convertAnthropicResponseToGateway = (responseBody, modelName) => {
+  if (!responseBody) {
+    return {
+      id: \`anthropic-\${Date.now()}\`,
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1000),
+      model: modelName.startsWith("anthropic:") ? modelName : \`anthropic:\${modelName}\`,
+      choices: [],
+    };
+  }
+
+  const textContent = Array.isArray(responseBody.content)
+    ? responseBody.content
+        .filter((item) => item && item.type === "text" && typeof item.text === "string")
+        .map((item) => item.text)
+        .join("\\n")
+    : typeof responseBody.content === "string"
+      ? responseBody.content
+      : "";
+
+  const promptTokens = responseBody.usage?.input_tokens ?? 0;
+  const completionTokens = responseBody.usage?.output_tokens ?? 0;
+
+  return {
+    id: responseBody.id ?? \`anthropic-\${Date.now()}\`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model: modelName.startsWith("anthropic:") ? modelName : \`anthropic:\${modelName}\`,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: responseBody.role ?? "assistant",
+          content: textContent,
+        },
+        finish_reason: responseBody.stop_reason ?? responseBody.stop_sequence ?? null,
+      },
+    ],
+    usage: responseBody.usage
+      ? {
+          prompt_tokens: promptTokens,
+          completion_tokens: completionTokens,
+          total_tokens: promptTokens + completionTokens,
+        }
+      : undefined,
+  };
+};
+
+const convertAnthropicResponseToGenerate = (responseBody, modelName) => {
+  const gatewayResponse = convertAnthropicResponseToGateway(responseBody, modelName);
+  const content = gatewayResponse.choices?.[0]?.message?.content ?? "";
+  return {
+    model: gatewayResponse.model,
+    created_at: new Date().toISOString(),
+    response: content,
+    done: true,
+    total_duration: 0,
+    load_duration: 0,
+    prompt_eval_count: gatewayResponse.usage?.prompt_tokens ?? 0,
+    prompt_eval_duration: 0,
+    eval_count: gatewayResponse.usage?.completion_tokens ?? 0,
+    eval_duration: 0,
+  };
+};
+
+const requireOpenAIKey = () => {
+  const key = process.env.OPENAI_API_KEY;
+  if (!key) {
+    throw new Error("Missing OPENAI_API_KEY. Add it to your .env file to route requests to OpenAI.");
+  }
+  return key;
+};
+
+const requireXAIKey = () => {
+  const key = XAI_API_KEY;
+  if (!key) {
+    throw new Error("Missing XAI_API_KEY. Add it to your .env file to route requests to xAI.");
+  }
+  return key;
+};
+
+// Utility function to handle streaming responses
+const handleStreamingResponse = async (upstreamResponse, res) => {
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  
+  try {
+    // Get the readable stream from the response
+    const reader = upstreamResponse.body.getReader();
+    
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      
+      // Write the chunk to the response
+      res.write(value);
+    }
+    
+    res.end();
+  } catch (error) {
+    console.error('Streaming error:', error);
+    // Fallback to non-streaming
+    const text = await upstreamResponse.text();
+    res.send(text);
+  }
+};
+
+const relayAnthropicStream = async (upstreamResponse, res) => {
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.setHeader('Access-Control-Allow-Origin', '*');
+
+  const reader = upstreamResponse.body?.getReader();
+  if (!reader) {
+    const fallback = await upstreamResponse.text();
+    res.write("data: " + JSON.stringify({ choices: [{ delta: { content: fallback } }] }) + "\\n\\n");
+    res.write("data: [DONE]\\n\\n");
+    return res.end();
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  const sendChunk = (payload) => {
+    res.write("data: " + JSON.stringify(payload) + "\\n\\n");
+  };
+
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+
+      let delimiterIndex;
+      while ((delimiterIndex = buffer.indexOf('\\n\\n')) >= 0) {
+        const rawEvent = buffer.slice(0, delimiterIndex).trim();
+        buffer = buffer.slice(delimiterIndex + 2);
+        if (!rawEvent) continue;
+
+        const lines = rawEvent.split('\\n');
+        const eventLine = lines.find((line) => line.startsWith('event:')) ?? '';
+        const dataLine = lines.find((line) => line.startsWith('data:')) ?? '';
+        const event = eventLine.replace('event:', '').trim();
+        const trimmedData = dataLine.replace('data:', '').trim();
+
+        if (!trimmedData) {
+          continue;
+        }
+
+        let parsed;
+        try {
+          parsed = JSON.parse(trimmedData);
+        } catch (error) {
+          console.error('Anthropic stream parse error', error, { rawEvent });
+          continue;
+        }
+
+        if (event === 'content_block_delta') {
+          const textChunk = parsed?.delta?.text ?? '';
+          if (textChunk) {
+            sendChunk({
+              choices: [
+                {
+                  delta: {
+                    content: textChunk,
+                  },
+                },
+              ],
+            });
+          }
+        } else if (event === 'message_stop') {
+          sendChunk({
+            choices: [
+              {
+                delta: {},
+                finish_reason: 'stop',
+              },
+            ],
+          });
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Anthropic streaming relay error', error);
+    sendChunk({
+      error: error instanceof Error ? error.message : String(error),
+    });
+  } finally {
+    res.write("data: [DONE]\\n\\n");
+    res.end();
+  }
+};
+
+// ============================================================================
+// GENERAL HEALTH & MODELS
+// ============================================================================
+
+app.get("/api/health", async (_req, res) => {
+  const providers = [];
+  
+  // Check OpenAI
+  try {
+    const openaiKey = process.env.OPENAI_API_KEY;
+    if (openaiKey) {
+      const response = await fetch("https://api.openai.com/v1/models", {
+        headers: { "Authorization": \`Bearer \${openaiKey}\` }
+      });
+      providers.push({
+        name: "openai",
+        status: response.ok ? "healthy" : "unhealthy",
+        provider: "openai"
+      });
+    } else {
+      providers.push({
+        name: "openai", 
+        status: "unconfigured",
+        provider: "openai",
+        error: "API key not configured"
+      });
+    }
+  } catch (error) {
+    providers.push({
+      name: "openai",
+      status: "unhealthy", 
+      provider: "openai",
+      error: error.message
+    });
+  }
+
+  // Check Azure OpenAI
+  if (AZURE_OPENAI_ENDPOINT || AZURE_OPENAI_API_KEY) {
+    if (!isAzureConfigured()) {
+      providers.push({
+        name: "azure",
+        status: "unconfigured",
+        provider: "azure",
+        error: "Endpoint or API key not configured",
+        endpoint: AZURE_OPENAI_ENDPOINT
+      });
+    } else {
+      try {
+        const { endpoint } = requireAzureBaseConfig();
+        const deploymentsUrl = buildAzurePath("deployments");
+        const response = await fetch(deploymentsUrl, {
+          headers: { "api-key": AZURE_OPENAI_API_KEY }
+        });
+        providers.push({
+          name: "azure",
+          status: response.ok ? "healthy" : "unhealthy",
+          provider: "azure",
+          endpoint
+        });
+      } catch (error) {
+        providers.push({
+          name: "azure",
+          status: "unhealthy",
+          provider: "azure",
+          error: error instanceof Error ? error.message : String(error),
+          endpoint: AZURE_OPENAI_ENDPOINT
+        });
+      }
+    }
+  } else {
+    providers.push({
+      name: "azure",
+      status: "unconfigured",
+      provider: "azure",
+      error: "Endpoint or API key not configured"
+    });
+  }
+
+  // Check Anthropic
+  if (ANTHROPIC_API_KEY) {
+    try {
+      const response = await fetch(buildAnthropicUrl("models"), {
+        headers: buildAnthropicHeaders(),
+        method: "GET"
+      });
+      providers.push({
+        name: "anthropic",
+        status: response.ok ? "healthy" : "unhealthy",
+        provider: "anthropic",
+        endpoint: ANTHROPIC_BASE_URL
+      });
+    } catch (error) {
+      providers.push({
+        name: "anthropic",
+        status: "unhealthy",
+        provider: "anthropic",
+        error: error instanceof Error ? error.message : String(error),
+        endpoint: ANTHROPIC_BASE_URL
+      });
+    }
+  } else {
+    providers.push({
+      name: "anthropic",
+      status: "unconfigured",
+      provider: "anthropic",
+      error: "API key not configured"
+    });
+  }
+
+  // Check xAI
+  if (XAI_API_KEY) {
+    try {
+      const response = await fetch(XAI_BASE_URL + "/models", {
+        headers: { "Authorization": "Bearer " + XAI_API_KEY }
+      });
+      providers.push({
+        name: "xai",
+        status: response.ok ? "healthy" : "unhealthy",
+        provider: "xai",
+        endpoint: XAI_BASE_URL
+      });
+    } catch (error) {
+      providers.push({
+        name: "xai",
+        status: "unhealthy",
+        provider: "xai",
+        error: error instanceof Error ? error.message : String(error),
+        endpoint: XAI_BASE_URL
+      });
+    }
+  } else {
+    providers.push({
+      name: "xai",
+      status: "unconfigured",
+      provider: "xai",
+      error: "API key not configured",
+      endpoint: XAI_BASE_URL
+    });
+  }
+
+  // Check Ollama
+  try {
+    console.log(\`Checking Ollama health at: \${OLLAMA_BASE_URL}/api/tags\`);
+    const response = await fetch(\`\${OLLAMA_BASE_URL}/api/tags\`);
+    const status = response.ok ? "healthy" : "unhealthy";
+    console.log(\`Ollama health check result: \${status}\`);
+    providers.push({
+      name: "ollama",
+      status: status,
+      provider: "ollama",
+      url: OLLAMA_BASE_URL
+    });
+  } catch (error) {
+    console.log(\`Ollama health check error: \${error.message}\`);
+    providers.push({
+      name: "ollama",
+      status: "offline",
+      provider: "ollama",
+      error: error.message,
+      url: OLLAMA_BASE_URL
+    });
+  }
+
+  const overallHealthy = providers.some(p => p.status === "healthy");
+  
+  res.json({
+    status: overallHealthy ? "healthy" : "unhealthy",
+    version: QUICKSTART_VERSION,
+    uptime: Math.round(process.uptime()),
+    providers
+  });
+});
+
+app.get("/api/models", (_req, res) => {
+  res.json({ models: toGatewayModels() });
+});
+
+// ============================================================================
+// ANTHROPIC ROUTES
+// ============================================================================
+
+app.get("/api/anthropic/health", async (_req, res) => {
+  try {
+    requireAnthropicKey();
+    const response = await fetch(buildAnthropicUrl("models"), {
+      method: "GET",
+      headers: buildAnthropicHeaders()
+    });
+    const isHealthy = response.ok;
+    res.json({
+      status: isHealthy ? "healthy" : "unhealthy",
+      anthropic_status: isHealthy,
+      provider: "anthropic",
+      endpoint: ANTHROPIC_BASE_URL
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    res.status(503).json({
+      status: "unhealthy",
+      anthropic_status: false,
+      provider: "anthropic",
+      error: message,
+      endpoint: ANTHROPIC_BASE_URL
+    });
+  }
+});
+
+app.post("/api/anthropic/chat/completions", async (req, res) => {
+  try {
+    requireAnthropicKey();
+    const rawBody = req.body ?? {};
+    const isStreaming = rawBody.stream === true;
+    const requestedModel =
+      stripAnthropicModelPrefix(rawBody.model) ??
+      stripAnthropicModelPrefix("${ctx.defaultModelId}") ??
+      "claude-3-5-haiku-latest";
+
+    const stopSequences = Array.isArray(rawBody.stop)
+      ? rawBody.stop
+      : Array.isArray(rawBody.stop_sequences)
+        ? rawBody.stop_sequences
+        : rawBody.stop
+          ? [rawBody.stop]
+          : undefined;
+
+    const { messages: anthropicMessages, system } = toAnthropicMessages(
+      Array.isArray(rawBody.messages) ? rawBody.messages : []
+    );
+
+    const fallbackText =
+      typeof rawBody.prompt === "string" && rawBody.prompt.trim().length > 0
+        ? rawBody.prompt
+        : "Hello from Bandit quickstart gateway";
+
+    const requestBody = {
+      model: requestedModel,
+      messages:
+        anthropicMessages.length > 0
+          ? anthropicMessages
+          : [
+              {
+                role: "user",
+                content: [{ type: "text", text: fallbackText }],
+              },
+            ],
+      stream: isStreaming,
+      max_tokens:
+        typeof rawBody.max_tokens === "number" && rawBody.max_tokens > 0
+          ? rawBody.max_tokens
+          : ANTHROPIC_MAX_TOKENS,
+    };
+
+    if (system) {
+      requestBody.system = system;
+    }
+    if (typeof rawBody.temperature === "number") {
+      requestBody.temperature = rawBody.temperature;
+    }
+    if (typeof rawBody.top_p === "number") {
+      requestBody.top_p = rawBody.top_p;
+    }
+    if (typeof rawBody.top_k === "number") {
+      requestBody.top_k = rawBody.top_k;
+    }
+    if (stopSequences) {
+      requestBody.stop_sequences = stopSequences;
+    }
+    if (rawBody.metadata) {
+      requestBody.metadata = rawBody.metadata;
+    }
+    if (rawBody.tools) {
+      requestBody.tools = rawBody.tools;
+    }
+    if (rawBody.tool_choice) {
+      requestBody.tool_choice = rawBody.tool_choice;
+    }
+    if (rawBody.thinking) {
+      requestBody.thinking = rawBody.thinking;
+    }
+    if (rawBody.extra_headers) {
+      requestBody.extra_headers = rawBody.extra_headers;
+    }
+
+    const response = await fetch(buildAnthropicUrl("messages"), {
+      method: "POST",
+      headers: buildAnthropicHeaders(),
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Anthropic chat failed: \${response.status}\`,
+        details: errorText,
+      });
+    }
+
+    if (isStreaming) {
+      await relayAnthropicStream(response, res);
+    } else {
+      const data = await response.json();
+      const normalized = convertAnthropicResponseToGateway(data, requestedModel);
+      res.json(normalized);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = message.startsWith("Missing ANTHROPIC_API_KEY") ? 400 : 500;
+    res.status(status).json({ error: message });
+  }
+});
+
+app.post("/api/anthropic/chat", async (req, res) => {
+  req.url = "/api/anthropic/chat/completions";
+  return app._router.handle(req, res);
+});
+
+app.post("/api/anthropic/completions", async (req, res) => {
+  try {
+    requireAnthropicKey();
+    const rawBody = req.body ?? {};
+    const isStreaming = rawBody.stream === true;
+    const requestedModel =
+      stripAnthropicModelPrefix(rawBody.model) ??
+      stripAnthropicModelPrefix("${ctx.defaultModelId}") ??
+      "claude-3-5-sonnet-latest";
+
+    const stopSequences = Array.isArray(rawBody.stop)
+      ? rawBody.stop
+      : Array.isArray(rawBody.stop_sequences)
+        ? rawBody.stop_sequences
+        : rawBody.stop
+          ? [rawBody.stop]
+          : undefined;
+
+    const prompt =
+      typeof rawBody.prompt === "string" && rawBody.prompt.trim().length > 0
+        ? rawBody.prompt
+        : "Hello from Bandit quickstart gateway";
+
+    const { messages, system } = toAnthropicMessages([
+      { role: "user", content: prompt },
+    ]);
+
+    const requestBody = {
+      model: requestedModel,
+      messages,
+      stream: isStreaming,
+      max_tokens:
+        typeof rawBody.max_tokens === "number" && rawBody.max_tokens > 0
+          ? rawBody.max_tokens
+          : ANTHROPIC_MAX_TOKENS,
+    };
+
+    if (system) {
+      requestBody.system = system;
+    }
+    if (typeof rawBody.temperature === "number") {
+      requestBody.temperature = rawBody.temperature;
+    }
+    if (typeof rawBody.top_p === "number") {
+      requestBody.top_p = rawBody.top_p;
+    }
+    if (typeof rawBody.top_k === "number") {
+      requestBody.top_k = rawBody.top_k;
+    }
+    if (stopSequences) {
+      requestBody.stop_sequences = stopSequences;
+    }
+    if (rawBody.metadata) {
+      requestBody.metadata = rawBody.metadata;
+    }
+    if (rawBody.tools) {
+      requestBody.tools = rawBody.tools;
+    }
+    if (rawBody.tool_choice) {
+      requestBody.tool_choice = rawBody.tool_choice;
+    }
+
+    const response = await fetch(buildAnthropicUrl("messages"), {
+      method: "POST",
+      headers: buildAnthropicHeaders(),
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Anthropic completions failed: \${response.status}\`,
+        details: errorText,
+      });
+    }
+
+    if (isStreaming) {
+      await relayAnthropicStream(response, res);
+    } else {
+      const data = await response.json();
+      const formatted = convertAnthropicResponseToGenerate(data, requestedModel);
+      res.json(formatted);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = message.startsWith("Missing ANTHROPIC_API_KEY") ? 400 : 500;
+    res.status(status).json({ error: message });
+  }
+});
+
+app.post("/api/anthropic/generate", async (req, res) => {
+  req.url = "/api/anthropic/completions";
+  return app._router.handle(req, res);
+});
+
+app.get("/api/anthropic/models", async (_req, res) => {
+  try {
+    requireAnthropicKey();
+    const response = await fetch(buildAnthropicUrl("models"), {
+      method: "GET",
+      headers: buildAnthropicHeaders(),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Anthropic models failed: \${response.status}\`,
+        details: errorText,
+      });
+    }
+
+    const text = await response.text();
+    res.setHeader('Content-Type', 'application/json');
+    res.send(text);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = message.startsWith("Missing ANTHROPIC_API_KEY") ? 400 : 500;
+    res.status(status).json({ error: message });
+  }
+});
+
+app.post("/api/anthropic/embed", async (_req, res) => {
+  res.status(501).json({
+    error: "Anthropic embeddings not implemented",
+    message: "Add support for the Anthropic embeddings endpoint if your use case requires it."
+  });
+});
+
+// ============================================================================
+// AZURE OPENAI ROUTES
+// ============================================================================
+
+app.get("/api/azure/health", async (_req, res) => {
+  try {
+    const { endpoint } = requireAzureBaseConfig();
+    const deploymentsUrl = buildAzurePath("deployments");
+    const response = await fetch(deploymentsUrl, {
+      headers: { "api-key": AZURE_OPENAI_API_KEY }
+    });
+    const isHealthy = response.ok;
+    res.json({
+      status: isHealthy ? "healthy" : "unhealthy",
+      azure_status: isHealthy,
+      provider: "azure",
+      endpoint
+    });
+  } catch (error) {
+    res.status(503).json({
+      status: "unhealthy",
+      azure_status: false,
+      provider: "azure",
+      error: error instanceof Error ? error.message : String(error),
+      endpoint: AZURE_OPENAI_ENDPOINT
+    });
+  }
+});
+
+app.post("/api/azure/chat/completions", async (req, res) => {
+  try {
+    const { apiKey } = requireAzureBaseConfig();
+    const deployment = resolveAzureDeployment(req.body?.model, AZURE_OPENAI_CHAT_DEPLOYMENT, "chat");
+    const isStreaming = req.body?.stream === true;
+    const { provider, model, ...cleanBody } = req.body ?? {};
+    const requestBody = { ...cleanBody };
+
+    const response = await fetch(buildAzureDeploymentUrl(deployment, "chat/completions"), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": apiKey
+      },
+      body: JSON.stringify(requestBody)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Azure OpenAI chat failed: \${response.status}\`,
+        details: errorText
+      });
+    }
+
+    if (isStreaming) {
+      await handleStreamingResponse(response, res);
+    } else {
+      const text = await response.text();
+      res.setHeader('Content-Type', 'application/json');
+      res.send(text);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = message.startsWith("Missing Azure OpenAI") ? 400 : 500;
+    res.status(status).json({ error: message });
+  }
+});
+
+app.post("/api/azure/chat", async (req, res) => {
+  req.url = "/api/azure/chat/completions";
+  return app._router.handle(req, res);
+});
+
+app.post("/api/azure/completions", async (req, res) => {
+  try {
+    const { apiKey } = requireAzureBaseConfig();
+    const deployment = resolveAzureDeployment(req.body?.model, AZURE_OPENAI_COMPLETIONS_DEPLOYMENT, "completions");
+    const isStreaming = req.body?.stream === true;
+    const { provider, model, ...cleanBody } = req.body ?? {};
+    const requestBody = { ...cleanBody };
+
+    const response = await fetch(buildAzureDeploymentUrl(deployment, "completions"), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": apiKey
+      },
+      body: JSON.stringify(requestBody)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Azure OpenAI completions failed: \${response.status}\`,
+        details: errorText
+      });
+    }
+
+    if (isStreaming) {
+      await handleStreamingResponse(response, res);
+    } else {
+      const text = await response.text();
+      res.setHeader('Content-Type', 'application/json');
+      res.send(text);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = message.startsWith("Missing Azure OpenAI") ? 400 : 500;
+    res.status(status).json({ error: message });
+  }
+});
+
+app.post("/api/azure/generate", async (req, res) => {
+  try {
+    const { apiKey } = requireAzureBaseConfig();
+    const deployment = resolveAzureDeployment(req.body?.model, AZURE_OPENAI_CHAT_DEPLOYMENT, "chat");
+    const prompt = req.body?.prompt || "";
+    const isStreaming = req.body?.stream === true;
+
+    const chatBody = {
+      messages: [
+        {
+          role: "user",
+          content: prompt
+        }
+      ],
+      stream: isStreaming,
+      max_tokens: req.body?.max_tokens ?? 150,
+      temperature: req.body?.temperature ?? 0.7
+    };
+
+    const response = await fetch(buildAzureDeploymentUrl(deployment, "chat/completions"), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": apiKey
+      },
+      body: JSON.stringify(chatBody)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Azure OpenAI generate failed: \${response.status}\`,
+        details: errorText
+      });
+    }
+
+    if (isStreaming) {
+      await handleStreamingResponse(response, res);
+    } else {
+      const text = await response.text();
+      res.setHeader('Content-Type', 'application/json');
+      res.send(text);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = message.startsWith("Missing Azure OpenAI") ? 400 : 500;
+    res.status(status).json({ error: message });
+  }
+});
+
+app.get("/api/azure/models", async (_req, res) => {
+  try {
+    requireAzureBaseConfig();
+
+    const response = await fetch(buildAzurePath("deployments"), {
+      headers: { "api-key": AZURE_OPENAI_API_KEY }
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Azure OpenAI models failed: \${response.status}\`,
+        details: errorText
+      });
+    }
+
+    const text = await response.text();
+    res.setHeader('Content-Type', 'application/json');
+    res.send(text);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = message.startsWith("Missing Azure OpenAI") ? 400 : 500;
+    res.status(status).json({ error: message });
   }
-  return key;
-};
+});
 
-// Utility function to handle streaming responses
-const handleStreamingResponse = async (upstreamResponse, res) => {
-  res.setHeader('Content-Type', 'text/event-stream');
-  res.setHeader('Cache-Control', 'no-cache');
-  res.setHeader('Connection', 'keep-alive');
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  
+app.post("/api/azure/embed", async (req, res) => {
   try {
-    // Get the readable stream from the response
-    const reader = upstreamResponse.body.getReader();
-    
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      
-      // Write the chunk to the response
-      res.write(value);
+    const { apiKey } = requireAzureBaseConfig();
+    const deployment = resolveAzureDeployment(req.body?.model, AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT, "embeddings");
+    const { provider, model, ...cleanBody } = req.body ?? {};
+    const requestBody = { ...cleanBody };
+
+    const response = await fetch(buildAzureDeploymentUrl(deployment, "embeddings"), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "api-key": apiKey
+      },
+      body: JSON.stringify(requestBody)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Azure OpenAI embed failed: \${response.status}\`,
+        details: errorText
+      });
     }
-    
-    res.end();
-  } catch (error) {
-    console.error('Streaming error:', error);
-    // Fallback to non-streaming
-    const text = await upstreamResponse.text();
+
+    const text = await response.text();
+    res.setHeader('Content-Type', 'application/json');
     res.send(text);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = message.startsWith("Missing Azure OpenAI") ? 400 : 500;
+    res.status(status).json({ error: message });
   }
-};
+});
 
 // ============================================================================
-// GENERAL HEALTH & MODELS
+// XAI ROUTES
 // ============================================================================
 
-app.get("/api/health", async (_req, res) => {
-  const providers = [];
-  
-  // Check OpenAI
+// xAI Health Check
+app.get("/api/xai/health", async (_req, res) => {
   try {
-    const openaiKey = process.env.OPENAI_API_KEY;
-    if (openaiKey) {
-      const response = await fetch("https://api.openai.com/v1/models", {
-        headers: { "Authorization": \`Bearer \${openaiKey}\` }
-      });
-      providers.push({
-        name: "openai",
-        status: response.ok ? "healthy" : "unhealthy",
-        provider: "openai"
+    const xaiKey = requireXAIKey();
+    const response = await fetch(XAI_BASE_URL + "/models", {
+      headers: { "Authorization": "Bearer " + xaiKey }
+    });
+    const isHealthy = response.ok;
+    res.json({
+      status: isHealthy ? "healthy" : "unhealthy",
+      xai_status: isHealthy,
+      provider: "xai"
+    });
+  } catch (error) {
+    res.status(503).json({
+      status: "unhealthy",
+      xai_status: false,
+      error: error instanceof Error ? error.message : String(error),
+      provider: "xai"
+    });
+  }
+});
+
+// xAI Chat Completions
+app.post("/api/xai/chat/completions", async (req, res) => {
+  try {
+    const xaiKey = requireXAIKey();
+    const isStreaming = req.body?.stream === true;
+    const { provider, ...cleanBody } = req.body ?? {};
+    const requestBody = {
+      ...cleanBody,
+      model: req.body?.model?.replace(/^xai:/, "") || "grok-2-latest"
+    };
+
+    const response = await fetch(XAI_BASE_URL + "/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": "Bearer " + xaiKey
+      },
+      body: JSON.stringify(requestBody)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: "xAI chat failed: " + response.status,
+        details: errorText
       });
+    }
+
+    if (isStreaming) {
+      await handleStreamingResponse(response, res);
     } else {
-      providers.push({
-        name: "openai", 
-        status: "unconfigured",
-        provider: "openai",
-        error: "API key not configured"
-      });
+      const text = await response.text();
+      res.setHeader('Content-Type', 'application/json');
+      res.send(text);
     }
   } catch (error) {
-    providers.push({
-      name: "openai",
-      status: "unhealthy", 
-      provider: "openai",
-      error: error.message
-    });
+    res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
   }
+});
 
-  // Check Ollama
+app.post("/api/xai/chat", async (req, res) => {
+  req.url = "/api/xai/chat/completions";
+  return app._router.handle(req, res);
+});
+
+// xAI Completions
+app.post("/api/xai/completions", async (req, res) => {
   try {
-    console.log(\`Checking Ollama health at: \${OLLAMA_BASE_URL}/api/tags\`);
-    const response = await fetch(\`\${OLLAMA_BASE_URL}/api/tags\`);
-    const status = response.ok ? "healthy" : "unhealthy";
-    console.log(\`Ollama health check result: \${status}\`);
-    providers.push({
-      name: "ollama",
-      status: status,
-      provider: "ollama",
-      url: OLLAMA_BASE_URL
+    const xaiKey = requireXAIKey();
+    const isStreaming = req.body?.stream === true;
+    const { provider, ...cleanBody } = req.body ?? {};
+    const requestBody = {
+      ...cleanBody,
+      model: req.body?.model?.replace(/^xai:/, "") || "grok-2-mini"
+    };
+
+    const response = await fetch(XAI_BASE_URL + "/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": "Bearer " + xaiKey
+      },
+      body: JSON.stringify(requestBody)
     });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: "xAI completions failed: " + response.status,
+        details: errorText
+      });
+    }
+
+    if (isStreaming) {
+      await handleStreamingResponse(response, res);
+    } else {
+      const text = await response.text();
+      res.setHeader('Content-Type', 'application/json');
+      res.send(text);
+    }
   } catch (error) {
-    console.log(\`Ollama health check error: \${error.message}\`);
-    providers.push({
-      name: "ollama",
-      status: "offline",
-      provider: "ollama",
-      error: error.message,
-      url: OLLAMA_BASE_URL
-    });
+    res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
   }
+});
 
-  const overallHealthy = providers.some(p => p.status === "healthy");
-  
-  res.json({
-    status: overallHealthy ? "healthy" : "unhealthy",
-    version: QUICKSTART_VERSION,
-    uptime: Math.round(process.uptime()),
-    providers
-  });
+// xAI Generate
+app.post("/api/xai/generate", async (req, res) => {
+  try {
+    const xaiKey = requireXAIKey();
+    const prompt = req.body?.prompt || "";
+    const model = req.body?.model?.replace(/^xai:/, "") || "grok-2-latest";
+    const isStreaming = req.body?.stream === true;
+
+    const chatBody = {
+      model,
+      messages: [
+        { role: "user", content: prompt }
+      ],
+      stream: isStreaming,
+      max_tokens: req.body?.max_tokens || 150,
+      temperature: req.body?.temperature ?? 0.7
+    };
+
+    const response = await fetch(XAI_BASE_URL + "/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": "Bearer " + xaiKey
+      },
+      body: JSON.stringify(chatBody)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: "xAI generate failed: " + response.status,
+        details: errorText
+      });
+    }
+
+    if (isStreaming) {
+      await handleStreamingResponse(response, res);
+    } else {
+      const data = await response.json();
+      const generateResponse = {
+        model,
+        created_at: new Date().toISOString(),
+        response: data.choices?.[0]?.message?.content || "",
+        done: true,
+        context: [],
+        total_duration: 0,
+        load_duration: 0,
+        prompt_eval_count: data.usage?.prompt_tokens || 0,
+        prompt_eval_duration: 0,
+        eval_count: data.usage?.completion_tokens || 0,
+        eval_duration: 0
+      };
+      res.json(generateResponse);
+    }
+  } catch (error) {
+    res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+  }
 });
 
-app.get("/api/models", (_req, res) => {
-  res.json({ models: toGatewayModels() });
+// xAI Models
+app.get("/api/xai/models", async (_req, res) => {
+  try {
+    const xaiKey = requireXAIKey();
+    const response = await fetch(XAI_BASE_URL + "/models", {
+      headers: { "Authorization": "Bearer " + xaiKey }
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: "xAI models failed: " + response.status,
+        details: errorText
+      });
+    }
+
+    const text = await response.text();
+    res.setHeader('Content-Type', 'application/json');
+    res.send(text);
+  } catch (error) {
+    res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+  }
 });
 
 // ============================================================================
@@ -1477,24 +3242,20 @@ app.post("/api/mcp/generate-image", async (req, res) => {
 
 app.all("/api/anthropic/*", (_req, res) => {
   res.status(501).json({
-    error: "Anthropic integration not implemented",
-    message: "This quickstart gateway only supports OpenAI and Ollama providers"
-  });
-});
-
-app.all("/api/azure/*", (_req, res) => {
-  res.status(501).json({
-    error: "Azure OpenAI integration not implemented", 
-    message: "This quickstart gateway only supports OpenAI and Ollama providers"
+    error: "Anthropic route not implemented",
+    message: "Extend the quickstart gateway if you need additional Anthropic endpoints beyond the defaults."
   });
 });
 
 const port = Number(process.env.PORT ?? ${ctx.gatewayPort});
 app.listen(port, () => {
   console.log("\u26A1 Bandit quickstart gateway ready on http://localhost:" + port);
-  console.log("\u{1F4E1} Supported providers: OpenAI, Ollama");
+  console.log("\u{1F4E1} Supported providers: OpenAI, Azure OpenAI, Anthropic, XAI, Ollama");
   console.log("\u{1F517} Provider-specific routes:");
   console.log("   \u2022 /api/openai/* - OpenAI endpoints");
+  console.log("   \u2022 /api/azure/* - Azure OpenAI endpoints");
+  console.log("   \u2022 /api/anthropic/* - Anthropic endpoints");
+  console.log("   \u2022 /api/xai/* - XAI endpoints");
   console.log("   \u2022 /api/ollama/* - Ollama endpoints");
   console.log("   \u2022 /api/health - Overall health check");
 });
@@ -1513,20 +3274,16 @@ dist
 `
   )
 );
-var buildNpmrc = () => ensureTrailingNewline(
-  normalizeLineEndings(`registry=https://registry.npmjs.org/
-`)
-);
 var buildReadme = (ctx) => ensureTrailingNewline(
   normalizeLineEndings(
     `# ${ctx.projectTitle} \u2014 Bandit Quickstart
 
-This project was generated by the Bandit Engine CLI. It ships with a React + Vite frontend that consumes \`@burtson-labs/bandit-engine\` and a lightweight Express gateway you can adapt for production.
+This project was generated by the Bandit Engine CLI. It ships with a React + Vite frontend that consumes \`@burtson-labs/bandit-engine\`, a lightweight Express gateway you can adapt for production, and a Next.js App Router API scaffold in \`server/next-app/\`.
 
 ## \u{1F680} Next steps
 - \`npm install\`
 - \`cp .env.example .env\`
-- Fill in \`OPENAI_API_KEY\` (or point \`OLLAMA_URL\` at your local server)
+- Fill in your OpenAI, Azure OpenAI, Anthropic, or xAI credentials (or point \`OLLAMA_URL\` at your local server)
 - \`npm run dev\`
 
 The command runs the gateway and the frontend together. Visit http://localhost:${ctx.frontendPort} to see the chat and modal in action.
@@ -1539,7 +3296,8 @@ The command runs the gateway and the frontend together. Visit http://localhost:$
 ## \u{1F4E6} What\u2019s inside
 - React + Vite 5 with Material UI theming
 - Bandit chat surface + modal wired via \`ChatProvider\`
-- Express gateway proxying OpenAI or Ollama to keep API keys server-side
+- Express gateway proxying OpenAI, Azure OpenAI, Anthropic, XAI, or Ollama to keep API keys server-side
+- Next.js App Router gateway scaffold in 'server/next-app/' for projects that prefer Next
 - Friendly defaults you can evolve into your production stack
 
 Need more? Run \`npx @burtson-labs/bandit-engine create --help\` to explore additional options.
@@ -1554,8 +3312,9 @@ var createQuickstartProject = async (options) => {
   const packageName = normalizePackageName(rawProjectName);
   const projectTitle = toTitleCase(rawProjectName) || "Bandit Quickstart";
   await ensureWritableDirectory(resolvedDir, Boolean(options.force));
-  const provider = normalizeProvider(options.provider);
-  const promptAnswers = options.skipPrompts ? {} : await promptForMissingData({
+  const skipPrompts = Boolean(options.skipPrompts);
+  const provider = options.provider ? normalizeProvider(options.provider) : skipPrompts ? "ollama" : await promptForProvider();
+  const promptAnswers = skipPrompts ? {} : await promptForMissingData({
     brandingText: options.brandingText,
     provider
   });
@@ -1620,17 +3379,84 @@ var ensureWritableDirectory = async (dir, force) => {
 };
 var normalizeProvider = (value) => {
   const normalized = (value ?? "openai").toLowerCase();
-  return normalized === "ollama" ? "ollama" : "openai";
+  if (normalized === "ollama") {
+    return "ollama";
+  }
+  if (normalized === "azure" || normalized === "azure-openai" || normalized === "azureopenai") {
+    return "azure";
+  }
+  if (normalized === "anthropic") {
+    return "anthropic";
+  }
+  if (normalized === "xai" || normalized === "grok") {
+    return "xai";
+  }
+  return "openai";
 };
 var inferDefaultModelId = (provider) => {
-  return provider === "ollama" ? "ollama:llama3.1" : "openai:gpt-4o-mini";
+  if (provider === "ollama") {
+    return "ollama:llama3.1";
+  }
+  if (provider === "azure") {
+    return "azure:gpt-4o";
+  }
+  if (provider === "anthropic") {
+    return "anthropic:claude-3-5-haiku-latest";
+  }
+  if (provider === "xai") {
+    return "xai:grok-2-latest";
+  }
+  return "openai:gpt-4o-mini";
 };
 var inferFallbackModelId = (provider, defaultId) => {
   if (provider === "ollama") {
     return defaultId === "ollama:llama3" ? "ollama:llama2" : "ollama:llama3";
   }
+  if (provider === "azure") {
+    return defaultId === "azure:gpt-4o-mini" ? "azure:gpt-4o" : "azure:gpt-4o-mini";
+  }
+  if (provider === "anthropic") {
+    return defaultId === "anthropic:claude-3-5-haiku-latest" ? "anthropic:claude-3-haiku-20240307" : "anthropic:claude-3-5-haiku-latest";
+  }
+  if (provider === "xai") {
+    return defaultId === "xai:grok-2-mini" ? "xai:grok-2-latest" : "xai:grok-2-mini";
+  }
   return defaultId === "openai:gpt-4.1-mini" ? "openai:gpt-4o-mini" : "openai:gpt-4.1-mini";
 };
+var promptForProvider = async () => {
+  const providerOptions = [
+    { label: "Ollama (self-hosted) \u2014 default", value: "ollama" },
+    { label: "OpenAI", value: "openai" },
+    { label: "Azure OpenAI", value: "azure" },
+    { label: "Anthropic", value: "anthropic" },
+    { label: "xAI (Grok)", value: "xai" }
+  ];
+  const messageLines = [
+    "Which provider should we configure for the gateway?",
+    ...providerOptions.map((option, index) => `  ${index + 1}. ${option.label}`),
+    "Enter a number:"
+  ];
+  const onCancel = () => {
+    throw new Error("Command cancelled.");
+  };
+  const answers = await (0, import_prompts.default)(
+    {
+      type: "number",
+      name: "providerIndex",
+      message: messageLines.join("\n"),
+      initial: 1,
+      validate: (input) => {
+        if (!Number.isInteger(input)) {
+          return "Enter a whole number.";
+        }
+        return input >= 1 && input <= providerOptions.length ? true : `Enter a number between 1 and ${providerOptions.length}.`;
+      }
+    },
+    { onCancel }
+  );
+  const selectedIndex = typeof answers.providerIndex === "number" && answers.providerIndex >= 1 ? answers.providerIndex - 1 : 0;
+  return providerOptions[selectedIndex]?.value ?? "ollama";
+};
 var sanitizePort = (value) => {
   const port = Number(value);
   if (Number.isNaN(port) || port <= 0 || port >= 65535) {
@@ -1719,9 +3545,12 @@ var writeProject = async (inputs) => {
     "src/theme.ts": buildThemeTs(),
     "public/config.json": buildBrandingConfig(context),
     "server/gateway.js": buildGatewayServer(context),
+    "server/next-app/app/api/chat/completions/route.ts": buildNextChatRoute(context),
+    "server/next-app/app/api/health/route.ts": buildNextHealthRoute(),
+    "server/next-app/app/api/models/route.ts": buildNextModelsRoute(context),
+    "server/next-app/README.md": buildNextGatewayReadme(),
     ".env.example": buildEnvExample(context),
     ".gitignore": buildGitignore(),
-    ".npmrc": buildNpmrc(),
     "README.md": buildReadme(context)
   };
   if (!inputs.logo.isDefault && inputs.logo.fileName) {
@@ -1766,6 +3595,9 @@ var logIntro = () => {
 var program = new import_commander.Command();
 program.name("bandit").description("Bandit Engine developer utilities").version(package_default.version).showHelpAfterError();
 program.command("create").description("Scaffold a Bandit quickstart project with a frontend and gateway").argument("[directory]", "Relative path for your new project", "bandit-quickstart").option("-f, --force", "Overwrite the target directory if it already contains files", false).option("--branding-text <text>", "Assistant display name shown in the UI").option(
+  "--provider <provider>",
+  "Default gateway provider (openai, azure, anthropic, ollama)"
+).option(
   "--frontend-port <port>",
   "Frontend dev server port (default: 5183)",
   (value) => parseInt(value, 10)
@@ -1780,6 +3612,7 @@ program.command("create").description("Scaffold a Bandit quickstart project with
       projectName,
       force: Boolean(cmdOptions.force),
       brandingText: cmdOptions.brandingText,
+      provider: typeof cmdOptions.provider === "string" ? cmdOptions.provider : void 0,
       frontendPort: Number.isFinite(cmdOptions.frontendPort) ? cmdOptions.frontendPort : void 0,
       gatewayPort: Number.isFinite(cmdOptions.gatewayPort) ? cmdOptions.gatewayPort : void 0,
       skipPrompts
@@ -1797,6 +3630,11 @@ program.command("create").description("Scaffold a Bandit quickstart project with
     console.log("  cp .env.example .env");
     console.log("  npm run dev");
     console.log("");
+    console.log("\u{1F50D} Before you dive in:");
+    console.log("  \u2022 Open .env to confirm the provider credentials and URLs match your setup.");
+    console.log("  \u2022 server/gateway.js is a scaffold Express proxy that keeps API keys server-side\u2014extend it with auth, logging, and your production logic.");
+    console.log("  \u2022 If you prefer Next.js App Router, check server/next-app/ for a starter route handler.");
+    console.log("");
   } catch (error) {
     const message = error instanceof Error ? error.message : "Failed to create Bandit quickstart project.";
     console.error(`