groundwork-method 0.0.1 → 0.10.0

package/src/engineer-skills/groundwork-python-engineer/references/resilience.md

@@ -0,0 +1,126 @@
+# Resilience
+
+## Timeouts
+
+Set explicit timeouts on every outbound HTTP call:
+
+```python
+import httpx
+
+client = httpx.AsyncClient(
+    timeout=httpx.Timeout(
+        connect=5.0,   # TCP connection
+        read=30.0,     # Full response body
+        write=10.0,    # Request body
+        pool=5.0,      # Connection from pool
+    )
+)
+```
+
+Own the timeout at the provider level. The `read` timeout is critical for ML/API providers — a streaming response that hangs mid-way waits indefinitely without it.
+
+## Retries
+
+Use `tenacity` for retry logic:
+
+```python
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential_jitter,
+)
+
+@retry(
+    retry=retry_if_exception_type(TransientError),
+    wait=wait_exponential_jitter(initial=1, max=30),
+    stop=stop_after_attempt(3),
+)
+async def _call_with_retry(self, payload: dict) -> dict:
+    return await self._client.post(payload)
+```
+
+**Jitter is not optional.** Backoff without jitter causes thundering herd.
+
+**Only retry transient errors.** A `400` is permanent — retrying wastes budget. Map errors to domain types before retrying.
+
+## Circuit Breakers
+
+Prevent cascading failure from a down dependency:
+
+```python
+from circuitbreaker import circuit
+
+@circuit(
+    failure_threshold=5,
+    recovery_timeout=30,
+    expected_exception=TransientError,
+)
+async def complete(self, prompt: str) -> str:
+    return await self._client.complete(prompt)
+```
+
+**Set `expected_exception` explicitly.** A breaker that trips on all exceptions produces false opens.
+
+## Graceful Shutdown
+
+FastAPI + Uvicorn handle `SIGTERM` correctly when `lifespan` is used:
+
+1. `SIGTERM` received
+2. Stop accepting new connections
+3. In-flight requests and `BackgroundTasks` complete
+4. `lifespan` cleanup runs
+5. Process exits
+
+Keep the shutdown path fast:
+
+```python
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    resources = await initialise_resources()
+    yield
+    await asyncio.wait_for(resources.close(), timeout=4.0)
+```
+
+## Health Probes
+
+**`/healthz` (liveness):** Returns `200` unconditionally. No external dependency checks.
+
+**`/readyz` (readiness):** Returns `200` only after startup completes. Returns `503` during startup and shutdown.
+
+```python
+@router.get("/healthz")
+async def liveness() -> dict:
+    return {"status": "ok"}
+
+@router.get("/readyz")
+async def readiness(state: AppState = Depends(get_app_state)) -> dict:
+    if not state.ready:
+        raise HTTPException(status_code=503, detail="not ready")
+    return {"status": "ready"}
+```
+
+## Graceful Degradation
+
+Return partial results rather than hard errors when non-critical steps fail:
+
+```python
+async def process_with_enrichment(self, input_uri: str) -> Result:
+    base = await self.processor.process(input_uri)
+    try:
+        enrichment = await self.enricher.enrich(base)
+        return base.with_enrichment(enrichment)
+    except EnrichmentUnavailableError:
+        logger.warning("enrichment.unavailable", item_id=base.id)
+        return base
+```
+
+Log every degraded response with structured context. Silent degradation is invisible in production.
+
+## Anti-Patterns
+
+- **No timeout on provider calls.** Hung connections hold indefinitely.
+- **Retrying non-transient errors.** A `400` never succeeds on retry.
+- **Circuit breaker on all exceptions.** False opens from caller errors.
+- **Long-running lifespan shutdown.** Force-killed by orchestrator.
+- **Silent degradation.** Partial results without structured logs.

package/src/engineer-skills/groundwork-python-engineer/references/testing.md

@@ -0,0 +1,177 @@
+# Testing
+
+## The Model: Honeycomb, Not Pyramid
+
+Testcontainers spins up real Postgres/Pub/Sub in seconds. The confidence it provides is categorically different from any mock. Mock-heavy suites pass while production breaks.
+
+**Service tests are the default.** Unit tests are reserved for genuinely complex logic. System tests are minimal.
+
+---
+
+## Tier 1 — Service Tests (Default)
+
+Drive the FastAPI app through HTTP using `httpx.AsyncClient` with `ASGITransport`. Infrastructure runs in containers. Non-containerisable providers (LLM APIs) are replaced at the FastAPI `dependency_overrides` boundary.
+
+### Fixture Setup — App + Async Client
+
+```python
+import pytest
+import httpx
+
+@pytest.fixture(scope="session")
+def app():
+    return create_app()
+
+@pytest.fixture
+async def client(app):
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app),
+        base_url="http://test",
+    ) as c:
+        yield c
+```
+
+### Fixture Setup — Containerised Infrastructure
+
+```python
+from testcontainers.postgres import PostgresContainer
+
+@pytest.fixture(scope="session")
+def postgres():
+    with PostgresContainer("postgres:16-alpine") as container:
+        yield container
+```
+
+Scope containers at `session`. Reset state via transactions or truncation between tests.
+
+### Replacing Non-Containerisable Providers
+
+Replace at the FastAPI boundary, not by patching internals:
+
+```python
+from unittest.mock import AsyncMock
+
+@pytest.fixture
+def fake_processor():
+    proc = AsyncMock()
+    proc.process.return_value = DomainResult(...)
+    return proc
+
+async def test_endpoint_returns_result(client, app, fake_processor):
+    app.dependency_overrides[get_processor] = lambda: fake_processor
+    response = await client.post("/process", json={"input": "test"})
+    assert response.status_code == 200
+```
+
+Route handler, service, and validation all run for real. Only the external API call is substituted.
+
+### Live Provider Tests
+
+Marked `@pytest.mark.live` and selected explicitly with pytest's `-m` flag (excluded from normal runs with `-m "not live"`):
+
+```python
+@pytest.mark.live
+async def test_adapter_against_real_api(processor, fixture_data):
+    result = await processor.process(fixture_data)
+    assert result.confidence > 0
+```
+
+---
+
+## Tier 2 — Unit Tests (Reserved)
+
+Appropriate when logic is genuinely complex, has many branches, operates on pure data, and is painful to exercise through HTTP.
+
+**What earns a unit test:**
+- Domain model immutability, field validation, business rules
+- Complex transformations (resampling, merging, normalisation)
+- Pure algorithms (confidence thresholding, chunking strategies)
+
+**What does NOT earn a unit test:**
+- Service methods that orchestrate adapter calls
+- Endpoint handlers that validate and delegate
+- Adapters that translate SDK responses
+
+```python
+class TestDomainModel:
+    def test_rejects_invalid_confidence(self):
+        with pytest.raises(ValidationError):
+            Segment(text="hello", confidence=1.5, start=0.0, end=1.0)
+
+    def test_is_immutable(self):
+        segment = Segment(text="hello", confidence=0.9, start=0.0, end=1.0)
+        with pytest.raises(ValidationError):
+            segment.text = "goodbye"
+```
+
+---
+
+## Tier 3 — System Tests (Minimal)
+
+**Bootstrap test** — verifies the DI container initialises:
+
+```python
+def test_application_starts():
+    app = create_app()
+    assert app is not None
+```
+
+**Golden path test** — one per critical journey, against the full live stack.
+
+---
+
+## Async Configuration
+
+```toml
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+```
+
+Write `async def` tests directly. No `@pytest.mark.asyncio` needed.
+
+## Test Isolation
+
+- **Transaction rollback** per test, or **truncation fixture**.
+- Always reset `dependency_overrides` after each test:
+
+```python
+@pytest.fixture(autouse=True)
+def reset_overrides(app):
+    yield
+    app.dependency_overrides.clear()
+```
+
+## Naming
+
+```python
+# Good
+async def test_process_returns_422_when_input_missing(client): ...
+# Bad
+async def test_process_success(client): ...
+```
+
+## Running Tests
+
+```bash
+uv run pytest tests/unit                        # No infrastructure
+uv run pytest tests/integration -m "not live"   # Requires Docker; skips live APIs
+uv run pytest tests/integration -m live         # Live API tests — requires real keys
+uv run pytest tests/system                      # Bootstrap + golden path
+```
+
+## Anti-Patterns
+
+- **Mocking the interior.** Test what comes out, not which methods were called.
+- **Testing delegation.** `assert adapter.called_once_with(...)` tests the mock, not the code.
+- **Fixture factories that mirror domain.** Construct only what the test needs.
+- **`scope="session"` on mutable state.** Containers: safe. Application state: not.
+- **Skipping the async client.** `TestClient` hides async behaviour. Use `httpx.AsyncClient`.
+
+## Bet Slice Rollout — the permanent tests a slice owes
+
+When a bet slice's progress tests go green, the slice rolls out permanent coverage before it closes (bet workflow, Delivery step 5). The bet-progress tests prove the capability once and are archived; these stay.
+
+- **Service perimeter test (always).** One test per capability the slice delivered, through `httpx.AsyncClient` against the real app with a real database — the coverage that survives refactors.
+- **Unit tests (when logic earned them).** Pure-function tests for branching business logic the slice introduced — validation rules, transformations, state machines. Plumbing does not earn unit tests; the perimeter test already covers it.
+- **Property-based tests (when invariants exist).** A slice that introduced an invariant — round-trip serialization, idempotent consumers, order-independent merges — pins it with Hypothesis, because example-based tests sample invariants instead of stating them.
+- **Contract conformance (when the slice changed an API).** FastAPI's served `/openapi.json` must match the promoted spec in `docs/architecture/api/<service>/openapi.yaml`; the generated system suite checks this — the slice's job is to keep the spec promotion current.

package/src/engineer-skills/groundwork-python-engineer/sync-anchor.md

@@ -0,0 +1,13 @@
+# Sync Anchor
+
+This file pins the principle files this skill embeds. When any listed file
+changes, this skill must be reviewed in the same commit. CI verifies the
+hashes match.
+
+| Principle file | SHA-256 | Last reviewed |
+|---|---|---|
+| src/generators/python-microservice/docs/principles/stack/python/async.md | 6fdd399fb3052381020ff6e792a724d72bdabe674817794093853cbf24fa9f97 | 2026-05-26 |
+| src/generators/python-microservice/docs/principles/stack/python/resilience.md | d5a7b8f089acdb71d64c1bd4fc9ce80e6947504b01b0ace695ac5ee66554a1b1 | 2026-06-19 |
+| src/generators/python-microservice/docs/principles/stack/python/testing.md | b596a4281825349c627dca17e671052ef64a371ff66c50b66d11ceab5ee7b5f2 | 2026-06-19 |
+| src/generators/python-microservice/docs/principles/stack/python/documentation.md | ac58228ba22435bf9bad2ea5bf924bdf9e3674e9967515d5c82aaf3b7825214d | 2026-05-26 |
+| src/generators/python-microservice/docs/principles/stack/python/mcp.md | 1e6deab0b45c7271e0038e9b3d51bc30cb2917488f608e847d566739ac6caeba | 2026-06-19 |

package/src/generators/add-capability/generator.ts

@@ -0,0 +1,70 @@
+import { formatFiles, Tree } from '@nx/devkit';
+import { recordGeneratorProvenance } from '../shared/provenance';
+import { applyCapability, loadCapability } from '../shared/capabilities';
+
+export interface AddCapabilityGeneratorSchema {
+  service: string;
+  capability: string;
+  provider?: string;
+  stack?: string;
+}
+
+/** Locate the service root in the tree. Accepts a bare name (resolved under
+ *  services/) or an explicit path. */
+function resolveServiceRoot(tree: Tree, service: string): string {
+  const candidates = service.includes('/') ? [service] : [`services/${service}`, service];
+  for (const c of candidates) {
+    if (tree.exists(`${c}/pyproject.toml`) || tree.exists(`${c}/go.mod`) || tree.exists(`${c}/package.json`)) {
+      return c;
+    }
+  }
+  throw new Error(
+    `Could not find service "${service}" (looked for ${candidates.join(', ')} with a pyproject.toml / go.mod / package.json).`,
+  );
+}
+
+/** Infer the stack from the marker file present in the service root. */
+function detectStack(tree: Tree, serviceRoot: string): string {
+  if (tree.exists(`${serviceRoot}/pyproject.toml`)) return 'python';
+  if (tree.exists(`${serviceRoot}/go.mod`)) return 'go';
+  if (tree.exists(`${serviceRoot}/package.json`)) return 'typescript';
+  throw new Error(`Could not detect the stack for ${serviceRoot}.`);
+}
+
+export default async function (tree: Tree, options: AddCapabilityGeneratorSchema) {
+  const capability = options.capability || 'llm';
+  const cap = loadCapability(capability);
+  const provider = options.provider || cap.default;
+  const serviceRoot = resolveServiceRoot(tree, options.service);
+  const stack = options.stack || detectStack(tree, serviceRoot);
+
+  const result = applyCapability(tree, { capability, provider, stack, serviceRoot });
+
+  await formatFiles(tree);
+  recordGeneratorProvenance(tree, 'add-capability', options as unknown as Record<string, unknown>);
+
+  // Guidance — the injector writes the port, adapter, contract test, deps and
+  // env, but composition-root wiring is service-specific and a compose/runner
+  // footprint is workspace-level, so we surface what the engineer must finish.
+  console.log(`\nAdded capability "${capability}" (provider: ${provider}, footprint: ${result.footprint}) to ${serviceRoot}`);
+  console.log(`  port:          ${result.files.port}`);
+  console.log(`  adapter:       ${result.files.adapter}`);
+  console.log(`  contract test: ${result.files.contractTest}`);
+  if (result.wiring) console.log(`  wiring:        ${result.wiring}`);
+  if (provider === 'none') {
+    console.log(`  bet:           the contract test is strict-xfail — implement the adapter to cash it.`);
+  }
+  if (result.footprint === 'compose-service') {
+    console.log(
+      result.materialized
+        ? `  footprint:     injected its container into docker-compose.yml — run \`./dev start\` to boot it.`
+        : `  footprint:     needs a docker-compose service, but no docker-compose.yml was found — run workspace-dev-cli first.`,
+    );
+  } else if (result.footprint === 'runner') {
+    console.log(
+      result.materialized
+        ? `  footprint:     registered as a native runner in .dev/dev.config.json — \`./dev start\` will launch it.`
+        : `  footprint:     runs as a process, but no .dev/dev.config.json was found — run workspace-dev-cli first.`,
+    );
+  }
+}

package/src/generators/add-capability/schema.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "id": "add-capability",
+  "title": "Add Capability",
+  "description": "Add a capability interface + a chosen provider implementation (or a bare `none` interface) to an existing service. The footprint — env / compose-service / runner / none — follows from the provider.",
+  "type": "object",
+  "properties": {
+    "service": {
+      "type": "string",
+      "description": "The service to add the capability to (directory name under services/, or a path to the service root).",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "Which service should the capability be added to?"
+    },
+    "capability": {
+      "type": "string",
+      "default": "llm",
+      "description": "The capability to add (must exist in the capability registry).",
+      "x-prompt": "Which capability do you want to add?"
+    },
+    "provider": {
+      "type": "string",
+      "description": "The provider that satisfies the capability. Defaults to the capability's default provider. Use `none` for a bare interface (interface + stub + red contract test, to be built as a bet)."
+    },
+    "stack": {
+      "type": "string",
+      "description": "Language stack of the target service. Auto-detected from the service when omitted (e.g. pyproject.toml -> python)."
+    }
+  },
+  "required": ["service"]
+}

package/src/generators/capabilities/llm/capability.json

@@ -0,0 +1,28 @@
+{
+  "id": "llm",
+  "title": "LLM inference",
+  "description": "Text generation via a large language model. The interface is fixed; the provider (and therefore the operational footprint) is a scaffold-time choice.",
+  "default": "anthropic",
+  "providers": ["anthropic", "openai", "local", "ollama", "localai", "none"],
+  "stacks": {
+    "python": {
+      "port": "src/__packageName__/core/llm.py",
+      "portSymbol": "TextGenerator",
+      "adapter": "src/__packageName__/adapters/llm.py",
+      "adapterSymbol": "LLMClient",
+      "contractTest": "tests/contracts/test_llm.py",
+      "envFile": ".env.example",
+      "wiring": "Provide LLMClient() to your composition root (e.g. dependencies.py get_text_generator) typed as the TextGenerator protocol from core.llm, and call generate_text() from your service."
+    },
+    "go": {
+      "port": "internal/core/service/llm.go",
+      "portSymbol": "TextGenerator",
+      "adapter": "internal/llm/llm.go",
+      "adapterSymbol": "Client",
+      "contractTest": "internal/llm/llm_test.go",
+      "envFile": ".env",
+      "module": true,
+      "wiring": "Construct llm.NewClient() in cmd/api/main.go and pass it (typed as the service.TextGenerator interface) into your service. Run `go mod tidy` if a provider added a dependency."
+    }
+  }
+}

package/src/generators/capabilities/llm/providers/anthropic/footprint.json

@@ -0,0 +1,13 @@
+{
+  "kind": "env",
+  "summary": "Anthropic Claude over HTTPS. API key in env; no infrastructure.",
+  "env": [
+    { "name": "LLM_API_KEY", "required": true, "default": "" },
+    { "name": "LLM_BASE_URL", "required": false, "default": "" },
+    { "name": "LLM_MODEL", "required": false, "default": "claude-sonnet-4-6" }
+  ],
+  "stacks": {
+    "python": { "dependencies": ["anthropic>=0.40.0"] },
+    "go": { "dependencies": [] }
+  }
+}

package/src/generators/capabilities/llm/providers/anthropic/stacks/go/internal/llm/llm.go.template

@@ -0,0 +1,102 @@
+package llm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"time"
+
+	"<%= moduleName %>/internal/core/service"
+)
+
+// Ensure Client implements the service.TextGenerator interface.
+var _ service.TextGenerator = (*Client)(nil)
+
+const anthropicVersion = "2023-06-01"
+
+// Client calls the Anthropic Messages API over HTTPS. It is a minimal
+// net/http adapter (no SDK dependency) — a transparent starting point you can
+// extend (streaming, tool use, prompt caching) or swap for the official SDK
+// behind this same interface. Reads LLM_API_KEY / LLM_BASE_URL / LLM_MODEL from env.
+type Client struct {
+	apiKey  string
+	baseURL string
+	model   string
+	http    *http.Client
+}
+
+func NewClient() *Client {
+	base := os.Getenv("LLM_BASE_URL")
+	if base == "" {
+		base = "https://api.anthropic.com"
+	}
+	model := os.Getenv("LLM_MODEL")
+	if model == "" {
+		model = "claude-sonnet-4-6"
+	}
+	return &Client{
+		apiKey:  os.Getenv("LLM_API_KEY"),
+		baseURL: base,
+		model:   model,
+		http:    &http.Client{Timeout: 60 * time.Second},
+	}
+}
+
+func (a *Client) GenerateText(ctx context.Context, prompt string, maxTokens int) (string, error) {
+	reqBody, err := json.Marshal(map[string]any{
+		"model":      a.model,
+		"max_tokens": maxTokens,
+		"messages":   []map[string]string{{"role": "user", "content": prompt}},
+	})
+	if err != nil {
+		return "", fmt.Errorf("llm: marshal request: %w", err)
+	}
+
+	var lastErr error
+	for attempt := 0; attempt < 3; attempt++ {
+		req, err := http.NewRequestWithContext(ctx, http.MethodPost, a.baseURL+"/v1/messages", bytes.NewReader(reqBody))
+		if err != nil {
+			return "", fmt.Errorf("llm: build request: %w", err)
+		}
+		req.Header.Set("content-type", "application/json")
+		req.Header.Set("x-api-key", a.apiKey)
+		req.Header.Set("anthropic-version", anthropicVersion)
+
+		resp, err := a.http.Do(req)
+		if err != nil {
+			lastErr = fmt.Errorf("llm: connection error: %w", err)
+			continue // transient — retry
+		}
+		body, _ := io.ReadAll(resp.Body)
+		resp.Body.Close()
+
+		if resp.StatusCode >= 500 || resp.StatusCode == http.StatusTooManyRequests {
+			lastErr = fmt.Errorf("llm: transient provider error (status %d): %s", resp.StatusCode, body)
+			continue
+		}
+		if resp.StatusCode >= 400 {
+			return "", fmt.Errorf("llm: provider request error (status %d): %s", resp.StatusCode, body)
+		}
+
+		var parsed struct {
+			Content []struct {
+				Type string `json:"type"`
+				Text string `json:"text"`
+			} `json:"content"`
+		}
+		if err := json.Unmarshal(body, &parsed); err != nil {
+			return "", fmt.Errorf("llm: decode response: %w", err)
+		}
+		for _, block := range parsed.Content {
+			if block.Type == "text" && block.Text != "" {
+				return block.Text, nil
+			}
+		}
+		return "", fmt.Errorf("llm: empty response from provider")
+	}
+	return "", fmt.Errorf("llm: exhausted retries: %w", lastErr)
+}

package/src/generators/capabilities/llm/providers/anthropic/stacks/python/src/__packageName__/adapters/llm.py.template

@@ -0,0 +1,61 @@
+from <%= packageName %>.core.domain.exceptions import TransientInferenceError, PermanentInferenceError, CircuitBreakerOpenError
+from tenacity import retry, wait_exponential_jitter, stop_after_attempt, retry_if_exception_type
+from circuitbreaker import circuit
+from <%= packageName %>.adapters.config import settings
+import anthropic
+import logging
+
+logger = logging.getLogger(__name__)
+
+def fallback_circuit_breaker(e):
+    logger.error(f"Circuit breaker tripped or open! {e}")
+    raise CircuitBreakerOpenError(f"External LLM API is unavailable. Please try again later.")
+
+class LLMClient:
+    def __init__(self):
+        # Defer building the provider client until the first generate_text call so
+        # the service boots and serves its non-LLM routes even when no API key is
+        # configured — the Anthropic client raises at construction on a missing key,
+        # which would otherwise 500 every route that depends on this service.
+        self._client: anthropic.AsyncAnthropic | None = None
+        self.model = settings.llm_model
+
+    @property
+    def client(self) -> anthropic.AsyncAnthropic:
+        if self._client is None:
+            # base_url is optional — leave LLM_BASE_URL blank to use Anthropic's default endpoint.
+            self._client = anthropic.AsyncAnthropic(
+                api_key=settings.llm_api_key,
+                base_url=settings.llm_base_url or None,
+            )
+        return self._client
+
+    @circuit(failure_threshold=5, recovery_timeout=30, fallback_function=fallback_circuit_breaker, expected_exception=TransientInferenceError)
+    @retry(
+        wait=wait_exponential_jitter(initial=1, max=30),
+        stop=stop_after_attempt(5),
+        retry=retry_if_exception_type(TransientInferenceError)
+    )
+    async def generate_text(self, prompt: str, max_tokens: int = 100) -> str:
+        try:
+            response = await self.client.messages.create(
+                model=self.model,
+                max_tokens=max_tokens,
+                messages=[{"role": "user", "content": prompt}]
+            )
+
+            # Boundary validation: ensure we got a valid text response
+            content = next((block.text for block in response.content if block.type == "text"), None)
+            if not content:
+                raise PermanentInferenceError("Received empty response from LLM provider")
+
+            return content
+
+        except anthropic.APIConnectionError as e:
+            raise TransientInferenceError(f"Connection error: {e}")
+        except anthropic.RateLimitError as e:
+            raise TransientInferenceError(f"Rate limited: {e}")
+        except anthropic.APIStatusError as e:
+            if e.status_code >= 500:
+                raise TransientInferenceError(f"Provider server error: {e}")
+            raise PermanentInferenceError(f"Provider request error: {e}")

package/src/generators/capabilities/llm/providers/local/footprint.json

@@ -0,0 +1,13 @@
+{
+  "kind": "env",
+  "summary": "A self-hosted, OpenAI-compatible endpoint (Ollama, vLLM, llama.cpp, LM Studio). Points at a base URL you run; no cloud key, no infrastructure this scaffold provisions. If you containerise the model server, add it as a compose service; if it is a host process, register it as a runner.",
+  "env": [
+    { "name": "LLM_API_KEY", "required": false, "default": "not-needed" },
+    { "name": "LLM_BASE_URL", "required": true, "default": "http://localhost:11434/v1" },
+    { "name": "LLM_MODEL", "required": false, "default": "llama3.1" }
+  ],
+  "stacks": {
+    "python": { "dependencies": ["openai>=1.14.0"] },
+    "go": { "dependencies": [] }
+  }
+}