groundwork-method 0.0.1 → 0.11.0

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": [] }
+  }
+}

package/src/generators/capabilities/llm/providers/local/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)
+
+// Client calls a self-hosted, OpenAI-compatible endpoint (Ollama,
+// vLLM, llama.cpp, LM Studio) over HTTP. Minimal net/http adapter, no SDK
+// dependency. Reads LLM_BASE_URL (the server you run) / LLM_MODEL / LLM_API_KEY
+// from env; local servers usually ignore the key.
+type Client struct {
+	apiKey  string
+	baseURL string
+	model   string
+	http    *http.Client
+}
+
+func NewClient() *Client {
+	base := os.Getenv("LLM_BASE_URL")
+	if base == "" {
+		base = "http://localhost:11434/v1"
+	}
+	model := os.Getenv("LLM_MODEL")
+	if model == "" {
+		model = "llama3.1"
+	}
+	apiKey := os.Getenv("LLM_API_KEY")
+	if apiKey == "" {
+		apiKey = "not-needed"
+	}
+	return &Client{
+		apiKey:  apiKey,
+		baseURL: base,
+		model:   model,
+		http:    &http.Client{Timeout: 120 * 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+"/chat/completions", bytes.NewReader(reqBody))
+		if err != nil {
+			return "", fmt.Errorf("llm: build request: %w", err)
+		}
+		req.Header.Set("content-type", "application/json")
+		req.Header.Set("authorization", "Bearer "+a.apiKey)
+
+		resp, err := a.http.Do(req)
+		if err != nil {
+			lastErr = fmt.Errorf("llm: connection error (is the local model server up at %s?): %w", a.baseURL, 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 endpoint error (status %d): %s", resp.StatusCode, body)
+			continue
+		}
+		if resp.StatusCode >= 400 {
+			return "", fmt.Errorf("llm: endpoint request error (status %d): %s", resp.StatusCode, body)
+		}
+
+		var parsed struct {
+			Choices []struct {
+				Message struct {
+					Content string `json:"content"`
+				} `json:"message"`
+			} `json:"choices"`
+		}
+		if err := json.Unmarshal(body, &parsed); err != nil {
+			return "", fmt.Errorf("llm: decode response: %w", err)
+		}
+		if len(parsed.Choices) == 0 || parsed.Choices[0].Message.Content == "" {
+			return "", fmt.Errorf("llm: empty response from local endpoint")
+		}
+		return parsed.Choices[0].Message.Content, nil
+	}
+	return "", fmt.Errorf("llm: exhausted retries: %w", lastErr)
+}

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

@@ -0,0 +1,53 @@
+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 openai
+import logging
+
+logger = logging.getLogger(__name__)
+
+def fallback_circuit_breaker(e):
+    logger.error(f"Circuit breaker tripped or open! {e}")
+    raise CircuitBreakerOpenError(f"Local LLM endpoint is unavailable. Is the model server running at LLM_BASE_URL?")
+
+class LLMClient:
+    """OpenAI-compatible adapter for a self-hosted endpoint (Ollama, vLLM,
+    llama.cpp, LM Studio). Talks to settings.llm_base_url; the API key is usually
+    irrelevant for local servers, so it defaults to a placeholder."""
+
+    def __init__(self):
+        self.client = openai.AsyncOpenAI(
+            api_key=settings.llm_api_key or "not-needed",
+            base_url=settings.llm_base_url,
+        )
+        self.model = settings.llm_model
+
+    @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.chat.completions.create(
+                model=self.model,
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=max_tokens
+            )
+
+            content = response.choices[0].message.content
+            if not content:
+                raise PermanentInferenceError("Received empty response from local LLM endpoint")
+
+            return content
+
+        except openai.APIConnectionError as e:
+            raise TransientInferenceError(f"Connection error (is the local model server up?): {e}")
+        except openai.RateLimitError as e:
+            raise TransientInferenceError(f"Rate limited: {e}")
+        except openai.APIStatusError as e:
+            if e.status_code >= 500:
+                raise TransientInferenceError(f"Local endpoint server error: {e}")
+            raise PermanentInferenceError(f"Local endpoint request error: {e}")

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

@@ -0,0 +1,29 @@
+{
+  "kind": "compose-service",
+  "summary": "A model-inference server (LocalAI) running as a docker-compose service, exposing an OpenAI-compatible API on :8080. Selecting it injects the container into the workspace compose; the adapter talks to it by env-configured base URL (the compose service name on the network, or localhost from the host).",
+  "env": [
+    { "name": "LLM_API_KEY", "required": false, "default": "not-needed" },
+    { "name": "LLM_BASE_URL", "required": true, "default": "http://localhost:8080/v1" },
+    { "name": "LLM_MODEL", "required": false, "default": "gpt-4" }
+  ],
+  "composeService": {
+    "name": "localai",
+    "definition": {
+      "image": "localai/localai:latest-aio-cpu",
+      "ports": ["8080:8080"],
+      "networks": ["groundwork-net"],
+      "volumes": ["localai_models:/models"],
+      "healthcheck": {
+        "test": ["CMD", "curl", "-f", "http://localhost:8080/readyz"],
+        "interval": "30s",
+        "timeout": "10s",
+        "retries": 5
+      }
+    },
+    "volumes": ["localai_models"]
+  },
+  "stacks": {
+    "python": { "dependencies": ["openai>=1.14.0"] },
+    "go": { "dependencies": [] }
+  }
+}

package/src/generators/capabilities/llm/providers/localai/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)
+
+// Client calls a self-hosted, OpenAI-compatible endpoint (Ollama,
+// vLLM, llama.cpp, LM Studio) over HTTP. Minimal net/http adapter, no SDK
+// dependency. Reads LLM_BASE_URL (the server you run) / LLM_MODEL / LLM_API_KEY
+// from env; local servers usually ignore the key.
+type Client struct {
+	apiKey  string
+	baseURL string
+	model   string
+	http    *http.Client
+}
+
+func NewClient() *Client {
+	base := os.Getenv("LLM_BASE_URL")
+	if base == "" {
+		base = "http://localhost:11434/v1"
+	}
+	model := os.Getenv("LLM_MODEL")
+	if model == "" {
+		model = "llama3.1"
+	}
+	apiKey := os.Getenv("LLM_API_KEY")
+	if apiKey == "" {
+		apiKey = "not-needed"
+	}
+	return &Client{
+		apiKey:  apiKey,
+		baseURL: base,
+		model:   model,
+		http:    &http.Client{Timeout: 120 * 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+"/chat/completions", bytes.NewReader(reqBody))
+		if err != nil {
+			return "", fmt.Errorf("llm: build request: %w", err)
+		}
+		req.Header.Set("content-type", "application/json")
+		req.Header.Set("authorization", "Bearer "+a.apiKey)
+
+		resp, err := a.http.Do(req)
+		if err != nil {
+			lastErr = fmt.Errorf("llm: connection error (is the local model server up at %s?): %w", a.baseURL, 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 endpoint error (status %d): %s", resp.StatusCode, body)
+			continue
+		}
+		if resp.StatusCode >= 400 {
+			return "", fmt.Errorf("llm: endpoint request error (status %d): %s", resp.StatusCode, body)
+		}
+
+		var parsed struct {
+			Choices []struct {
+				Message struct {
+					Content string `json:"content"`
+				} `json:"message"`
+			} `json:"choices"`
+		}
+		if err := json.Unmarshal(body, &parsed); err != nil {
+			return "", fmt.Errorf("llm: decode response: %w", err)
+		}
+		if len(parsed.Choices) == 0 || parsed.Choices[0].Message.Content == "" {
+			return "", fmt.Errorf("llm: empty response from local endpoint")
+		}
+		return parsed.Choices[0].Message.Content, nil
+	}
+	return "", fmt.Errorf("llm: exhausted retries: %w", lastErr)
+}

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

@@ -0,0 +1,53 @@
+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 openai
+import logging
+
+logger = logging.getLogger(__name__)
+
+def fallback_circuit_breaker(e):
+    logger.error(f"Circuit breaker tripped or open! {e}")
+    raise CircuitBreakerOpenError(f"Local LLM endpoint is unavailable. Is the model server running at LLM_BASE_URL?")
+
+class LLMClient:
+    """OpenAI-compatible adapter for a self-hosted endpoint (Ollama, vLLM,
+    llama.cpp, LM Studio). Talks to settings.llm_base_url; the API key is usually
+    irrelevant for local servers, so it defaults to a placeholder."""
+
+    def __init__(self):
+        self.client = openai.AsyncOpenAI(
+            api_key=settings.llm_api_key or "not-needed",
+            base_url=settings.llm_base_url,
+        )
+        self.model = settings.llm_model
+
+    @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.chat.completions.create(
+                model=self.model,
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=max_tokens
+            )
+
+            content = response.choices[0].message.content
+            if not content:
+                raise PermanentInferenceError("Received empty response from local LLM endpoint")
+
+            return content
+
+        except openai.APIConnectionError as e:
+            raise TransientInferenceError(f"Connection error (is the local model server up?): {e}")
+        except openai.RateLimitError as e:
+            raise TransientInferenceError(f"Rate limited: {e}")
+        except openai.APIStatusError as e:
+            if e.status_code >= 500:
+                raise TransientInferenceError(f"Local endpoint server error: {e}")
+            raise PermanentInferenceError(f"Local endpoint request error: {e}")

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

@@ -0,0 +1,9 @@
+{
+  "kind": "none",
+  "summary": "Bare interface. The TextGenerator interface plus a not-yet-implemented stub and a strict-xfail contract test — a bet. No provider SDK, no env, no infrastructure. Implement it (or run `add-capability` with a real provider) to cash the bet.",
+  "env": [],
+  "stacks": {
+    "python": { "dependencies": [] },
+    "go": { "dependencies": [] }
+  }
+}

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

@@ -0,0 +1,35 @@
+// Package llm — bare LLM adapter: the interface is defined, the adapter is NOT
+// implemented. A bet.
+//
+// The service.TextGenerator interface (internal/core/service/llm.go) fixes the
+// contract the core depends on; this adapter is the slot where you build the
+// implementation. The contract test (llm_test.go) Skips while this stub returns
+// an error and flips to a live assertion the moment GenerateText works — your
+// cue the bet is delivered.
+//
+// To cash the bet, implement GenerateText below, or regenerate against a shipped
+// provider:
+//
+//	nx g add-capability --service <this-service> --capability llm --provider anthropic
+package llm
+
+import (
+	"context"
+	"fmt"
+
+	"<%= moduleName %>/internal/core/service"
+)
+
+// Ensure Client implements the service.TextGenerator interface.
+var _ service.TextGenerator = (*Client)(nil)
+
+type Client struct{}
+
+func NewClient() *Client {
+	// No provider client to construct yet — that's the bet.
+	return &Client{}
+}
+
+func (a *Client) GenerateText(ctx context.Context, prompt string, maxTokens int) (string, error) {
+	return "", fmt.Errorf("llm adapter is not implemented: build out Client.GenerateText, or scaffold a provider with `add-capability --capability=llm --provider=anthropic|openai|local`")
+}

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

@@ -0,0 +1,25 @@
+"""Bare LLM adapter — the port is defined, the implementation is NOT YET written.
+
+This is a *bet*. The TextGenerator port (src/<%= packageName %>/core/llm.py) fixes the contract
+your domain depends on; this adapter is the slot where you build the
+implementation. The contract test in tests/contracts/test_llm.py is marked
+xfail(strict): the suite stays green while the bet is open and flips red the
+moment you make generate_text work — your cue to remove the marker.
+
+To cash the bet, either implement generate_text below, or regenerate against a
+shipped provider:
+
+    nx g add-capability --service=<this-service> --capability=llm --provider=anthropic
+"""
+
+
+class LLMClient:
+    def __init__(self) -> None:
+        # No provider client to construct yet — that's the bet.
+        pass
+
+    async def generate_text(self, prompt: str, max_tokens: int = 100) -> str:
+        raise NotImplementedError(
+            "LLM adapter is not implemented. Build out LLMClient.generate_text, "
+            "or scaffold a provider with `add-capability --capability=llm --provider=anthropic|openai|local`."
+        )

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

@@ -0,0 +1,20 @@
+{
+  "kind": "runner",
+  "summary": "Ollama running as a local host process (`ollama serve`), exposing an OpenAI-compatible API on :11434. Registered as a native runner so `./dev start` brings it up alongside your services — no container. Requires the ollama binary installed on the host; pull a model with `ollama pull <model>`.",
+  "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" }
+  ],
+  "runner": {
+    "name": "ollama",
+    "kind": "sidecar",
+    "cmd": "ollama serve",
+    "autostart": true,
+    "health": { "type": "port", "port": 11434 }
+  },
+  "stacks": {
+    "python": { "dependencies": ["openai>=1.14.0"] },
+    "go": { "dependencies": [] }
+  }
+}