@burtson-labs/bandit-engine 2.0.8

package/dist/cli/cli.js

@@ -0,0 +1,1808 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/index.ts
+var import_node_path3 = __toESM(require("path"));
+var import_commander = require("commander");
+
+// package.json
+var package_default = {
+  name: "@burtson-labs/bandit-engine",
+  version: "2.0.8",
+  license: "BUSL-1.1",
+  main: "dist/index.js",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  bin: {
+    bandit: "dist/cli/cli.js"
+  },
+  files: [
+    "dist",
+    "dist/cli",
+    "docs",
+    "LICENSE",
+    "README.md"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/Burtson-Labs/bandit.git",
+    directory: "packages/bandit-engine"
+  },
+  author: "Burtson Labs LLC <team@burtson.ai>",
+  maintainers: [
+    {
+      name: "Burtson Labs LLC",
+      email: "team@burtson.ai"
+    }
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    docs: "typedoc src --out docs/api_reference --skipErrorChecking",
+    lint: 'eslint "src/**/*.{ts,tsx}"',
+    test: "vitest",
+    protect: "node scripts/add-license-headers.js",
+    "validate-protection": "node scripts/validate-protection.js"
+  },
+  overrides: {
+    "sha.js": "^2.4.12"
+  },
+  dependencies: {
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0",
+    "@hello-pangea/dnd": "^18.0.1",
+    "@mui/icons-material": "^7.0.1",
+    "@mui/material": "^7.1.0",
+    "@tanstack/react-query": "^5.66.3",
+    axios: "^1.7.9",
+    "crypto-browserify": "^3.12.1",
+    commander: "^12.1.0",
+    "fs-extra": "^11.3.0",
+    idb: "latest",
+    mammoth: "^1.9.0",
+    "pdfjs-dist": "^5.2.133",
+    prompts: "^2.4.2",
+    react: "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-markdown": "^10.1.0",
+    "react-router-dom": "^7.5.0",
+    "rehype-raw": "^7.0.0",
+    "rehype-sanitize": "^6.0.0",
+    lowlight: "^3.1.0",
+    "highlight.js": "^11.10.0",
+    "remark-gfm": "^4.0.1",
+    "remark-mark": "^0.0.0",
+    rxjs: "^7.8.2",
+    uuid: "^11.1.0",
+    zustand: "^4.5.6"
+  },
+  devDependencies: {
+    "@esbuild-plugins/node-globals-polyfill": "^0.2.3",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^24.0.3",
+    "@types/react": "^18.3.22",
+    "@types/react-dom": "^18.2.17",
+    "@types/react-router-dom": "^5.3.3",
+    "@types/fs-extra": "^11.0.4",
+    "@types/prompts": "^2.4.9",
+    "@types/uuid": "^10.0.0",
+    "@vitejs/plugin-react": "^4.6.0",
+    "@vitest/ui": "^3.2.4",
+    typedoc: "^0.26.11",
+    eslint: "^8.57.0",
+    "eslint-plugin-react": "^7.34.1",
+    jsdom: "^26.1.0",
+    tsup: "^8.5.0",
+    typescript: "5.5.4",
+    vitest: "^3.2.4"
+  },
+  peerDependencies: {
+    react: ">=18",
+    "@mui/material": ">=5",
+    zustand: ">=4"
+  },
+  exports: {
+    ".": {
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    }
+  }
+};
+
+// src/cli/createQuickstart.ts
+var import_node_path2 = __toESM(require("path"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_prompts = __toESM(require("prompts"));
+
+// src/cli/utils.ts
+var import_node_path = __toESM(require("path"));
+var toKebabCase = (value) => {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[\s_./]+/g, "-").replace(/[^a-zA-Z0-9-]+/g, "").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+};
+var toTitleCase = (value) => {
+  const cleaned = value.replace(/[-_/]+/g, " ").replace(/\s+/g, " ").trim();
+  if (!cleaned) {
+    return "";
+  }
+  return cleaned.replace(/\b\w/g, (char) => char.toUpperCase());
+};
+var formatJson = (value) => `${JSON.stringify(value, null, 2)}
+`;
+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}`;
+};
+var normalizeLineEndings = (content) => content.replace(/\r\n/g, "\n");
+var ensureTrailingNewline = (content) => content.endsWith("\n") ? content : `${content}
+`;
+
+// src/cli/templates.ts
+var QUOTE = '"';
+var buildPackageJson = (ctx) => formatJson({
+  name: ctx.packageName,
+  private: true,
+  version: "0.1.0",
+  type: "module",
+  scripts: {
+    dev: 'concurrently -k "npm run dev:gateway" "npm run dev:web"',
+    "dev:web": "vite",
+    "dev:gateway": "node server/gateway.js",
+    build: "vite build",
+    preview: "vite preview"
+  },
+  dependencies: {
+    "@burtson-labs/bandit-engine": `^${ctx.engineVersion}`,
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0",
+    "@mui/material": "^7.1.0",
+    "@tanstack/react-query": "^5.59.20",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.5",
+    "express": "^4.19.2",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-router-dom": "^7.5.0",
+    "zustand": "^4.5.6"
+  },
+  devDependencies: {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.17.7",
+    "@types/react": "^18.3.22",
+    "@types/react-dom": "^18.2.18",
+    "@vitejs/plugin-react": "^5.0.0",
+    "concurrently": "^8.2.2",
+    "typescript": "^5.5.4",
+    "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 buildTsConfig = () => formatJson({
+  compilerOptions: {
+    target: "ESNext",
+    useDefineForClassFields: true,
+    lib: ["DOM", "DOM.Iterable", "ESNext"],
+    allowJs: false,
+    skipLibCheck: true,
+    esModuleInterop: true,
+    allowSyntheticDefaultImports: true,
+    strict: true,
+    forceConsistentCasingInFileNames: true,
+    module: "ESNext",
+    moduleResolution: "Node",
+    resolveJsonModule: true,
+    isolatedModules: true,
+    noEmit: true,
+    jsx: "react-jsx"
+  },
+  include: ["src"]
+});
+var buildEnvDts = () => ensureTrailingNewline(
+  `/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_GATEWAY_URL?: string;
+  readonly VITE_GATEWAY_PROVIDER?: string;
+  readonly VITE_DEFAULT_MODEL?: string;
+  readonly VITE_FALLBACK_MODEL?: string;
+  readonly VITE_FEEDBACK_EMAIL?: string;
+  readonly VITE_BRANDING_TEXT?: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}
+`
+);
+var buildViteConfig = (ctx) => ensureTrailingNewline(
+  normalizeLineEndings(
+    `import { defineConfig, loadEnv } from "vite";
+import react from "@vitejs/plugin-react";
+
+export default defineConfig(({ mode }) => {
+  const env = loadEnv(mode, process.cwd(), "");
+  const parsedPort = Number(env.VITE_DEV_PORT || env.PORT || ${ctx.frontendPort});
+  const port = Number.isFinite(parsedPort) ? parsedPort : ${ctx.frontendPort};
+
+  return {
+    plugins: [react()],
+    resolve: {
+      dedupe: [
+        "react",
+        "react-dom",
+        "@mui/material",
+        "@mui/system",
+        "@emotion/react",
+        "@emotion/styled",
+        "react-router-dom"
+      ],
+    },
+    optimizeDeps: {
+      include: ["@burtson-labs/bandit-engine"],
+    },
+    server: {
+      port,
+    },
+  };
+});
+`
+  )
+);
+var buildMainTsx = () => ensureTrailingNewline(
+  normalizeLineEndings(
+    `import React from "react";
+import ReactDOM from "react-dom/client";
+import { BrowserRouter } from "react-router-dom";
+import App from "./App";
+import "./index.css";
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+  <React.StrictMode>
+    <BrowserRouter>
+      <App />
+    </BrowserRouter>
+  </React.StrictMode>
+);
+`
+  )
+);
+var buildIndexCss = () => ensureTrailingNewline(
+  normalizeLineEndings(
+    `:root {
+  font-family: "Inter", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  background: radial-gradient(circle at top left, rgba(120, 119, 255, 0.12), transparent 45%),
+    radial-gradient(circle at bottom right, rgba(244, 114, 182, 0.1), transparent 55%),
+    #05070f;
+  color: #f8fafc;
+  min-height: 100vh;
+}
+
+body {
+  margin: 0;
+}
+
+* {
+  box-sizing: border-box;
+}
+`
+  )
+);
+var buildIndexHtml = () => ensureTrailingNewline(
+  normalizeLineEndings(
+    `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" href="https://cdn.burtson.ai/images/bandit-head.png" />
+    <title>Bandit Quickstart</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`
+  )
+);
+var buildThemeTs = () => ensureTrailingNewline(
+  normalizeLineEndings(
+    `import { createTheme } from "@mui/material/styles";
+
+export const banditQuickstartTheme = createTheme({
+  palette: {
+    mode: "dark",
+    primary: {
+      main: "#f97316",
+    },
+    secondary: {
+      main: "#6366f1",
+    },
+    background: {
+      default: "#05070f",
+      paper: "rgba(15, 23, 42, 0.78)",
+    },
+  },
+  typography: {
+    fontFamily: '"Inter", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
+    h1: {
+      fontWeight: 700,
+    },
+    h2: {
+      fontWeight: 600,
+    },
+  },
+  components: {
+    MuiPaper: {
+      styleOverrides: {
+        root: {
+          backdropFilter: "blur(18px)",
+          backgroundImage: "linear-gradient(145deg, rgba(15, 23, 42, 0.92), rgba(2, 6, 23, 0.92))",
+        },
+      },
+    },
+  },
+});
+`
+  )
+);
+var buildAppTsx = (ctx) => {
+  const responseStatusExpr = "${response.status}";
+  const gatewayErrorExpr = '${gatewayError ?? "Unknown"}';
+  const template = `
+import { useEffect, useState, useMemo, useCallback, type ReactNode } from "react";
+import {
+  CssBaseline,
+  AppBar,
+  Toolbar,
+  Typography,
+  Container,
+  Box,
+  Button,
+  Chip,
+  Tooltip,
+  Stack,
+  Card,
+  CardContent
+} from "@mui/material";
+import { ThemeProvider } from "@mui/material/styles";
+import { Routes, Route, Navigate, Link as RouterLink, useLocation } from "react-router-dom";
+import { ChatProvider, Chat, ChatModal, Management } from "@burtson-labs/bandit-engine";
+import * as BanditEngine from "@burtson-labs/bandit-engine";
+import { banditQuickstartTheme } from "./theme";
+
+const gatewayBaseUrl = (import.meta.env.VITE_GATEWAY_URL ?? "${ctx.defaultGatewayUrl}").replace(/\\/$/, "");
+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 gatewayApiUrl = gatewayBaseUrl.endsWith("/api") ? gatewayBaseUrl : gatewayBaseUrl + "/api";
+const banditHeadLogoUrl = "https://cdn.burtson.ai/images/bandit-head.png";
+const burtsonLabsLogoUrl = "https://cdn.burtson.ai/logos/burtson-labs-logo-alt.png";
+const healthEndpoint = gatewayApiUrl + "/health";
+
+// Move packageSettings outside the component to prevent recreation on every render
+const packageSettings = {
+  defaultModel: defaultModelId,
+  fallbackModel: fallbackModelId,
+  gatewayApiUrl: gatewayApiUrl,
+  brandingConfigUrl: "/config.json",
+  aiProvider: {
+    type: "gateway" as const,
+    gatewayUrl: gatewayApiUrl,
+    provider,
+    tokenFactory: () => {
+      return localStorage.getItem("authToken");
+    }
+  },
+  feedbackEmail: import.meta.env.VITE_FEEDBACK_EMAIL,
+  featureFlags: {
+    subscriptionType: "premium" as const,
+    rolesClaimKey: "roles",
+    subscriptionTypeClaimKey: "subscriptionType", 
+    isSubscribedClaimKey: "isSubscribed",
+    jwtStorageKey: "authToken",
+    adminRole: "admin",
+    debug: true,
+    featureMatrix: {
+      tts: false,
+      stt: false,
+      semanticSearchSimple: false,
+      semanticSearchPremium: false,
+      advancedSearch: false,
+      advancedMemories: false,
+    },
+  },
+};
+
+function App() {
+  const location = useLocation();
+  const [isModalOpen, setIsModalOpen] = useState(false);
+  const [gatewayStatus, setGatewayStatus] = useState<"checking" | "healthy" | "error">("checking");
+  const [gatewayError, setGatewayError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (typeof window !== "undefined") {
+      const applyAuthToken = (token: string) => {
+        localStorage.setItem("authToken", token);
+        const maybeService = (BanditEngine as { authenticationService?: { setToken: (token: string) => void } }).authenticationService;
+        try {
+          maybeService?.setToken(token);
+        } catch (error) {
+          console.warn("Bandit quickstart: failed to seed authentication service token", error);
+        }
+      };
+
+      const ensureAuthToken = () => {
+        const existing = localStorage.getItem("authToken");
+        if (existing) {
+          applyAuthToken(existing);
+          return;
+        }
+
+        const header = {
+          alg: "HS256",
+          typ: "JWT",
+        };
+        const payload = {
+          exp: Math.floor(Date.now() / 1000) + 60 * 60 * 8,
+          roles: ["admin"],
+          iat: Math.floor(Date.now() / 1000),
+          email: "quickstart@burtson.ai",
+          sub: "123456789012345678901",
+        };
+        const encodeSegment = (value: unknown) =>
+          btoa(JSON.stringify(value))
+            .replace(/=+$/g, "")
+            .replace(/\\+/g, "-")
+            .replace(/\\//g, "_");
+        const mockToken = \`${"${"}encodeSegment(header)}.${"${"}encodeSegment(payload)}.quickstart\`;
+        applyAuthToken(mockToken);
+      };
+
+      ensureAuthToken();
+    }
+  }, []);
+
+  // Separate effect for health checking to avoid re-renders
+  useEffect(() => {
+    let cancelled = false;
+
+    const checkHealth = async () => {
+      try {
+        const response = await fetch(healthEndpoint, { headers: { "Content-Type": "application/json" } });
+        if (!response.ok) {
+          throw new Error(\`HTTP __RESPONSE_STATUS__\`);
+        }
+        await response.json();
+        if (!cancelled) {
+          setGatewayStatus(prevStatus => prevStatus !== "healthy" ? "healthy" : prevStatus);
+          setGatewayError(prevError => prevError !== null ? null : prevError);
+        }
+      } catch (error) {
+        if (!cancelled) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          setGatewayStatus(prevStatus => prevStatus !== "error" ? "error" : prevStatus);
+          setGatewayError(prevError => prevError !== errorMessage ? errorMessage : prevError);
+        }
+      }
+    };
+
+    // Initial check
+    checkHealth();
+    
+    // Set up interval for periodic checks
+    const interval = setInterval(checkHealth, 15000);
+    
+    return () => {
+      cancelled = true;
+      clearInterval(interval);
+    };
+  }, []);
+
+  const gatewayChip = useMemo(() => (
+    <Tooltip
+      title={
+        gatewayStatus === "error"
+          ? \`Gateway health check failed. Last error: __GATEWAY_ERROR__\`
+          : gatewayStatus === "healthy"
+            ? "Gateway reachable"
+            : "Checking gateway health..."
+      }
+    >
+      <Chip
+        size="small"
+        color={gatewayStatus === "healthy" ? "success" : gatewayStatus === "error" ? "error" : "default"}
+        variant={gatewayStatus === "healthy" ? "filled" : "outlined"}
+        label={
+          gatewayStatus === "healthy"
+            ? "Gateway: Healthy"
+            : gatewayStatus === "error"
+              ? "Gateway: Unreachable"
+              : "Gateway: Checking..."
+        }
+        sx={{ fontWeight: 600 }}
+      />
+    </Tooltip>
+  ), [gatewayStatus, gatewayError]);
+
+  const handleOpenModal = useCallback(() => setIsModalOpen(true), []);
+  const handleCloseModal = useCallback(() => setIsModalOpen(false), []);
+
+  const HomePage = ({ onOpenModal }: { onOpenModal: () => void }) => (
+    <Container maxWidth="lg" sx={{ py: { xs: 4, md: 6 } }}>
+      <Stack spacing={{ xs: 5, md: 7 }}>
+        <Box
+          sx={{
+            display: "flex",
+            flexDirection: { xs: "column-reverse", md: "row" },
+            alignItems: "center",
+            gap: { xs: 4, md: 8 },
+          }}
+        >
+          <Stack spacing={3} sx={{ flex: 1, width: "100%" }}>
+            <Box sx={{ display: "flex", alignItems: "center", gap: 2 }}>
+              <Box
+                component="img"
+                src={banditHeadLogoUrl}
+                alt="Bandit AI logo"
+                sx={{ height: 48, width: 48, borderRadius: 3, boxShadow: "0 18px 50px rgba(99, 102, 241, 0.35)" }}
+              />
+              <Typography variant="overline" color="primary.light" sx={{ letterSpacing: 2 }}>
+                Powered by Bandit Engine
+              </Typography>
+            </Box>
+            <Typography variant="h3" fontWeight={700}>
+              {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.
+            </Typography>
+            <Stack direction={{ xs: "column", sm: "row" }} spacing={2}>
+              <Button component={RouterLink} to="/chat" variant="contained" color="primary">
+                Go to chat demo
+              </Button>
+              <Button variant="outlined" color="secondary" onClick={onOpenModal}>
+                Open modal assistant
+              </Button>
+            </Stack>
+          </Stack>
+          <Box
+            component="img"
+            src={burtsonLabsLogoUrl}
+            alt="Burtson Labs logo"
+            sx={{
+              width: "100%",
+              maxWidth: 320,
+              mx: { xs: "auto", md: 0 },
+              display: "block",
+              filter: "drop-shadow(0 25px 45px rgba(15, 23, 42, 0.45))",
+            }}
+          />
+        </Box>
+        <Box
+          sx={{
+            display: "grid",
+            gap: 3,
+            gridTemplateColumns: { xs: "1fr", md: "repeat(3, minmax(0, 1fr))" },
+          }}
+        >
+          <Card sx={{ height: "100%", backdropFilter: "blur(12px)", backgroundColor: "rgba(15, 23, 42, 0.64)" }}>
+            <CardContent>
+              <Typography variant="h6" gutterBottom>
+                Configure in minutes
+              </Typography>
+              <Typography variant="body2" color="text.secondary">
+                Edit <code>public/config.json</code> and <code>.env</code> to tailor models, personas, and branding for your product.
+              </Typography>
+            </CardContent>
+          </Card>
+          <Card sx={{ height: "100%", backdropFilter: "blur(12px)", backgroundColor: "rgba(15, 23, 42, 0.64)" }}>
+            <CardContent>
+              <Typography variant="h6" gutterBottom>
+                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.
+              </Typography>
+            </CardContent>
+          </Card>
+          <Card sx={{ height: "100%", backdropFilter: "blur(12px)", backgroundColor: "rgba(15, 23, 42, 0.64)" }}>
+            <CardContent>
+              <Typography variant="h6" gutterBottom>
+                Manage knowledge freely
+              </Typography>
+              <Typography variant="body2" color="text.secondary">
+                Add memories, files, and tools directly in the management console that ships with this quickstart.
+              </Typography>
+              <Button component={RouterLink} to="/management" variant="text" color="secondary" sx={{ mt: 2, px: 0 }}>
+                Explore management console
+              </Button>
+            </CardContent>
+          </Card>
+        </Box>
+      </Stack>
+    </Container>
+  );
+
+  const ChatPage = ({ onOpenModal }: { onOpenModal: () => void }) => (
+    <Container maxWidth="lg" sx={{ py: 4, display: "flex", flexDirection: "column", gap: 3 }}>
+      <Stack
+        direction={{ xs: "column", md: "row" }}
+        spacing={2}
+        alignItems={{ xs: "stretch", md: "center" }}
+        justifyContent="space-between"
+      >
+        <Box>
+          <Typography variant="h4" fontWeight={700} gutterBottom>
+            Chat demo
+          </Typography>
+          <Typography variant="body2" color="text.secondary">
+            This route renders the full <code>{\`<Chat />\`}</code> surface powered by your quickstart gateway.
+          </Typography>
+        </Box>
+        <Stack direction={{ xs: "column", sm: "row" }} spacing={1.5}>
+          <Button component={RouterLink} to="/management" variant="outlined" color="secondary">
+            Management console
+          </Button>
+          <Button variant="contained" color="primary" onClick={onOpenModal}>
+            Open modal assistant
+          </Button>
+        </Stack>
+      </Stack>
+      <Box
+        sx={{
+          flexGrow: 1,
+          minHeight: 540,
+          borderRadius: 3,
+          overflow: "hidden",
+          boxShadow: "0 35px 90px rgba(15, 23, 42, 0.55)",
+        }}
+      >
+        <Chat />
+      </Box>
+    </Container>
+  );
+
+  const Header = ({ gatewayChip }: { gatewayChip: ReactNode }) => (
+    <AppBar
+      position="sticky"
+      color="transparent"
+      elevation={0}
+      sx={{ borderBottom: "1px solid rgba(148, 163, 184, 0.16)", backdropFilter: "blur(18px)" }}
+    >
+      <Toolbar sx={{ gap: 2, flexWrap: "wrap" }}>
+        <Button
+          component={RouterLink}
+          to="/"
+          color="inherit"
+          sx={{
+            display: "flex",
+            alignItems: "center",
+            gap: 1.5,
+            py: 1,
+            px: 1.5,
+            borderRadius: 2,
+            textTransform: "none",
+            bgcolor: "transparent",
+            "&:hover": { bgcolor: "rgba(99, 102, 241, 0.12)" },
+          }}
+        >
+          <Typography variant="h6" sx={{ fontWeight: 600 }}>
+            {brandingText}
+          </Typography>
+        </Button>
+        <Box sx={{ flexGrow: 1 }} />
+        {gatewayChip}
+        <Stack direction="row" spacing={1} flexWrap="wrap" justifyContent="flex-end">
+          <Button component={RouterLink} to="/" color="inherit">
+            Home
+          </Button>
+          <Button component={RouterLink} to="/management" color="inherit">
+            Management
+          </Button>
+          <Button component={RouterLink} to="/chat" variant="contained" color="primary">
+            Go to chat
+          </Button>
+        </Stack>
+      </Toolbar>
+    </AppBar>
+  );
+
+  return (
+    <Routes>
+      <Route path="/management" element={
+        <ChatProvider packageSettings={packageSettings}>
+          <Management />
+        </ChatProvider>
+      } />
+      <Route path="/chat" element={
+            <ThemeProvider theme={banditQuickstartTheme}>
+              <CssBaseline />
+              <ChatProvider packageSettings={packageSettings}>
+                <Box display="flex" flexDirection="column" minHeight="100vh">
+                  <Box component="main" sx={{ flexGrow: 1, display: "flex" }}>
+                    <ChatPage onOpenModal={handleOpenModal} />
+                  </Box>
+                  <ChatModal open={isModalOpen} onClose={handleCloseModal} />
+                </Box>
+              </ChatProvider>
+            </ThemeProvider>
+          } />
+          <Route path="/*" element={
+            <ThemeProvider theme={banditQuickstartTheme}>
+              <CssBaseline />
+              <ChatProvider packageSettings={packageSettings}>
+                <Box display="flex" flexDirection="column" minHeight="100vh">
+                <Header gatewayChip={gatewayChip} />
+                <Box component="main" sx={{ flexGrow: 1, display: "flex" }}>
+                  <Routes>
+                    <Route path="/" element={<HomePage onOpenModal={handleOpenModal} />} />
+                    <Route path="*" element={<Navigate to="/" replace />} />
+                  </Routes>
+                </Box>
+                <ChatModal open={isModalOpen} onClose={handleCloseModal} />
+                </Box>
+              </ChatProvider>
+            </ThemeProvider>
+          } />
+        </Routes>
+  );
+}
+
+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 buildGatewayServer = (ctx) => {
+  const modelsDefinition = JSON.stringify(ctx.gatewayModels, null, 2);
+  const gatewaySource = `import express from "express";
+import cors from "cors";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+const app = express();
+app.use(cors());
+app.use(express.json({ limit: '50mb' }));
+app.use(express.urlencoded({ limit: '50mb', extended: true }));
+
+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 toGatewayModels = () =>
+  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: "",
+    },
+  }));
+
+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;
+};
+
+// 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);
+  }
+};
+
+// ============================================================================
+// 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 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() });
+});
+
+// ============================================================================
+// OPENAI ROUTES
+// ============================================================================
+
+// OpenAI Health Check
+app.get("/api/openai/health", async (_req, res) => {
+  try {
+    const openaiKey = process.env.OPENAI_API_KEY;
+    if (!openaiKey) {
+      return res.status(503).json({
+        status: "unhealthy",
+        openai_status: false,
+        error: "OpenAI API key not configured",
+        provider: "openai"
+      });
+    }
+
+    const response = await fetch("https://api.openai.com/v1/models", {
+      headers: { "Authorization": \`Bearer \${openaiKey}\` }
+    });
+
+    const isHealthy = response.ok;
+    res.json({
+      status: isHealthy ? "healthy" : "unhealthy",
+      openai_status: isHealthy,
+      provider: "openai"
+    });
+  } catch (error) {
+    res.status(503).json({
+      status: "unhealthy",
+      openai_status: false,
+      error: error.message,
+      provider: "openai"
+    });
+  }
+});
+
+// OpenAI Chat Completions
+app.post("/api/openai/chat/completions", async (req, res) => {
+  try {
+    const openaiKey = requireOpenAIKey();
+    const isStreaming = req.body?.stream === true;
+
+    // Strip the openai: prefix from model name and remove provider field
+    const { provider, ...cleanBody } = req.body;
+    const requestBody = {
+      ...cleanBody,
+      model: req.body?.model?.replace(/^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 errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`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) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// OpenAI Chat (alternative route)
+app.post("/api/openai/chat", async (req, res) => {
+  // Route to the completions endpoint for compatibility
+  req.url = "/api/openai/chat/completions";
+  return app._router.handle(req, res);
+});
+
+// OpenAI Completions
+app.post("/api/openai/completions", async (req, res) => {
+  try {
+    const openaiKey = requireOpenAIKey();
+    const isStreaming = req.body?.stream === true;
+
+    // Strip the openai: prefix from model name and remove provider field
+    const { provider, ...cleanBody } = req.body;
+    const requestBody = {
+      ...cleanBody,
+      model: req.body?.model?.replace(/^openai:/, "") || "gpt-3.5-turbo-instruct"
+    };
+
+    const response = await fetch("https://api.openai.com/v1/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": \`Bearer \${openaiKey}\`
+      },
+      body: JSON.stringify(requestBody)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`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) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// OpenAI Generate (converts to chat format for conversation starters)
+app.post("/api/openai/generate", async (req, res) => {
+  try {
+    const openaiKey = requireOpenAIKey();
+    const prompt = req.body?.prompt || "";
+    const model = req.body?.model?.replace(/^openai:/, "") || "gpt-4o";
+    const isStreaming = req.body?.stream === true;
+
+    // Convert generate request to chat format
+    const chatBody = {
+      model: 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("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": \`Bearer \${openaiKey}\`
+      },
+      body: JSON.stringify(chatBody)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`OpenAI generate failed: \${response.status}\`,
+        details: errorText
+      });
+    }
+
+    if (isStreaming) {
+      await handleStreamingResponse(response, res);
+    } else {
+      const data = await response.json();
+      // Convert chat response back to generate format
+      const generateResponse = {
+        model: model,
+        created_at: new Date().toISOString(),
+        response: data.choices?.[0]?.message?.content || "",
+        done: true,
+        context: [],
+        total_duration: 0,
+        load_duration: 0,
+        prompt_eval_count: 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.message });
+  }
+});
+
+// OpenAI Models
+app.get("/api/openai/models", async (_req, res) => {
+  try {
+    const openaiKey = requireOpenAIKey();
+
+    const response = await fetch("https://api.openai.com/v1/models", {
+      headers: { "Authorization": \`Bearer \${openaiKey}\` }
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`OpenAI 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.message });
+  }
+});
+
+// ============================================================================
+// OLLAMA ROUTES
+// ============================================================================
+
+// Ollama Health Check
+app.get("/api/ollama/health", async (_req, res) => {
+  try {
+    console.log(\`Ollama health check at: \${OLLAMA_BASE_URL}/api/tags\`);
+    const response = await fetch(\`\${OLLAMA_BASE_URL}/api/tags\`);
+    const isHealthy = response.ok;
+
+    res.json({
+      status: isHealthy ? "healthy" : "unhealthy",
+      ollama_status: isHealthy,
+      provider: "ollama",
+      url: OLLAMA_BASE_URL
+    });
+  } catch (error) {
+    console.log(\`Ollama health check error: \${error.message}\`);
+    res.status(503).json({
+      status: "offline",
+      ollama_status: false,
+      error: error.message,
+      provider: "ollama",
+      url: OLLAMA_BASE_URL
+    });
+  }
+});
+
+// Ollama Chat
+app.post("/api/ollama/chat", async (req, res) => {
+  try {
+    const response = await fetch(\`\${OLLAMA_BASE_URL}/api/chat\`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(req.body)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Ollama chat failed: \${response.status}\`,
+        details: errorText
+      });
+    }
+
+    const isStreaming = req.body?.stream === true;
+    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.message });
+  }
+});
+
+// Ollama Generate
+app.post("/api/ollama/generate", async (req, res) => {
+  try {
+    const response = await fetch(\`\${OLLAMA_BASE_URL}/api/generate\`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(req.body)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Ollama generate failed: \${response.status}\`,
+        details: errorText
+      });
+    }
+
+    const isStreaming = req.body?.stream === true;
+    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.message });
+  }
+});
+
+// Ollama Models
+app.get("/api/ollama/models", async (_req, res) => {
+  try {
+    const response = await fetch(\`\${OLLAMA_BASE_URL}/api/tags\`);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Ollama 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.message });
+  }
+});
+
+// Ollama Embedding
+app.post("/api/ollama/embed", async (req, res) => {
+  try {
+    const response = await fetch(\`\${OLLAMA_BASE_URL}/api/embeddings\`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(req.body)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return res.status(response.status).json({
+        error: \`Ollama embed 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.message });
+  }
+});
+
+// ============================================================================
+// TTS ROUTES (not implemented - placeholder for compatibility)
+// ============================================================================
+
+// TTS Main endpoint
+app.post("/api/tts", async (_req, res) => {
+  res.status(501).json({
+    error: "TTS integration not implemented",
+    message: "Text-to-speech functionality is not available in this quickstart gateway"
+  });
+});
+
+// TTS Stream endpoint
+app.post("/api/tts/stream", async (_req, res) => {
+  res.status(501).json({
+    error: "TTS streaming not implemented", 
+    message: "Text-to-speech streaming functionality is not available in this quickstart gateway"
+  });
+});
+
+// TTS Real-time stream endpoint
+app.post("/api/tts/stream-realtime", async (_req, res) => {
+  res.status(501).json({
+    error: "TTS real-time streaming not implemented",
+    message: "Text-to-speech real-time streaming functionality is not available in this quickstart gateway"
+  });
+});
+
+// TTS Models endpoint - returns empty models
+app.get("/api/tts/models", async (_req, res) => {
+  res.json({
+    models: []
+  });
+});
+
+// TTS Available models endpoint - returns empty models with defaults
+app.get("/api/tts/available-models", async (_req, res) => {
+  res.json({
+    models: [],
+    defaultModel: null,
+    fallbackModel: null
+  });
+});
+
+// ============================================================================
+// MCP (Model Context Protocol) TOOL ROUTES
+// ============================================================================
+
+// MCP Health Check
+app.get("/api/mcp/health", async (_req, res) => {
+  res.json({
+    status: "healthy",
+    timestamp: new Date().toISOString(),
+    totalTools: 0,
+    enabledTools: 0,
+    availableTools: [],
+    message: "MCP tools are not implemented in this quickstart gateway"
+  });
+});
+
+// Get available MCP tools
+app.get("/api/mcp/tools", async (_req, res) => {
+  res.json([]);
+});
+
+// News endpoint - placeholder implementation
+app.get("/api/mcp/news", async (req, res) => {
+  const { topic = "general", count = 10, headlines = false } = req.query;
+  
+  res.status(501).json({
+    error: "News service not implemented",
+    message: "MCP news functionality is not available in this quickstart gateway",
+    suggestion: "Implement this endpoint to connect to a news API service",
+    requestedParams: { topic, count, headlines }
+  });
+});
+
+// Weather endpoint - placeholder implementation  
+app.get("/api/mcp/weather", async (req, res) => {
+  const { zip, latitude, longitude } = req.query;
+  
+  res.status(501).json({
+    error: "Weather service not implemented", 
+    message: "MCP weather functionality is not available in this quickstart gateway",
+    suggestion: "Implement this endpoint to connect to a weather API service",
+    requestedParams: { zip, latitude, longitude }
+  });
+});
+
+// Documentation search endpoint - placeholder implementation
+app.get("/api/mcp/docs", async (req, res) => {
+  const { query, framework, count = 10 } = req.query;
+  
+  if (!query) {
+    return res.status(400).json({
+      error: "Query parameter is required",
+      message: "Please provide a search query"
+    });
+  }
+  
+  res.status(501).json({
+    error: "Documentation search not implemented",
+    message: "MCP docs functionality is not available in this quickstart gateway", 
+    suggestion: "Implement this endpoint to connect to a documentation search service",
+    requestedParams: { query, framework, count }
+  });
+});
+
+// Get supported documentation frameworks
+app.get("/api/mcp/docs/frameworks", async (_req, res) => {
+  res.json({
+    frameworks: [],
+    message: "Documentation frameworks not configured in this quickstart gateway"
+  });
+});
+
+// Sports scores endpoint - placeholder implementation
+app.get("/api/mcp/sports", async (req, res) => {
+  const { league, date } = req.query;
+  
+  res.status(501).json({
+    error: "Sports service not implemented",
+    message: "MCP sports functionality is not available in this quickstart gateway",
+    suggestion: "Implement this endpoint to connect to a sports API service", 
+    requestedParams: { league, date }
+  });
+});
+
+// Get supported sports leagues
+app.get("/api/mcp/sports/leagues", async (_req, res) => {
+  res.json({
+    leagues: [],
+    message: "Sports leagues not configured in this quickstart gateway"
+  });
+});
+
+// Image generation endpoint - placeholder implementation
+app.post("/api/mcp/generate-image", async (req, res) => {
+  const { prompt, size, quality, style } = req.body;
+  
+  if (!prompt) {
+    return res.status(400).json({
+      error: "Prompt is required",
+      message: "Please provide a prompt for image generation"
+    });
+  }
+  
+  res.status(501).json({
+    success: false,
+    error: "Image generation not implemented",
+    message: "MCP image generation functionality is not available in this quickstart gateway",
+    suggestion: "Implement this endpoint to connect to an image generation API service",
+    requestedParams: { prompt, size, quality, style }
+  });
+});
+
+// ============================================================================
+// NOT IMPLEMENTED ROUTES (for graceful degradation)
+// ============================================================================
+
+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"
+  });
+});
+
+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{1F517} Provider-specific routes:");
+  console.log("   \u2022 /api/openai/* - OpenAI endpoints");
+  console.log("   \u2022 /api/ollama/* - Ollama endpoints");
+  console.log("   \u2022 /api/health - Overall health check");
+});
+`;
+  return ensureTrailingNewline(normalizeLineEndings(gatewaySource));
+};
+var buildGitignore = () => ensureTrailingNewline(
+  normalizeLineEndings(
+    `node_modules
+.env
+.vite
+.idea
+.DS_Store
+coverage
+dist
+`
+  )
+);
+var buildNpmrc = () => {
+  const tokenExpr = "${GITHUB_NPM_TOKEN}";
+  const template = `@burtson-labs:registry=https://npm.pkg.github.com/
+//npm.pkg.github.com/:_authToken=__NPM_TOKEN__
+`;
+  return ensureTrailingNewline(
+    normalizeLineEndings(template.replace(/__NPM_TOKEN__/g, tokenExpr))
+  );
+};
+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.
+
+## \u{1F680} Next steps
+- \`npm install\`
+- \`cp .env.example .env\`
+- Fill in \`OPENAI_API_KEY\` (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.
+
+## \u{1F527} Customizing your assistant
+- **Branding & personas**: edit \`public/config.json\` to tweak logos, colors, and starter models.
+- **Provider defaults**: update \`.env\` to switch providers or change the default upstream model IDs.
+- **Gateway routes**: open \`server/gateway.js\` to add auth, logging, or connect additional providers.
+
+## \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
+- Friendly defaults you can evolve into your production stack
+
+Need more? Run \`npx @burtson-labs/bandit-engine create --help\` to explore additional options.
+`
+  )
+);
+
+// src/cli/createQuickstart.ts
+var createQuickstartProject = async (options) => {
+  const resolvedDir = import_node_path2.default.resolve(process.cwd(), options.targetDir);
+  const rawProjectName = options.projectName ?? import_node_path2.default.basename(resolvedDir);
+  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({
+    brandingText: options.brandingText,
+    provider
+  });
+  const brandingText = options.brandingText ?? (typeof promptAnswers.brandingText === "string" && promptAnswers.brandingText.trim().length > 0 ? promptAnswers.brandingText.trim() : `${projectTitle} Assistant`);
+  const logoResolution = {
+    dataUrl: "",
+    fileName: "",
+    fileContent: Buffer.alloc(0),
+    hasTransparentLogo: true,
+    isDefault: true
+  };
+  const gatewayPort = sanitizePort(options.gatewayPort ?? promptAnswers.gatewayPort ?? 5151);
+  const frontendPort = sanitizePort(options.frontendPort ?? promptAnswers.frontendPort ?? 5183);
+  const defaultModelId = sanitizeModelIdentifier(
+    options.defaultModelId ?? inferDefaultModelId(provider)
+  );
+  const fallbackModelId = options.fallbackModelId ? sanitizeModelIdentifier(options.fallbackModelId) : inferFallbackModelId(provider, defaultModelId);
+  const inputs = {
+    targetDir: resolvedDir,
+    projectTitle,
+    packageName,
+    brandingText,
+    provider,
+    defaultModelId,
+    fallbackModelId,
+    gatewayPort,
+    frontendPort,
+    logo: logoResolution
+  };
+  const createdFiles = await writeProject(inputs);
+  return {
+    projectDir: resolvedDir,
+    packageName,
+    brandingText,
+    defaultModelId,
+    fallbackModelId,
+    gatewayPort,
+    frontendPort,
+    createdFiles
+  };
+};
+var normalizePackageName = (input) => {
+  const fallback = "bandit-quickstart";
+  const kebab = toKebabCase(input || fallback);
+  if (!kebab) {
+    return fallback;
+  }
+  return /^[a-z]/.test(kebab) ? kebab : `bandit-${kebab}`;
+};
+var ensureWritableDirectory = async (dir, force) => {
+  const exists = await import_fs_extra.default.pathExists(dir);
+  if (!exists) {
+    await import_fs_extra.default.ensureDir(dir);
+    return;
+  }
+  const entries = await import_fs_extra.default.readdir(dir);
+  if (entries.length > 0 && !force) {
+    throw new Error(
+      `Target directory "${dir}" is not empty. Re-run with --force to overwrite or choose a new folder.`
+    );
+  }
+};
+var normalizeProvider = (value) => {
+  const normalized = (value ?? "openai").toLowerCase();
+  return normalized === "ollama" ? "ollama" : "openai";
+};
+var inferDefaultModelId = (provider) => {
+  return provider === "ollama" ? "ollama:llama3.1" : "openai:gpt-4o-mini";
+};
+var inferFallbackModelId = (provider, defaultId) => {
+  if (provider === "ollama") {
+    return defaultId === "ollama:llama3" ? "ollama:llama2" : "ollama:llama3";
+  }
+  return defaultId === "openai:gpt-4.1-mini" ? "openai:gpt-4o-mini" : "openai:gpt-4.1-mini";
+};
+var sanitizePort = (value) => {
+  const port = Number(value);
+  if (Number.isNaN(port) || port <= 0 || port >= 65535) {
+    return 8080;
+  }
+  return port;
+};
+var promptForMissingData = async (options) => {
+  const questions = [];
+  if (!options.brandingText) {
+    questions.push({
+      type: "text",
+      name: "brandingText",
+      message: "What should we display for the app name? (Press Enter to accept)",
+      initial: "Bandit Quickstart"
+    });
+  }
+  const defaultGatewayPort = options.provider === "ollama" ? 11435 : 8080;
+  const defaultFrontendPort = 5183;
+  questions.push({
+    type: "text",
+    name: "frontendPort",
+    message: "Frontend port (Press Enter to accept)",
+    initial: String(defaultFrontendPort),
+    validate: (value) => {
+      if (typeof value !== "string" || value.trim().length === 0) {
+        return true;
+      }
+      const numericValue = Number(value);
+      return Number.isFinite(numericValue) && numericValue > 0 && numericValue < 65535 ? true : "Enter a port between 1 and 65535";
+    }
+  });
+  questions.push({
+    type: "text",
+    name: "gatewayPort",
+    message: "Gateway port (Press Enter to accept)",
+    initial: String(defaultGatewayPort),
+    validate: (value) => {
+      if (typeof value !== "string" || value.trim().length === 0) {
+        return true;
+      }
+      const numericValue = Number(value);
+      return Number.isFinite(numericValue) && numericValue > 0 && numericValue < 65535 ? true : "Enter a port between 1 and 65535";
+    }
+  });
+  const onCancel = () => {
+    throw new Error("Command cancelled.");
+  };
+  const answers = await (0, import_prompts.default)(questions, { onCancel });
+  const parsedGatewayPort = typeof answers.gatewayPort === "number" ? answers.gatewayPort : typeof answers.gatewayPort === "string" && answers.gatewayPort.trim().length > 0 ? Number(answers.gatewayPort) : defaultGatewayPort;
+  const parsedFrontendPort = typeof answers.frontendPort === "number" ? answers.frontendPort : typeof answers.frontendPort === "string" && answers.frontendPort.trim().length > 0 ? Number(answers.frontendPort) : defaultFrontendPort;
+  return {
+    brandingText: typeof answers.brandingText === "string" ? answers.brandingText : void 0,
+    gatewayPort: Number.isFinite(parsedGatewayPort) ? parsedGatewayPort : defaultGatewayPort,
+    frontendPort: Number.isFinite(parsedFrontendPort) ? parsedFrontendPort : defaultFrontendPort
+  };
+};
+var writeProject = async (inputs) => {
+  const { targetDir } = inputs;
+  const createdFiles = [];
+  const context = {
+    packageName: inputs.packageName,
+    projectTitle: inputs.projectTitle,
+    engineVersion: package_default.version,
+    brandingText: inputs.brandingText,
+    logoBase64: inputs.logo.dataUrl,
+    hasTransparentLogo: inputs.logo.hasTransparentLogo,
+    isDefaultLogo: inputs.logo.isDefault,
+    gatewayPort: inputs.gatewayPort,
+    frontendPort: inputs.frontendPort,
+    defaultProvider: inputs.provider,
+    defaultGatewayUrl: `http://localhost:${inputs.gatewayPort}`,
+    defaultModelId: inputs.defaultModelId,
+    fallbackModelId: inputs.fallbackModelId,
+    gatewayModels: buildGatewayModels(inputs)
+  };
+  const files = {
+    "package.json": buildPackageJson(context),
+    "tsconfig.json": buildTsConfig(),
+    "src/env.d.ts": buildEnvDts(),
+    "vite.config.ts": buildViteConfig(context),
+    "src/main.tsx": buildMainTsx(),
+    "index.html": buildIndexHtml(),
+    "src/App.tsx": buildAppTsx(context),
+    "src/index.css": buildIndexCss(),
+    "src/theme.ts": buildThemeTs(),
+    "public/config.json": buildBrandingConfig(context),
+    "server/gateway.js": buildGatewayServer(context),
+    ".env.example": buildEnvExample(context),
+    ".gitignore": buildGitignore(),
+    ".npmrc": buildNpmrc(),
+    "README.md": buildReadme(context)
+  };
+  if (!inputs.logo.isDefault && inputs.logo.fileName) {
+    files[import_node_path2.default.posix.join("public", inputs.logo.fileName)] = inputs.logo.fileContent;
+  }
+  for (const [relativePath, content] of Object.entries(files)) {
+    const destination = import_node_path2.default.join(targetDir, relativePath);
+    await import_fs_extra.default.ensureDir(import_node_path2.default.dirname(destination));
+    if (Buffer.isBuffer(content)) {
+      await import_fs_extra.default.writeFile(destination, content);
+    } else {
+      await import_fs_extra.default.writeFile(destination, ensureTrailingNewline(content), "utf8");
+    }
+    createdFiles.push(relativePath);
+  }
+  return createdFiles;
+};
+var buildGatewayModels = (inputs) => {
+  const seen = /* @__PURE__ */ new Set();
+  const models = [];
+  const pushModel = (modelId) => {
+    if (!modelId) return;
+    if (seen.has(modelId)) return;
+    seen.add(modelId);
+    const provider = modelId.includes(":") ? modelId.split(":")[0] : inputs.provider;
+    const nameSegment = modelId.includes(":") ? modelId.split(":")[1] : modelId;
+    models.push({
+      id: modelId,
+      name: toTitleCase(nameSegment.replace(/[-_.]/g, " ")),
+      provider
+    });
+  };
+  pushModel(inputs.defaultModelId);
+  pushModel(inputs.fallbackModelId);
+  return models;
+};
+
+// src/cli/index.ts
+var logIntro = () => {
+  console.log("\u{1F977} Bandit CLI \u2014 Burtson Labs \u{1F9EA}");
+};
+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(
+  "--frontend-port <port>",
+  "Frontend dev server port (default: 5183)",
+  (value) => parseInt(value, 10)
+).option("--gateway-port <port>", "Gateway port (default: 8080)", (value) => parseInt(value, 10)).option("-y, --yes", "Skip interactive prompts and accept defaults", false).option("--skip-prompts", "Alias for --yes", false).action(async (directory, cmdOptions) => {
+  try {
+    const targetDir = directory ?? "bandit-quickstart";
+    const projectName = import_node_path3.default.basename(import_node_path3.default.resolve(process.cwd(), targetDir));
+    logIntro();
+    const skipPrompts = Boolean(cmdOptions.skipPrompts ?? cmdOptions.yes);
+    const result = await createQuickstartProject({
+      targetDir,
+      projectName,
+      force: Boolean(cmdOptions.force),
+      brandingText: cmdOptions.brandingText,
+      frontendPort: Number.isFinite(cmdOptions.frontendPort) ? cmdOptions.frontendPort : void 0,
+      gatewayPort: Number.isFinite(cmdOptions.gatewayPort) ? cmdOptions.gatewayPort : void 0,
+      skipPrompts
+    });
+    const relativeDir = import_node_path3.default.relative(process.cwd(), result.projectDir) || ".";
+    console.log("\n\u2705 Quickstart ready!");
+    console.log(`   Location: ${result.projectDir}`);
+    console.log(`   Package:  ${result.packageName}`);
+    console.log(`   App name: ${result.brandingText}`);
+    console.log(`   Frontend: http://localhost:${result.frontendPort}`);
+    console.log(`   Gateway:  http://localhost:${result.gatewayPort}`);
+    console.log("\nNext steps:");
+    console.log(`  cd ${relativeDir}`);
+    console.log("  npm install");
+    console.log("  cp .env.example .env");
+    console.log("  npm run dev");
+    console.log("");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to create Bandit quickstart project.";
+    console.error(`
+\u274C ${message}`);
+    process.exitCode = 1;
+  }
+});
+async function main() {
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map