@inference-gateway/adl-cli 0.47.1 → 0.48.1

package/README.md

@@ -33,6 +33,7 @@ _A command-line interface for generating enterprise-ready A2A (Agent-to-Agent) s
 - [Sandbox Environments](#sandbox-environments)
 - [Enterprise Features](#enterprise-features)
 - [Artifacts Support](#artifacts-support)
+- [Telemetry](#telemetry)
 - [GitHub Issue Templates](#github-issue-templates)
 - [Examples](#examples)
 - [Template System & Architecture](#template-system--architecture)
@@ -64,6 +65,7 @@ The ADL CLI helps you build enterprise-ready A2A agents quickly by generating co
 - 🎣 **Post-Generation Hooks** - Customize build, format, and test commands after generation
 - 🤖 **Multi-Provider AI** - OpenAI, Anthropic, Google, Groq, Mistral, DeepSeek, Cohere, Cloudflare, Moonshot, Ollama, Ollama Cloud, and Nvidia support
 - 📁 **Artifacts Support** - Integrated filesystem and MinIO object storage for artifact management
+- 📡 **OpenTelemetry Instrumentation** - Opt-in tracing and metrics via `spec.telemetry.enabled` (Go and TypeScript)
 
 ## Installation
 
@@ -275,7 +277,7 @@ The init command supports extensive configuration options:
 **Go Options:**
 
 - `--go-module` - Go module path (e.g., `github.com/user/project`)
-- `--go-version` - Go version (e.g., `1.26.2`)
+- `--go-version` - Go version (e.g., `1.26.4`)
 
 **Rust Options:**
 
@@ -289,8 +291,9 @@ The init command supports extensive configuration options:
 
 **Environment Options:**
 
-- `--flox` - Enable Flox environment
 - `--devcontainer` - Enable DevContainer environment
+- `--docker-compose` - Enable Docker Compose environment
+- `--flox` - Enable Flox environment
 
 **Pipeline / AI Options (declarative, written into the manifest as `false` by default):**
 
@@ -302,6 +305,10 @@ The init command supports extensive configuration options:
 - `--ci` - Sets `spec.scm.ci: true` (generate CI workflow on `adl generate`)
 - `--cd` - Sets `spec.scm.cd: true` (generate CD pipeline + semantic-release on `adl generate`)
 
+**Deployment Options:**
+
+- `--deployment` - Deployment type (`kubernetes`, `cloudrun`, `vercel`, `cloudflare` (TypeScript-only); defaults to empty for no deployment)
+
 ### Generate Command
 
 ```bash
@@ -331,7 +338,10 @@ adl generate --file agent.yaml --output ./test-my-agent --deployment cloudrun --
 | `--overwrite`      | Overwrite existing files (respects .adl-ignore)                                    |
 | `--ci`             | Generate CI workflow configuration (GitHub Actions). Overrides `spec.scm.ci`.      |
 | `--cd`             | Generate CD pipeline configuration with semantic-release. Overrides `spec.scm.cd`. |
-| `--deployment`     | Generate deployment configuration (`kubernetes`, `cloudrun`)                       |
+| `--deployment`     | Generate deployment configuration (`kubernetes`, `cloudrun`, `vercel`, `cloudflare` (TypeScript-only)) |
+| `--devcontainer`  | Enable DevContainer environment                                                    |
+| `--flox`          | Enable Flox environment                                                            |
+| `--offline`       | Skip the skills registry; require every non-bare skill to already be in the local cache |
 
 > **Declarative equivalents:** `--ci` and `--cd` are mirrored by `spec.scm.ci`
 > and `spec.scm.cd`. The CLI flag is OR'd on top of the manifest value (passing
@@ -473,7 +483,7 @@ spec:
   language:
     go:
       module: "github.com/example/weather-agent"
-      version: "1.26.2"
+      version: "1.26.4"
   acronyms: # Optional: Custom acronyms for better code generation
     - api
     - json
@@ -496,6 +506,7 @@ The complete ADL schema includes:
 - **scm**: Source control management configuration (GitHub, GitLab)
 - **sandbox**: Development environment configuration (Flox, DevContainer)
 - **deployment**: Platform-specific deployment configuration (Kubernetes, Cloud Run)
+- **telemetry**: OpenTelemetry instrumentation toggle (see [Telemetry](#telemetry))
 
 ### Complete ADL Example
 
@@ -602,7 +613,7 @@ spec:
   language:
     go:
       module: "github.com/company/advanced-agent"
-      version: "1.26.2"
+      version: "1.26.4"
   scm:
     provider: github
     url: "https://github.com/company/advanced-agent"
@@ -674,7 +685,7 @@ spec:
   language:
     go:
       module: github.com/example/agent
-      version: "1.26.2"
+      version: "1.26.4"
       vendor:
         deps:
           - github.com/google/uuid@v1.6.0
@@ -770,7 +781,7 @@ Worked example per backend:
 # Flox: pin deno + kubectl + terraform alongside the Go toolchain
 spec:
   language:
-    go: { module: github.com/example/agent, version: "1.26.2" }
+    go: { module: github.com/example/agent, version: "1.26.4" }
   development:
     sandbox:
       flox:
@@ -785,7 +796,7 @@ spec:
 # Devcontainer: same deps, rendered as an apt-packages feature
 spec:
   language:
-    go: { module: github.com/example/agent, version: "1.26.2" }
+    go: { module: github.com/example/agent, version: "1.26.4" }
   development:
     sandbox:
       devcontainer:
@@ -970,6 +981,8 @@ Resolution precedence at runtime: **env > compile-time literal > built-in defaul
 
 ## Service Injection & Configuration Management
 
+> **Note:** The code examples in this section are **illustrative** - they show the conceptual shape of the generated code but may not match the exact output of the current templates. For the authoritative generated output, refer to the Go templates in `internal/templates/languages/go/` (config.go.tmpl, service.go.tmpl, tool.go.tmpl, main.go.tmpl).
+
 The ADL CLI provides a sophisticated service injection system with structured configuration management. This system improves testability, separation of concerns, and provides type-safe configuration with environment variable mapping.
 
 ### Structured Service System
@@ -1021,15 +1034,14 @@ The configuration system generates type-safe structs with automatic environment
 
 **Generated Configuration (`config/config.go`):**
 
+> Illustrative example - see `internal/templates/languages/go/config.go.tmpl` for the actual template. The `Config` struct is generated dynamically from `spec.config` entries; the `Environment` field shown below is not generated by the template.
+
 ```go
 type Config struct {
-    // Core application settings
-    Environment string `env:"ENVIRONMENT"`
-
-    // A2A configuration
+    // A2A configuration (all A2A_ prefixed vars)
     A2A serverConfig.Config `env:",prefix=A2A_"`
 
-    // Custom configuration sections
+    // Custom configuration sections (one per spec.config entry, excluding "tools")
     Cache          CacheConfig          `env:",prefix=CACHE_"`
     GoogleCalendar GoogleCalendarConfig `env:",prefix=GOOGLE_CALENDAR_"`
 }
@@ -1090,33 +1102,40 @@ spec:
         required: [recipient]
 ```
 
-**Generated Skill Code:**
+**Generated Tool Code:**
+
+> Illustrative example - see `internal/templates/languages/go/tool.go.tmpl` for the actual template. Generated tools live under `tools/`, not `skills/`.
 
 ```go
-type ExportReportSkill struct {
+type ExportReportTool struct {
     logger   *zap.Logger
     database database.DatabaseService
     email    *config.EmailConfig  // Type-safe access to email config only
 }
 
-func NewExportReportSkill(
+func NewExportReportTool(
     logger *zap.Logger,
     database database.DatabaseService,
     email *config.EmailConfig,
 ) server.Tool {
-    skill := &ExportReportSkill{
+    tool := &ExportReportTool{
         logger:   logger,
         database: database,
         email:    email,
     }
-    // ...
+    return server.NewBasicTool(
+        "export_report",
+        "Export data and email report",
+        map[string]any{ /* schema */ },
+        tool.ExportReportHandler,
+    )
 }
 
-func (s *ExportReportSkill) ExportReportHandler(ctx context.Context, args map[string]any) (string, error) {
+func (t *ExportReportTool) ExportReportHandler(ctx context.Context, args map[string]any) (string, error) {
     // Direct access to email config subsection
-    apiKey := s.email.APIKey
-    fromAddress := s.email.FromAddress
-    provider := s.email.Provider
+    apiKey := t.email.APIKey
+    fromAddress := t.email.FromAddress
+    provider := t.email.Provider
 
     // ... implementation
 }
@@ -1124,10 +1143,12 @@ func (s *ExportReportSkill) ExportReportHandler(ctx context.Context, args map[st
 
 **Main Registration:**
 
+> Illustrative example - see `internal/templates/languages/go/main.go.tmpl` for the actual template.
+
 ```go
 // In main.go - config subsection is passed directly
-exportReportSkill := skills.NewExportReportSkill(l, databaseSvc, &cfg.Email)
-toolBox.AddTool(exportReportSkill)
+exportReportTool := tools.NewExportReportTool(l, databaseSvc, &cfg.Email)
+toolBox.AddTool(exportReportTool)
 ```
 
 **Benefits of Config Subsection Injection:**
@@ -1191,24 +1212,23 @@ Each service generates a package with interface and factory:
 
 **Example `internal/googleCalendar/googleCalendar.go`:**
 
+> Illustrative example - see `internal/templates/languages/go/service.go.tmpl` for the actual template.
+
 ```go
 type CalendarService interface {
-    // TODO: Define your CalendarService interface methods
-    CreateEvent(ctx context.Context, event *Event) error
-    ListEvents(ctx context.Context, query *Query) ([]*Event, error)
+    // TODO: Define the methods for CalendarService service
+    // Example:
+    // SomeMethod(ctx context.Context, param string) error
 }
 
-type calendarService struct {
-    logger *zap.Logger
-    config *config.Config
+type calendarServiceImpl struct {
+    // TODO: Add fields needed for this service
 }
 
 func NewCalendarService(logger *zap.Logger, cfg *config.Config) (CalendarService, error) {
-    // TODO: Implement CalendarService initialization
-    return &calendarService{
-        logger: logger,
-        config: cfg,
-    }, nil
+    // TODO: Implement constructor logic for CalendarService
+    logger.Info("initializing CalendarService service")
+    return &calendarServiceImpl{}, nil
 }
 ```
 
@@ -1216,21 +1236,29 @@ func NewCalendarService(logger *zap.Logger, cfg *config.Config) (CalendarService
 
 Skills automatically receive injected services as constructor parameters:
 
-**Example `skills/create_event.go`:**
+**Example `tools/create_event.go`:**
+
+> Illustrative example - see `internal/templates/languages/go/tool.go.tmpl` for the actual template. Generated tools live under `tools/`, not `skills/`.
 
 ```go
-type CreateEventSkill struct {
-    logger    *zap.Logger
-    calendar  googleCalendar.CalendarService
-    cache     cache.CacheRepository
+type CreateEventTool struct {
+    logger   *zap.Logger
+    calendar googleCalendar.CalendarService
+    cache    cache.CacheRepository
 }
 
-func NewCreateEventSkill(logger *zap.Logger, calendar googleCalendar.CalendarService, cache cache.CacheRepository) *CreateEventSkill {
-    return &CreateEventSkill{
+func NewCreateEventTool(logger *zap.Logger, calendar googleCalendar.CalendarService, cache cache.CacheRepository) server.Tool {
+    tool := &CreateEventTool{
         logger:   logger,
         calendar: calendar,
         cache:    cache,
     }
+    return server.NewBasicTool(
+        "create_event",
+        "Create a new calendar event",
+        map[string]any{ /* schema */ },
+        tool.CreateEventHandler,
+    )
 }
 ```
 
@@ -1293,9 +1321,7 @@ my-go-agent/
 │       └── refactor_request.md # Refactoring request template
 ├── .releaserc.yaml            # Semantic-release configuration (with --cd flag)
 ├── k8s/
-│   └── deployment.yaml        # Kubernetes deployment manifest
-├── cloudrun/
-│   └── deploy.sh              # CloudRun deployment script (with --deployment cloudrun)
+│   └── deployment.yaml        # Kubernetes deployment manifest (with --deployment kubernetes)
 ├── .flox/                     # Generated when sandbox: flox
 │   ├── env/manifest.toml
 │   ├── env.json
@@ -1334,9 +1360,7 @@ my-rust-agent/
 │   └── cd.yml                 # GitHub Actions CD workflow (with --cd flag)
 ├── .releaserc.yaml            # Semantic-release configuration (with --cd flag)
 ├── k8s/
-│   └── deployment.yaml        # Kubernetes deployment
-├── cloudrun/
-│   └── deploy.sh              # CloudRun deployment script (with --deployment cloudrun)
+│   └── deployment.yaml        # Kubernetes deployment (with --deployment kubernetes)
 ├── CLAUDE.md                  # AI assistant instructions (spec.development.ai.orchestrators.claudecode.enabled: true)
 └── README.md                  # Documentation
 ```
@@ -1384,7 +1408,7 @@ All projects include these essential files regardless of language:
 - **`.well-known/agent-card.json`** - A2A agent discovery and capabilities manifest
 - **`Taskfile.yml`** - Unified task runner configuration for build, test, lint, run
 - **`Dockerfile`** - Language-optimized container configuration
-- **`k8s/deployment.yaml`** - Kubernetes deployment manifest
+- **`k8s/deployment.yaml`** - Kubernetes deployment manifest (only when `spec.deployment.type: kubernetes`)
 - **`deploy` task in `Taskfile.yml`** - CloudRun deployment task (when using `--deployment cloudrun`)
 - **`.adl-ignore`** - Protects user implementations from overwrite
 - **CI Workflows** - When using `--ci` flag, generates GitHub Actions workflows:
@@ -1811,6 +1835,28 @@ Configure storage via environment variables (see generated README for A2A*ARTIFA
 - `examples/go-agent-artifacts-filesystem.yaml` - Filesystem storage example
 - `examples/go-agent-artifacts-minio.yaml` - MinIO storage example
 
+## Telemetry
+
+Enable OpenTelemetry instrumentation for the generated agent:
+
+```yaml
+spec:
+  telemetry:
+    enabled: true
+```
+
+The manifest field is a single on/off switch - exporter endpoints, ports, and sampling stay runtime concerns configured via environment variables in the generated `.env.example`:
+
+- **Go**: pulls the OpenTelemetry runtime dependencies into `go.mod`, generates `tools/telemetry.go` (each built-in tool call becomes its own span with `infer.tool.call.id`/`infer.session.id` attributes), and surfaces `A2A_TELEMETRY_ENABLE`, `A2A_TELEMETRY_METRICS_PORT`/`_HOST`, `A2A_TELEMETRY_TRACE_ENABLE`/`_ENDPOINT`/`_HEADERS` in `.env.example`.
+- **TypeScript**: wires the ADK's `createTelemetryProvider` into `src/index.ts` (no extra npm dependencies) and surfaces `TELEMETRY_ENABLE` plus the standard `OTEL_EXPORTER_OTLP_*` / `OTEL_SERVICE_*` variables in `.env.example`.
+
+> **Note:** Telemetry generation currently supports Go and TypeScript only; Rust agents ignore `spec.telemetry`.
+
+**Examples:**
+
+- `examples/go-agent-telemetry.yaml` - Go agent with metrics server, OTLP traces, and per-tool-call spans
+- `examples/typescript-agent-telemetry.yaml` - TypeScript agent with ADK-provided OTel wiring
+
 ## GitHub Issue Templates
 
 The ADL CLI can automatically generate GitHub issue templates for your agent projects, providing standardized forms for bug reports, feature requests, and refactoring tasks:
@@ -1879,25 +1925,25 @@ adl validate examples/cloudrun-ghcr-agent.yaml
 adl generate --file examples/go-agent.yaml --output ./test-go-agent
 adl generate --file examples/rust-agent.yaml --output ./test-rust-agent
 adl generate --file examples/typescript-agent.yaml --output ./test-typescript-agent
-adl generate --file examples/github-app-agent.yaml --output ./test-github-app-agent --cd
 adl generate --file examples/cloudrun-agent.yaml --output ./test-cloudrun-agent --deployment cloudrun
 adl generate --file examples/cloudrun-ghcr-agent.yaml --output ./test-ghcr-agent --deployment cloudrun
 
 # Generate with CI/CD pipeline
-adl generate --file examples/github-app-agent.yaml --output ./enterprise-agent --ci --cd
+adl generate --file examples/go-agent.yaml --output ./enterprise-agent --ci --cd
 adl generate --file examples/cloudrun-agent.yaml --output ./cloudrun-enterprise --deployment cloudrun --cd
 ```
 
 **Example ADL Files:**
 
-- `go-agent.yaml` - Basic Go agent with multiple skills and capabilities
-- `rust-agent.yaml` - Rust agent with enterprise features
+- `go-agent.yaml` - Go agent with services, tools, and an orchestration skill
+- `rust-agent.yaml` - Minimal Rust agent built with the Rust ADK
 - `typescript-agent.yaml` - Minimal TypeScript agent built with the TypeScript ADK
 - `typescript-agent-tools.yaml` - TypeScript agent with tools, services, and dependency injection
 - `typescript-agent-ai.yaml` - AI-powered TypeScript agent with LLM-driven tools
-- `github-app-agent.yaml` - Enterprise agent with GitHub App CD integration
-- `cloudrun-agent.yaml` - CloudRun deployment with Google Container Registry
-- `cloudrun-ghcr-agent.yaml` - CloudRun deployment with GitHub Container Registry
+- `cloudrun-agent.yaml` - Cloud Run deployment with Google Container Registry
+- `cloudrun-ghcr-agent.yaml` - Cloud Run deployment with GitHub Container Registry
+
+See [`examples/README.md`](examples/README.md) for the full catalog of all 18 example manifests.
 
 ## Template System & Architecture
 
@@ -1924,25 +1970,89 @@ Each language has its own file mapping that determines what gets generated:
 **Go Projects:**
 
 - `main.go` → Go main server setup
+- `config/config.go` → Application configuration
+- `internal/logger/logger.go` → Structured logging
+- `internal/{service}/{service}.go` → Service implementation per ADL service
 - `tools/{toolname}.go` → Individual function-call tool implementations
+- `tools/{builtin}.go` + `tools/{builtin}_test.go` → Reserved built-in tool implementations (read, bash, write, edit, fetch)
+- `tools/telemetry.go` → OpenTelemetry instrumentation (when telemetry enabled and built-in tools present)
 - `skills/{skillid}/SKILL.md` → Markdown skill playbooks (loaded into system prompt at runtime)
 - `go.mod` → Go module configuration
-- Language-specific Dockerfile and CI configurations
+- `Dockerfile` → Container image
+- `.dockerignore` → Docker build exclusions
+- `.gitignore`, `.gitattributes`, `.editorconfig` → Repository configuration
+- `README.md`, `LICENSE` → Project documentation
+- `Taskfile.yml` → Development task runner
+- `.well-known/agent-card.json` → A2A capabilities manifest
+- `k8s/deployment.yaml` → Kubernetes deployment (only when `spec.deployment.type: kubernetes`)
+- `vercel.json`, `.vercel/project.json` → Vercel deployment (only when `spec.deployment.type: vercel`)
+- `docker-compose.yaml`, `.env.example` → Docker Compose sandbox (conditional on sandbox config)
+- `.flox/` → Flox reproducible environment (conditional)
+- `.devcontainer/` → Devcontainer configuration (conditional)
+- `CLAUDE.md`, `GEMINI.md`, `AGENTS.md` → AI assistant documentation (conditional on AI toggles)
+- `.github/ISSUE_TEMPLATE/*.md` → GitHub issue templates (conditional on SCM config)
+- `.github/dependabot.yml` → Dependabot configuration (conditional on SCM config)
+- CI workflow (`.github/workflows/ci.go.yaml`) → Conditional on SCM CI toggle
+- CD workflow (`.github/workflows/cd.yaml`) → Conditional on SCM CD toggle
+- AI agent workflows (`.github/workflows/ai-*.yaml`) → Conditional on AI orchestrator toggles
 
 **Rust Projects:**
 
 - `src/main.rs` → Rust main application
 - `src/tools/{toolname}.rs` → Tool descriptor + handler
+- `src/tools/{builtin}.rs` → Reserved built-in tool implementations (read, bash, write, edit, fetch)
 - `src/tools/mod.rs` → Module declarations
 - `skills/{skillid}/SKILL.md` → Markdown skill playbooks
 - `Cargo.toml` → Rust package configuration
-
-**Universal Files:**
-
+- `Dockerfile` → Container image
+- `.dockerignore` → Docker build exclusions
+- `.gitignore`, `.gitattributes`, `.editorconfig` → Repository configuration
+- `README.md`, `LICENSE` → Project documentation
+- `Taskfile.yml` → Development task runner
+- `.well-known/agent-card.json` → A2A capabilities manifest
+- `k8s/deployment.yaml` → Kubernetes deployment (only when `spec.deployment.type: kubernetes`)
+- `vercel.json`, `.vercel/project.json` → Vercel deployment (only when `spec.deployment.type: vercel`)
+- `docker-compose.yaml`, `.env.example` → Docker Compose sandbox (conditional on sandbox config)
+- `.flox/` → Flox reproducible environment (conditional)
+- `.devcontainer/` → Devcontainer configuration (conditional)
+- `CLAUDE.md`, `GEMINI.md`, `AGENTS.md` → AI assistant documentation (conditional on AI toggles)
+- `.github/ISSUE_TEMPLATE/*.md` → GitHub issue templates (conditional on SCM config)
+- `.github/dependabot.yml` → Dependabot configuration (conditional on SCM config)
+- CI workflow (`.github/workflows/ci.rust.yaml`) → Conditional on SCM CI toggle
+- CD workflow (`.github/workflows/cd.yaml`) → Conditional on SCM CD toggle
+- AI agent workflows (`.github/workflows/ai-*.yaml`) → Conditional on AI orchestrator toggles
+
+**TypeScript Projects:**
+
+- `src/index.ts` → TypeScript main application
+- `src/config.ts` → Application configuration
+- `src/logger.ts` → Structured logging
+- `src/services/{service}.ts` → Service implementation per ADL service
+- `src/tools/{toolname}.ts` → Individual function-call tool implementations
+- `src/tools/index.ts` → Tool module barrel export
+- `src/worker.ts` → Cloudflare Worker entrypoint (only when `spec.deployment.type: cloudflare`)
+- `skills/{skillid}/SKILL.md` → Markdown skill playbooks
+- `package.json` → Node.js package configuration
+- `pnpm-workspace.yaml` → pnpm workspace configuration
+- `tsconfig.json` → TypeScript compiler configuration
+- `Dockerfile` → Container image
+- `.dockerignore` → Docker build exclusions
+- `.gitignore`, `.gitattributes`, `.editorconfig` → Repository configuration
+- `README.md`, `LICENSE` → Project documentation
 - `Taskfile.yml` → Development task runner
-- `.well-known/agent-card.json` → A2A capabilities manifest (skills are listed here, not tools)
-- `k8s/deployment.yaml` → Kubernetes deployment
-- CI workflows and sandbox configurations
+- `.well-known/agent-card.json` → A2A capabilities manifest
+- `wrangler.toml` → Cloudflare Workers configuration (only when `spec.deployment.type: cloudflare`)
+- `k8s/deployment.yaml` → Kubernetes deployment (only when `spec.deployment.type: kubernetes`)
+- `vercel.json`, `.vercel/project.json` → Vercel deployment (only when `spec.deployment.type: vercel`)
+- `docker-compose.yaml`, `.env.example` → Docker Compose sandbox (conditional on sandbox config)
+- `.flox/` → Flox reproducible environment (conditional)
+- `.devcontainer/` → Devcontainer configuration (conditional)
+- `CLAUDE.md`, `GEMINI.md`, `AGENTS.md` → AI assistant documentation (conditional on AI toggles)
+- `.github/ISSUE_TEMPLATE/*.md` → GitHub issue templates (conditional on SCM config)
+- `.github/dependabot.yml` → Dependabot configuration (conditional on SCM config)
+- CI workflow (`.github/workflows/ci.typescript.yaml`) → Conditional on SCM CI toggle
+- CD workflow (`.github/workflows/cd.yaml`) → Conditional on SCM CD toggle
+- AI agent workflows (`.github/workflows/ai-*.yaml`) → Conditional on AI orchestrator toggles
 
 ### Template Context
 
@@ -1950,13 +2060,22 @@ All templates receive a rich context object:
 
 ```go
 type Context struct {
-    ADL      *schema.ADL           // Complete ADL configuration
-    Metadata GeneratedMetadata     // Generation metadata
-    Language string               // Detected language
+    ADL             *schema.ADL                // Complete ADL configuration
+    Metadata        schema.GeneratedMetadata  // Generation metadata (CLI version, timestamp, template, ADL file)
+    Language        string                    // Detected language (go, rust, typescript)
+    GenerateCI      bool                      // Whether to generate CI workflows
+    GenerateCD      bool                      // Whether to generate CD workflows
+    EnableAI        bool                      // Whether AI assistant features are enabled
+    AIToggles       schema.AIAgentToggles      // Per-agent AI toggles (Claude Code, Codex, Gemini, OpenCode, Infer)
+    GenerateCommand string                    // The CLI command used to generate the project
+    Skills          []SkillView               // Resolved skill metadata (frontmatter only)
+    BuiltinConfigs  schema.ResolvedBuiltinConfigs  // Decoded config for reserved built-in tools
+    Vendor          vendor.View               // Resolved user-declared extra dependencies
+    SandboxDeps     sandbox.View              // Resolved sandbox-level extra packages
 }
 ```
 
-This allows templates to access any ADL configuration and generate language-appropriate code.
+This allows templates to access any ADL configuration, toggle features based on SCM and AI settings, and generate language-appropriate code with the correct dependencies.
 
 ## Customizing Generation with .adl-ignore
 
@@ -2004,7 +2123,7 @@ Taskfile.yml
 
 ### Prerequisites
 
-- Go 1.26.2+
+- Go 1.26.4+
 - [Task](https://taskfile.dev/) (optional, for using Taskfile commands)
 
 ### Building from Source
@@ -2069,7 +2188,7 @@ spec:
   language:
     go:
       module: "github.com/company/my-agent"
-      version: "1.26.2"
+      version: "1.26.4"
   acronyms: ["n8n", "xml", "mqtt", "iot", "uuid"]
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inference-gateway/adl-cli",
-  "version": "0.47.1",
+  "version": "0.48.1",
   "description": "Scaffold complete A2A (Agent-to-Agent) projects from YAML Agent Definition Language (ADL) manifests. Thin npm wrapper around the native adl binary.",
   "bin": {
     "adl": "bin/run.js"