@tangle-network/starter-foundry 0.5.4 → 0.7.0

package/registry/families/unity-web-proxy/manifest.json

@@ -0,0 +1,175 @@
+{
+  "id": "unity-web-proxy",
+  "description": "Build-host scaffold for Unity WebGL exports. The scaffold can't bundle the Unity editor output, so this family ships what you DO check in: a CI batch-mode build script, a Vite-based dev server to serve the built artifact, an index.html wired to the Unity loader, and a Build/ drop-zone for the editor's output. The Unity project itself lives elsewhere (source Assets/) and writes into Build/ via `Unity -batchmode`.",
+  "tags": [
+    "frontend",
+    "typescript",
+    "unity",
+    "webgl",
+    "game-engine"
+  ],
+  "taxonomy": {
+    "language": "typescript",
+    "runtime": "node",
+    "surface": "frontend"
+  },
+  "defaults": {
+    "projectType": "frontend",
+    "serviceName": "starter-foundry-unity-web",
+    "port": 5173
+  },
+  "files": [
+    {
+      "source": "files/package.json",
+      "target": "package.json"
+    },
+    {
+      "source": "files/tsconfig.json",
+      "target": "tsconfig.json"
+    },
+    {
+      "source": "files/vite.config.ts",
+      "target": "vite.config.ts"
+    },
+    {
+      "source": "files/scripts/build-webgl.sh",
+      "target": "scripts/build-webgl.sh"
+    },
+    {
+      "source": "files/Build/.gitkeep",
+      "target": "Build/.gitkeep"
+    },
+    {
+      "source": "files/README.md",
+      "target": "README.md"
+    },
+    {
+      "source": "files/validate-unity.mjs",
+      "target": "validate-unity.mjs"
+    },
+    {
+      "source": "files/.gitignore",
+      "target": ".gitignore"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "index.html"
+    },
+    {
+      "type": "file-exists",
+      "path": "package.json"
+    },
+    {
+      "type": "file-exists",
+      "path": "scripts/build-webgl.sh"
+    },
+    {
+      "type": "file-exists",
+      "path": "Build/.gitkeep"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-unity.mjs"
+      ],
+      "expect": "unity-web-proxy starter ok"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "pnpm install",
+      "pnpm dev",
+      "bash scripts/build-webgl.sh"
+    ],
+    "entrypoints": [
+      "index.html",
+      "vite.config.ts",
+      "scripts/build-webgl.sh",
+      "Build/"
+    ],
+    "preview": {
+      "path": "/"
+    },
+    "extensionPoints": [
+      "index.html",
+      "scripts/build-webgl.sh"
+    ]
+  },
+  "keywords": [
+    "unity webgl",
+    "unity web build",
+    "unity batch mode",
+    "unity html5",
+    "unity browser game",
+    "unity web export",
+    "unity ci build"
+  ],
+  "scoring": {
+    "boost": {
+      "unity webgl": 5,
+      "unity web build": 5,
+      "unity batch mode": 4,
+      "unity html5": 4
+    }
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "unity webgl",
+      "unity web build",
+      "unity batch mode",
+      "unity html5"
+    ],
+    "tier2": [
+      "unity browser game",
+      "unity web export",
+      "unity ci build",
+      "unity loader"
+    ],
+    "archetypes": [
+      "unity browser game",
+      "unity webgl demo",
+      "unity portfolio piece",
+      "unity jam entry web",
+      "unity playable ad",
+      "unity training sim web",
+      "unity product viewer",
+      "unity interactive tutorial",
+      "unity marketing demo"
+    ]
+  },
+  "buildHints": {
+    "whenToUse": "Unity-authored games or interactive content that must ship as a browser-native WebGL build. This scaffold is the serving + CI harness — the Unity project source (Assets/, ProjectSettings/) lives in a separate repo or sibling directory, and the `Unity -batchmode` CLI writes its output into this repo's `Build/` directory. Pick godot-web or bevy-web if you haven't already committed to Unity.",
+    "firstSteps": [
+      "Put your Unity editor build output in `Build/` — you need `Build.loader.js`, `Build.framework.js`, `Build.wasm`, `Build.data`, and optionally `Build.symbols.json` (filenames depend on the Unity product name in Player Settings).",
+      "Run locally: `pnpm install` then `pnpm dev` — Vite serves on 5173 with the COOP/COEP headers Unity 2021 LTS+ needs for threads + SharedArrayBuffer.",
+      "CI build: `bash scripts/build-webgl.sh` — batch-mode Unity CLI incantation that runs a custom BuildScript and writes into `Build/`. Point `UNITY_PROJECT_PATH` at the Unity project source; `UNITY_VERSION` selects the Unity Hub-installed editor.",
+      "Ship: `pnpm build` runs Vite in production mode (`dist/`). The Build/ artifacts are static; any CDN works. Keep the COOP/COEP headers on the serving host.",
+      "For Unity Cloud Build or GitHub Actions, the same `scripts/build-webgl.sh` runs inside the Unity Docker image (`unityci/editor:ubuntu-<version>-webgl-<patch>`)."
+    ],
+    "gotchas": [
+      "Unity 2021.2+ WebGL builds enable threads by default, which requires the page to be served with `Cross-Origin-Opener-Policy: same-origin` and `Cross-Origin-Embedder-Policy: require-corp`. Without these headers the loader fails with a SharedArrayBuffer error — Vite's server is configured here; make sure production hosting mirrors it.",
+      "Unity's Brotli-compressed output (`.br` files) requires the server to send `Content-Encoding: br`; gzip output needs `Content-Encoding: gzip`. Static hosts often strip this header, giving you a corrupted bundle. Either use Disabled compression in Player Settings or verify headers with `curl -I`.",
+      "The Unity loader filename depends on Player Settings → WebGL → Product Name. `index.html` here uses `Build/Build.loader.js` as a placeholder — rename on both sides after the first export so they match.",
+      "Batch-mode Unity must be activated and licensed (Personal/Pro/Plus) or it exits with code 12 after 30 days of trial. For CI, pre-activate with `-createManualActivationFile` + `-manualLicenseFile`.",
+      "WebGL builds have no multi-threaded GC — long GC pauses show up as freezes in JS profilers. Keep per-frame allocations minimal and profile with Unity's built-in profiler attached to the running WebGL page.",
+      "Output size: the data file (`Build.data`) often exceeds 50 MB even for simple games. Enable compression (Brotli for Cloudflare/Vercel; gzip for sites that can't set `Content-Encoding: br`)."
+    ],
+    "architectureNotes": [
+      "Treat this scaffold as pure infra — the Unity C# source is NOT here. Point `UNITY_PROJECT_PATH` at the Unity project (separate repo or sibling dir) and let `build-webgl.sh` drop output into `Build/`.",
+      "Unity's WebGL loader wants exclusive ownership of the canvas; do not decorate it with external CSS transforms (they're ignored on resize)."
+    ],
+    "placeholders": [
+      {
+        "path": "index.html",
+        "description": "Loads Unity's WebGL bootstrap from ./Build/Build.loader.js and starts the instance via createUnityInstance(). Update the loader URL and the Unity company/product metadata in the script block to match your editor Player Settings on first export."
+      },
+      {
+        "path": "scripts/build-webgl.sh",
+        "description": "Unity CLI batch-mode build script. Replace BuildScript.PerformWebGLBuild with your actual editor C# method (e.g. inside Assets/Editor/Build.cs) once the Unity project exists."
+      }
+    ]
+  }
+}

package/registry/families/vision-first-agent/files/api/README.md

@@ -0,0 +1,92 @@
+# Vision agent backend wiring
+
+The browser scaffold posts a captured JPEG + user prompt to `/api/vision`.
+You implement the endpoint.
+
+## Contract
+
+### `POST /api/vision`
+
+**Request:**
+```json
+{
+  "image": "data:image/jpeg;base64,...",
+  "prompt": "What am I looking at?"
+}
+```
+
+**Response:**
+```json
+{
+  "answer": "A laptop on a wooden desk with a half-full coffee mug to the right.",
+  "boxes": [
+    { "label": "laptop", "x": 0.18, "y": 0.32, "w": 0.55, "h": 0.48 },
+    { "label": "mug",    "x": 0.76, "y": 0.45, "w": 0.15, "h": 0.20 }
+  ]
+}
+```
+
+The `boxes` array is optional — when present, the frontend draws them over
+the captured frame. Coordinates are normalized 0..1 so they survive any
+display-size rescaling. Most current multimodal models won't return boxes
+reliably — omit the field and the frontend only renders `answer`.
+
+## Providers
+
+- **Anthropic Claude** (Sonnet 4.5+ has vision): `messages.create` with an
+  `image` content block. Recommended — best captioning quality and the
+  most reliable "please return boxes as JSON" follower.
+- **OpenAI GPT-4o / GPT-4.1**: `chat.completions.create` with
+  `{ type: 'image_url', image_url: { url: dataUrl } }`.
+- **Google Gemini 2.x**: Files API or inline `inline_data`.
+- **Router:** Route through `router.tangle.tools` to failover across
+  providers without re-wiring the client.
+
+## Minimum viable backend (Node)
+
+```ts
+import express from 'express'
+import Anthropic from '@anthropic-ai/sdk'
+
+const app = express()
+app.use(express.json({ limit: '10mb' }))
+
+const client = new Anthropic({
+  baseURL: 'https://router.tangle.tools/anthropic',
+  apiKey: process.env.TANGLE_ROUTER_USER_KEY,
+})
+
+app.post('/api/vision', async (req, res) => {
+  const { image, prompt } = req.body as { image: string; prompt: string }
+  // image is a data URL; strip the prefix to get raw base64
+  const base64 = image.replace(/^data:image\/\w+;base64,/, '')
+
+  const result = await client.messages.create({
+    model: 'claude-sonnet-4-5',
+    max_tokens: 1024,
+    messages: [
+      {
+        role: 'user',
+        content: [
+          { type: 'image', source: { type: 'base64', media_type: 'image/jpeg', data: base64 } },
+          { type: 'text', text: prompt },
+        ],
+      },
+    ],
+  })
+
+  const text = result.content[0]?.type === 'text' ? result.content[0].text : ''
+  res.json({ answer: text })
+})
+
+app.listen(8787)
+```
+
+## Prompt tips
+
+- Ask for "a short description (1-2 sentences)" — vision models default to
+  long walls of text.
+- For OCR: "Transcribe only the text visible in this image. Output exactly
+  what appears, no commentary."
+- For boxes: most models need JSON-mode enforcement. Tool use is the
+  reliable path; pure "return JSON" prompts hallucinate.

package/registry/families/vision-first-agent/files/index.html

@@ -0,0 +1,67 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <title>{{headline}}</title>
+    <style>
+      :root { color-scheme: dark; }
+      body {
+        font-family: system-ui, -apple-system, sans-serif;
+        margin: 0;
+        min-height: 100vh;
+        background: #0a0a0a;
+        color: #f2f2f2;
+        display: grid;
+        place-items: center;
+      }
+      main { width: min(720px, 100%); padding: 1.25rem; }
+      h1 { margin: 0 0 0.25rem 0; font-size: 1.3rem; }
+      p.sub { margin: 0 0 1.25rem 0; color: #888; }
+      .stage {
+        position: relative;
+        aspect-ratio: 4/3;
+        background: #111;
+        border-radius: 12px;
+        overflow: hidden;
+      }
+      video, canvas {
+        width: 100%; height: 100%; object-fit: cover;
+        position: absolute; inset: 0;
+      }
+      canvas#overlay { pointer-events: none; }
+      .row { display: flex; gap: 0.5rem; margin-top: 1rem; }
+      input[type=text] {
+        flex: 1; padding: 0.75rem; font-size: 1rem;
+        background: #111; color: #f2f2f2; border: 1px solid #333; border-radius: 8px;
+      }
+      button {
+        padding: 0.75rem 1.25rem; font-size: 1rem; border: 0; border-radius: 8px;
+        background: #357; color: white; cursor: pointer;
+      }
+      button:disabled { opacity: 0.5; cursor: wait; }
+      pre#answer {
+        margin-top: 1rem; padding: 1rem; background: #111; border: 1px solid #222;
+        border-radius: 8px; min-height: 4rem; white-space: pre-wrap; font-size: 0.9rem;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>{{headline}}</h1>
+      <p class="sub">{{subheadline}}</p>
+      <div class="stage">
+        <video id="cam" autoplay playsinline muted></video>
+        <canvas id="overlay"></canvas>
+      </div>
+      <div class="row">
+        <input id="q" type="text" placeholder="What am I looking at?" value="What am I looking at?" />
+        <button id="ask">Capture + ask</button>
+        <button id="flip" title="Switch camera">Flip</button>
+      </div>
+      <pre id="answer">Aim the camera. Type a question. Press Capture.</pre>
+      <canvas id="work" hidden></canvas>
+    </main>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/registry/families/vision-first-agent/files/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "{{packageName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "validate": "node validate-vision.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "typescript": "^5.9.0",
+    "vite": "^6.4.2"
+  },
+  "overrides": {
+    "vite": "^6.4.2"
+  },
+  "pnpm": {
+    "overrides": {
+      "vite": "^6.4.2"
+    }
+  }
+}

package/registry/families/vision-first-agent/files/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"]
+  },
+  "include": ["src/**/*.ts", "vite.config.ts"]
+}

package/registry/families/vision-first-agent/files/validate-vision.mjs

@@ -0,0 +1,48 @@
+// Structural validator for vision-first-agent. Does NOT launch a browser
+// or open the camera — just cross-checks that the scaffold wiring is coherent.
+
+import fs from "node:fs/promises";
+import { stripTypeScriptTypes } from "node:module";
+
+const [pkgSource, indexHtml, mainTs, viteConfig] = await Promise.all([
+  fs.readFile("package.json", "utf8"),
+  fs.readFile("index.html", "utf8"),
+  fs.readFile("src/main.ts", "utf8"),
+  fs.readFile("vite.config.ts", "utf8"),
+]);
+
+const pkg = JSON.parse(pkgSource);
+if (pkg.name !== "{{packageName}}") {
+  throw new Error(`package.json name should be "{{packageName}}", got "${pkg.name}"`);
+}
+
+if (!indexHtml.includes('id="cam"')) {
+  throw new Error("index.html missing <video id=\"cam\"> — camera surface contract");
+}
+if (!indexHtml.includes('id="overlay"')) {
+  throw new Error("index.html missing <canvas id=\"overlay\"> — box-rendering surface");
+}
+if (!indexHtml.includes('id="ask"')) {
+  throw new Error("index.html missing #ask button — capture trigger");
+}
+
+if (!mainTs.includes("getUserMedia")) {
+  throw new Error("src/main.ts must call navigator.mediaDevices.getUserMedia for camera access");
+}
+if (!mainTs.includes("facingMode")) {
+  throw new Error("src/main.ts must declare facingMode — mobile rear/front camera selection");
+}
+if (!mainTs.includes("/api/vision")) {
+  throw new Error("src/main.ts must POST to /api/vision — the wiring contract");
+}
+if (!mainTs.includes("toDataURL") && !mainTs.includes("toBlob")) {
+  throw new Error("src/main.ts must serialize the canvas frame via toDataURL or toBlob");
+}
+
+if (!viteConfig.includes("/api")) {
+  throw new Error("vite.config.ts must proxy /api to the backend during dev");
+}
+
+stripTypeScriptTypes(mainTs);
+
+console.log("vision-first-agent starter ok");

package/registry/families/vision-first-agent/files/vite.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  server: {
+    port: {{port}},
+    proxy: {
+      '/api': {
+        target: 'http://localhost:8787',
+        changeOrigin: true,
+      },
+    },
+  },
+})

package/registry/families/vision-first-agent/manifest.json

@@ -0,0 +1,142 @@
+{
+  "id": "vision-first-agent",
+  "description": "Browser camera agent — getUserMedia streams webcam to a <video>, a canvas grabs a JPEG on trigger, POSTs base64 + prompt to /api/vision, renders the multimodal LLM response as text and as an overlay on the captured frame.",
+  "tags": [
+    "vision",
+    "camera",
+    "agent",
+    "browser",
+    "frontend",
+    "typescript",
+    "vite"
+  ],
+  "taxonomy": {
+    "language": "typescript",
+    "runtime": "browser",
+    "surface": "frontend"
+  },
+  "defaults": {
+    "projectType": "frontend",
+    "serviceName": "starter-foundry-vision-agent",
+    "port": 4181,
+    "headline": "Point the camera, ask a question",
+    "subheadline": "Capture a frame, send it to a multimodal LLM, see the answer drawn on top of the image."
+  },
+  "files": [
+    {
+      "source": "files/package.json",
+      "target": "package.json"
+    },
+    {
+      "source": "files/tsconfig.json",
+      "target": "tsconfig.json"
+    },
+    {
+      "source": "files/vite.config.ts",
+      "target": "vite.config.ts"
+    },
+    {
+      "source": "files/index.html",
+      "target": "index.html"
+    },
+    {
+      "source": "files/validate-vision.mjs",
+      "target": "validate-vision.mjs"
+    },
+    {
+      "source": "files/api/README.md",
+      "target": "api/README.md"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "src/main.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "index.html"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-vision.mjs"
+      ],
+      "expect": "vision-first-agent starter ok"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "pnpm install",
+      "pnpm run dev"
+    ],
+    "entrypoints": [
+      "index.html",
+      "src/main.ts",
+      "api/README.md",
+      "vite.config.ts"
+    ],
+    "preview": {
+      "path": "/"
+    },
+    "extensionPoints": [
+      "src/main.ts",
+      "api/"
+    ]
+  },
+  "keywords": [
+    "vision agent",
+    "vision first agent",
+    "camera agent",
+    "browser camera agent",
+    "visual qa",
+    "multimodal vision",
+    "webcam llm",
+    "frame capture agent",
+    "gpt-4v client",
+    "vision llm browser"
+  ],
+  "scoring": {
+    "boost": {
+      "vision agent": 4,
+      "camera agent": 3,
+      "visual qa": 3
+    }
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "vision first",
+      "vision first agent",
+      "camera agent",
+      "visual qa",
+      "browser camera agent"
+    ],
+    "tier2": [
+      "webcam llm",
+      "frame capture agent",
+      "gpt-4v client",
+      "vision llm browser",
+      "multimodal vision"
+    ],
+    "archetypes": [
+      "point and identify app",
+      "webcam ocr",
+      "live camera describe",
+      "visual inspection agent",
+      "snap a photo ask an llm",
+      "camera-based search",
+      "barcode camera llm"
+    ]
+  },
+  "buildHints": {
+    "gotchas": [
+      "getUserMedia for camera requires HTTPS outside localhost. Behind plain HTTP on any real hostname the call fails with NotAllowedError before the permission prompt ever appears.",
+      "iOS Safari auto-rotates camera frames based on device orientation but <canvas>.drawImage does NOT. On mobile portrait the captured JPEG is sideways — you must read `(video as any).videoWidth/videoHeight` after `loadedmetadata` fires, and apply orientation if building a production app.",
+      "canvas.toDataURL('image/jpeg', quality) is synchronous and blocks the main thread on large canvases. For >1080p frames, switch to canvas.toBlob() with a callback — it's off-thread and ~3× faster.",
+      "Base64 JPEGs are ~1.33× their binary size. For high-res frames (>500KB), send as multipart/form-data or use toBlob() + binary fetch to cut the payload.",
+      "`facingMode: 'environment'` (rear camera) is a hint, not a guarantee. Desktop browsers ignore it, and some Android devices return a front camera anyway. Always offer a flip-camera button that re-calls getUserMedia with `{ video: { deviceId } }`.",
+      "The MediaStream keeps the camera LED on until every track.stop() is called. Don't just pause the <video>; call `stream.getTracks().forEach(t => t.stop())` when the user is done."
+    ]
+  }
+}

package/registry/families/vllm-server/files/README-serving.md

@@ -0,0 +1,60 @@
+# vLLM serving — operator guide
+
+This scaffold is a production-shape LLM inference server. It exposes
+OpenAI-compatible endpoints (`/v1/chat/completions`, `/v1/completions`,
+`/v1/models`) so any OpenAI-SDK client can point at it and work unchanged.
+
+## First-run
+
+```bash
+pip install -r requirements.txt
+export VLLM_API_KEY=$(openssl rand -hex 16)
+python -m src.server
+```
+
+Server boots, pulls the model from HuggingFace on first request, warms up
+PagedAttention caches, then serves. Call it:
+
+```bash
+curl http://localhost:{{port}}/v1/chat/completions \
+  -H "Authorization: Bearer $VLLM_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "{{modelId}}",
+    "messages": [{"role": "user", "content": "explain pagedattention"}]
+  }'
+```
+
+## Swapping models
+
+Edit `config.yaml`'s `model.id` to any HuggingFace model id supported by
+vLLM. First request after a change re-pulls + re-warms. For large models:
+set `tensor_parallel_size` to your GPU count, enable `quantization: awq`
+(or `fp8` on H100+).
+
+## Production notes
+
+- **Memory**: PagedAttention spills KV cache to host memory above GPU cap.
+  Set `gpu_memory_utilization` in config.yaml if the default (0.9) conflicts
+  with other tenants on the same box.
+- **Batching**: continuous batching is on by default. Higher concurrency =
+  better throughput; the server handles its own queue.
+- **Auth**: set `VLLM_API_KEY`. Unauthenticated requests return 401. For
+  multi-tenant, put an auth gateway (Clerk, better-auth) in front —
+  `slot: auth` is available on this family.
+- **Metrics**: Prometheus scrape at `/metrics`. Latency histograms,
+  tokens/sec, active requests, cache hit rate.
+- **GPU sizing**: Llama-3-8B in bf16 needs ~16GB. Quantize to AWQ for 8GB.
+  70B needs tensor-parallel across 2xA100-80GB or 4xA100-40GB.
+
+## Swapping inference engine
+
+vLLM is one of several modern serving engines. Drop-in alternatives with
+similar OpenAI-compatible surfaces:
+
+- **sglang** — newer, better for structured generation (JSON mode, tool calls)
+- **ollama** — local-first, handles quantized GGUF models out-of-the-box
+- **TGI (text-generation-inference)** — HuggingFace's own server
+
+All share the OpenAI-compatible endpoint shape, so migration is a
+requirements.txt + server.py change, not a rewrite.

package/registry/families/vllm-server/files/config.yaml

@@ -0,0 +1,26 @@
+# vLLM serving config. Edit to switch model + runtime parameters.
+# See https://docs.vllm.ai/en/latest/models/supported_models.html for model ids.
+
+model:
+  id: "{{modelId}}"
+  max_model_len: {{maxModelLen}}
+  # Enable quantization for models larger than single-GPU VRAM. Options:
+  # awq (weight-only), gptq (weight-only), fp8 (weight + activation).
+  quantization: null
+  # tensor_parallel_size > 1 sharded across GPUs. Only relevant for multi-GPU hosts.
+  tensor_parallel_size: 1
+
+server:
+  host: "0.0.0.0"
+  port: {{port}}
+  # Enable OpenAI-compatible chat + completions endpoints.
+  enable_openai_api: true
+  # API key required to call /v1/* endpoints. Set via VLLM_API_KEY env var.
+  api_key_env: "VLLM_API_KEY"
+
+# Per-request defaults. Override per-call via the OpenAI payload.
+generation_defaults:
+  max_tokens: 512
+  temperature: 0.7
+  top_p: 0.95
+  top_k: 50

package/registry/families/vllm-server/files/requirements.txt

@@ -0,0 +1,6 @@
+vllm>=0.6.0
+fastapi>=0.115.0
+uvicorn[standard]>=0.32.0
+pydantic>=2.9.0
+pyyaml>=6.0.2
+httpx>=0.27.0