@burtson-labs/bandit-engine 2.0.35 → 2.0.37

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.35",
+  version: "2.0.37",
   license: "BUSL-1.1",
   main: "dist/index.js",
   module: "dist/index.mjs",
@@ -162,14 +162,29 @@ var toTitleCase = (value) => {
 };
 var formatJson = (value) => `${JSON.stringify(value, null, 2)}
 `;
+var KNOWN_PROVIDERS = /* @__PURE__ */ new Set(["openai", "azure", "azure-openai", "azureopenai", "anthropic", "xai", "ollama"]);
 var sanitizeModelIdentifier = (value) => {
   const trimmed = value.trim();
   if (!trimmed.includes(":")) {
     return trimmed.toLowerCase();
   }
-  const [provider, model] = trimmed.split(/:(.+)/).filter(Boolean);
-  const cleanModel = model.replace(/[^a-zA-Z0-9_.-]/g, "-").replace(/-+/g, "-").toLowerCase();
-  return `${provider.toLowerCase()}:${cleanModel}`;
+  const segments = trimmed.split(/:(.+)/).filter(Boolean);
+  if (segments.length < 2) {
+    return trimmed.toLowerCase();
+  }
+  const [candidateProvider, rest] = segments;
+  const provider = candidateProvider.toLowerCase();
+  const cleanRest = rest.trim().replace(/[^a-zA-Z0-9_.:-]/g, "-").replace(/-+/g, "-").toLowerCase();
+  if (KNOWN_PROVIDERS.has(provider)) {
+    if (provider === "azure-openai" || provider === "azureopenai") {
+      return `azure:${cleanRest}`;
+    }
+    if (provider === "ollama") {
+      return cleanRest;
+    }
+    return `${provider}:${cleanRest}`;
+  }
+  return [candidateProvider, rest].filter(Boolean).join(":").replace(/[^a-zA-Z0-9_.:-]/g, "-").replace(/-+/g, "-").toLowerCase();
 };
 var normalizeLineEndings = (content) => content.replace(/\r\n/g, "\n");
 var ensureTrailingNewline = (content) => content.endsWith("\n") ? content : `${content}
@@ -214,33 +229,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-................................
-# AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com
-# AZURE_OPENAI_API_KEY=................................................................
-# AZURE_OPENAI_API_VERSION=2024-08-01-preview
-# AZURE_OPENAI_CHAT_DEPLOYMENT=gpt-4o
-# AZURE_OPENAI_COMPLETIONS_DEPLOYMENT=gpt-35-turbo-instruct
-# AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT=text-embedding-3-large
-# ANTHROPIC_API_KEY=sk-ant-................................
-# ANTHROPIC_BASE_URL=https://api.anthropic.com
-# ANTHROPIC_API_VERSION=2023-06-01
-# ANTHROPIC_MAX_TOKENS=1024
-# 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",
@@ -439,7 +473,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" | "azure" | "anthropic";
+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";
@@ -621,7 +655,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, Azure OpenAI, Anthropic, 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">
@@ -668,7 +702,7 @@ function App() {
                 Ship secure gateways
               </Typography>
               <Typography variant="body2" color="text.secondary">
-                Keep API keys server-side while proxying requests to OpenAI, Azure OpenAI, Anthropic, 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>
@@ -815,21 +849,679 @@ function App() {
   );
 }
 
-export default App;
+export default App;
+`;
+  const withResponse = template.replace(/__RESPONSE_STATUS__/g, responseStatusExpr);
+  const withGatewayError = withResponse.replace(/__GATEWAY_ERROR__/g, gatewayErrorExpr);
+  return ensureTrailingNewline(normalizeLineEndings(withGatewayError));
+};
+var buildBrandingConfig = (ctx) => formatJson({
+  branding: {
+    logoBase64: ctx.isDefaultLogo ? null : ctx.logoBase64,
+    brandingText: ctx.brandingText,
+    theme: "bandit-dark",
+    hasTransparentLogo: ctx.isDefaultLogo ? true : ctx.hasTransparentLogo
+  },
+  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,
+  });
+}
+
 `;
-  const withResponse = template.replace(/__RESPONSE_STATUS__/g, responseStatusExpr);
-  const withGatewayError = withResponse.replace(/__GATEWAY_ERROR__/g, gatewayErrorExpr);
-  return ensureTrailingNewline(normalizeLineEndings(withGatewayError));
+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 buildBrandingConfig = (ctx) => formatJson({
-  branding: {
-    logoBase64: ctx.isDefaultLogo ? null : ctx.logoBase64,
-    brandingText: ctx.brandingText,
-    theme: "bandit-dark",
-    hasTransparentLogo: ctx.isDefaultLogo ? true : ctx.hasTransparentLogo
-  },
-  knowledgeDocs: []
-});
+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";
@@ -859,6 +1551,8 @@ 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) => ({
@@ -1065,6 +1759,14 @@ const requireOpenAIKey = () => {
   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');
@@ -1093,6 +1795,93 @@ const handleStreamingResponse = async (upstreamResponse, res) => {
   }
 };
 
+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
 // ============================================================================
@@ -1202,6 +1991,37 @@ app.get("/api/health", async (_req, res) => {
     });
   }
 
+  // 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\`);
@@ -1277,7 +2097,7 @@ app.post("/api/anthropic/chat/completions", async (req, res) => {
     const requestedModel =
       stripAnthropicModelPrefix(rawBody.model) ??
       stripAnthropicModelPrefix("${ctx.defaultModelId}") ??
-      "claude-3-5-sonnet-latest";
+      "claude-3-5-haiku-latest";
 
     const stopSequences = Array.isArray(rawBody.stop)
       ? rawBody.stop
@@ -1360,7 +2180,7 @@ app.post("/api/anthropic/chat/completions", async (req, res) => {
     }
 
     if (isStreaming) {
-      await handleStreamingResponse(response, res);
+      await relayAnthropicStream(response, res);
     } else {
       const data = await response.json();
       const normalized = convertAnthropicResponseToGateway(data, requestedModel);
@@ -1455,7 +2275,7 @@ app.post("/api/anthropic/completions", async (req, res) => {
     }
 
     if (isStreaming) {
-      await handleStreamingResponse(response, res);
+      await relayAnthropicStream(response, res);
     } else {
       const data = await response.json();
       const formatted = convertAnthropicResponseToGenerate(data, requestedModel);
@@ -1728,6 +2548,201 @@ app.post("/api/azure/embed", async (req, res) => {
   }
 });
 
+// ============================================================================
+// XAI ROUTES
+// ============================================================================
+
+// xAI Health Check
+app.get("/api/xai/health", async (_req, res) => {
+  try {
+    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 {
+      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) });
+  }
+});
+
+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 {
+    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) {
+    res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+// 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) });
+  }
+});
+
+// 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) });
+  }
+});
+
 // ============================================================================
 // OPENAI ROUTES
 // ============================================================================
@@ -2250,11 +3265,12 @@ app.all("/api/anthropic/*", (_req, res) => {
 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, Azure OpenAI, Anthropic, 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");
 });
@@ -2273,20 +3289,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 your OpenAI, Azure OpenAI, or Anthropic credentials (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.
@@ -2299,7 +3311,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, Azure OpenAI, Anthropic, 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.
@@ -2315,7 +3328,7 @@ var createQuickstartProject = async (options) => {
   const projectTitle = toTitleCase(rawProjectName) || "Bandit Quickstart";
   await ensureWritableDirectory(resolvedDir, Boolean(options.force));
   const skipPrompts = Boolean(options.skipPrompts);
-  const provider = options.provider ? normalizeProvider(options.provider) : skipPrompts ? "openai" : await promptForProvider();
+  const provider = options.provider ? normalizeProvider(options.provider) : skipPrompts ? "ollama" : await promptForProvider();
   const promptAnswers = skipPrompts ? {} : await promptForMissingData({
     brandingText: options.brandingText,
     provider
@@ -2333,7 +3346,8 @@ var createQuickstartProject = async (options) => {
   const defaultModelId = sanitizeModelIdentifier(
     options.defaultModelId ?? inferDefaultModelId(provider)
   );
-  const fallbackModelId = options.fallbackModelId ? sanitizeModelIdentifier(options.fallbackModelId) : inferFallbackModelId(provider, defaultModelId);
+  const fallbackModelRaw = options.fallbackModelId ? options.fallbackModelId : inferFallbackModelId(provider, defaultModelId);
+  const fallbackModelId = fallbackModelRaw ? sanitizeModelIdentifier(fallbackModelRaw) : void 0;
   const inputs = {
     targetDir: resolvedDir,
     projectTitle,
@@ -2390,38 +3404,52 @@ var normalizeProvider = (value) => {
   if (normalized === "anthropic") {
     return "anthropic";
   }
+  if (normalized === "xai" || normalized === "grok") {
+    return "xai";
+  }
   return "openai";
 };
 var inferDefaultModelId = (provider) => {
   if (provider === "ollama") {
-    return "ollama:llama3.1";
+    return "llama3.1";
   }
   if (provider === "azure") {
     return "azure:gpt-4o";
   }
   if (provider === "anthropic") {
-    return "anthropic:claude-3-5-sonnet-latest";
+    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";
+    const normalized = defaultId.toLowerCase();
+    if (normalized.startsWith("llama3")) {
+      return "llama2";
+    }
+    return "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-5-sonnet-latest" : "anthropic:claude-3-5-haiku-latest";
+    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: "OpenAI (default)", value: "openai" },
+    { label: "Ollama (self-hosted) \u2014 default", value: "ollama" },
+    { label: "OpenAI", value: "openai" },
     { label: "Azure OpenAI", value: "azure" },
     { label: "Anthropic", value: "anthropic" },
-    { label: "Ollama (self-hosted)", value: "ollama" }
+    { label: "xAI (Grok)", value: "xai" }
   ];
   const messageLines = [
     "Which provider should we configure for the gateway?",
@@ -2447,7 +3475,7 @@ var promptForProvider = async () => {
     { onCancel }
   );
   const selectedIndex = typeof answers.providerIndex === "number" && answers.providerIndex >= 1 ? answers.providerIndex - 1 : 0;
-  return providerOptions[selectedIndex]?.value ?? "openai";
+  return providerOptions[selectedIndex]?.value ?? "ollama";
 };
 var sanitizePort = (value) => {
   const port = Number(value);
@@ -2537,9 +3565,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) {
@@ -2619,6 +3650,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(`