Routing DSL

​

Quando ricorrere al DSL

• Specializzazione per task — invia il codice a un modello di coding, la vision a un modello di vision, la chat economica a un modello economico.
• Routing consapevole della difficoltà — escala verso un modello costoso solo le richieste difficili; mantieni economiche quelle facili.
• Routing consapevole dell’agente — instrada in modo diverso in base allo stato della sessione (quali strumenti l’agente ha usato, se i test sono appena falliti, a che turno si trova).
• Regole per tempo / tenant / header — routing diverso per ora, gruppo utenti o un header della richiesta.

​

Abilitarlo

​

L’editor

• Template seedati con i modelli reali del tuo workspace (tramite un dialog di mappatura dei tier una tantum), così non parti mai da un file vuoto né ti scontri con un muro di “modello sconosciuto”.
• Insert — inserisci un Model, un Router (orcarouter/<name>) o un Pool dall’autocompletamento invece di digitare gli identificatori a mano.
• Generate — descrivi il routing che vuoi in linguaggio naturale e ottieni in cambio DSL compilato e privo di errori di lint, fondato sui tuoi modelli reali.
• Explain — una parafrasi in inglese semplice di ciò che fa il ruleset corrente.
• Lint inline — ogni errore riporta {line, column, message} e ogni codice di lint ha uno spiegatore ?. La precedenza (vince il primo match) e i pattern CEL comuni sono mostrati in loco.

​

Struttura del file

version: 1              # required — currently must be 1
rules: [...]            # required — 1 to 30 rules, evaluated in order
default: {...}          # required — the effect when no rule matches

rules:
  - id: hard_code              # required: ^[a-z][a-z0-9_]{0,39}$, unique
    when: |                    # optional CEL boolean; absent ⇒ always matches
      task_class == "code" && difficulty > 0.6
    use:
      model: "anthropic/claude-sonnet-4-6"
default:
  delegate: balanced           # fall back to a built-in strategy

​

when: — la condizione

​

Variabili

​

Macro

​

use: — l’effetto

​

Destinazione

use:
  model:    "anthropic/claude-sonnet-4-6"   # one upstream model
  models:   ["openai/gpt-4o-mini", "..."]   # load-balance across a list
  pool:     "@pool:<name>"                   # an admin-curated pool
  delegate: balanced                         # hand off to a built-in
                                             #   strategy: cheapest |
                                             #   quality | balanced |
                                             #   linucb | gated_adaptive

​

Knob per chiamata

use:
  reasoning_effort:       low | medium | high     # OpenAI o-series, Gemini
  thinking_budget_tokens: 1024..64000             # Claude / Gemini thinking
  samples:                1..16                    # the n parameter
  temperature:            0.0..2.0
  param_override:         { ... }                  # merged into upstream params
  header_override:        { ... }                  # merged into upstream headers
  reason_tag:             "<[a-z0-9_]+>"           # shows up in logs/telemetry
  affinity_ttl:           "5m"                      # channel stickiness window
  model_rewrite:          "<upstream-model>"       # send under a different name

​

Cascate di confidenza ed ensemble (avanzato)

rules:
  - id: code_with_repair
    when: task_class == "code"
    use:
      model: "openai/gpt-4o-mini"
    on_low_confidence:
      signals: [patch_invalid, self_doubt, next_turn_test_failed]
      use:
        model: "anthropic/claude-sonnet-4-6"   # repair attempt

use:
  parallel:
    - { model: "anthropic/claude-sonnet-4-6" }
    - { model: "openai/gpt-4o-mini", samples: 2 }
  arbiter:
    strategy: best_of_n        # or majority | first | tests_pass
    model:    "anthropic/claude-sonnet-4-6"   # judge (best_of_n only)
  max_latency_ms: 120000

​

Distribuire in sicurezza

• Shadow mode — per una finestra dopo il primo salvataggio, il DSL viene valutato ma non usato: la tua strategia precedente continua a servire il traffico mentre il gateway registra cosa avrebbe fatto il DSL. La dashboard mostra un report di diff — percentuale di route divergenti, delta di costo previsto, conteggi di attivazione per regola e con quale frequenza è caduto su default:. Leggilo prima di fidarti delle regole.
• Canary — porta il DSL su una percentuale di traffico reale (5 → 25 → 50 → 100), osservando le metriche per slice, e fai rollback istantaneo riportando la percentuale a 0.

​

Limiti e validazione

• Schema — chiavi obbligatorie, tipi/enum corretti, nessun campo sconosciuto.
• Dimensione — ≤ 30 regole, ≤ 16 KiB di YAML, ≤ 200 caratteri per when:.
• CEL — fa il parse, supera il type-check rispetto all’ambiente delle variabili, nessun identificatore sconosciuto, e when: deve valutare a un bool.
• Effetto — esattamente una destinazione per blocco use:; tutti i riferimenti model / models / @pool: devono risolvere nel tuo workspace.
• Range dei knob — thinking_budget_tokens ∈ [1024, 64000], temperature ∈ [0, 2], samples ∈ [1, 16].
• Riservati — gli id di regola che iniziano con _ sono riservati; default come id di regola viene rifiutato (usa il blocco default: di primo livello).

​

Un esempio completo

version: 1
rules:
  - id: vision
    when: request.vision
    use: { model: "openai/gpt-4o" }

  - id: cheap_chat
    when: task_class == "chat" && difficulty < 0.3
    use: { delegate: cheapest }

  - id: hard_code
    when: task_class == "code" && difficulty > 0.6
    use:
      model: "anthropic/claude-sonnet-4-6"
      thinking_budget_tokens: 8000
      reason_tag: hard_code

  - id: agent_after_failed_test
    when: agent_state.last_test_failed && agent_state.consecutive_errors >= 2
    use:
      model: "anthropic/claude-sonnet-4-6"
      reason_tag: repair

default:
  delegate: balanced

​

Riferimento API

​

FAQ