[FE feat] Mustache support

docs/design/prompt-runtime-unification/wp-f-playground-mustache/testset.json

@@ -0,0 +1,83 @@
+[
+    {
+        "country": "Vanuatu",
+        "population_thousands": 320,
+        "is_island_nation": true,
+        "geo": {
+            "region": "Pacific Islands",
+            "subregion": "Western Melanesia",
+            "coordinates": {
+                "lat": -15.376,
+                "lng": 166.959
+            }
+        },
+        "languages": ["en", "bi", "fr"],
+        "metadata": "{\"source\":\"trace\",\"trace_id\":\"vu-001\",\"latency_ms\":520,\"confidence\":\"high\"}",
+        "messages": [
+            {
+                "role": "system",
+                "content": "You are a geography research assistant with access to a country lookup tool. Cite ISO codes when available."
+            },
+            {
+                "role": "user",
+                "content": "What is the capital of Vanuatu and its ISO 3166-1 alpha-2 code?"
+            },
+            {
+                "role": "assistant",
+                "content": "Port Vila is the capital of Vanuatu. Its ISO 3166-1 alpha-2 code is VU."
+            }
+        ],
+        "correct_answer": "Port Vila",
+        "notes": "Vanuatu became independent in 1980. Unused-by-default to exercise the unreferenced-columns footer."
+    },
+    {
+        "country": "Kiribati",
+        "population_thousands": 120,
+        "is_island_nation": true,
+        "geo": {
+            "region": "Pacific Islands",
+            "subregion": "Micronesia",
+            "coordinates": {
+                "lat": 1.451,
+                "lng": 172.971
+            }
+        },
+        "languages": ["en", "gil"],
+        "metadata": "{\"source\":\"trace\",\"trace_id\":\"ki-001\",\"latency_ms\":480,\"confidence\":\"high\"}",
+        "messages": [
+            {
+                "role": "system",
+                "content": "You are a geography research assistant with access to a country lookup tool. Cite ISO codes when available."
+            },
+            {
+                "role": "user",
+                "content": "What is the capital of Kiribati?"
+            }
+        ],
+        "correct_answer": "South Tarawa",
+        "notes": "Kiribati straddles the equator and the international date line."
+    },
+    {
+        "country": "Switzerland",
+        "population_thousands": 8700,
+        "is_island_nation": false,
+        "geo": {
+            "region": "Europe",
+            "subregion": "Western Europe",
+            "coordinates": {
+                "lat": 46.818,
+                "lng": 8.227
+            }
+        },
+        "languages": ["de", "fr", "it", "rm"],
+        "metadata": "{\"source\":\"trace\",\"trace_id\":\"ch-001\",\"latency_ms\":410,\"confidence\":\"high\"}",
+        "messages": [
+            {
+                "role": "user",
+                "content": "What is the capital of Switzerland?"
+            }
+        ],
+        "correct_answer": "Bern",
+        "notes": "Switzerland is famous for its political neutrality and four national languages."
+    }
+]

web/packages/agenta-entities/src/runnable/index.ts

@@ -128,10 +128,12 @@ export {
     buildEvaluatorExecutionInputs,
     validateEvaluatorInputs,
     // Template variable extraction
+    extractMustacheSectionOpeners,
     extractTemplateVariables,
     extractTemplateVariablesFromJson,
     extractVariablesFromPrompts,
     extractVariablesFromConfig,
+    extractSectionOpenersFromConfig,
     extractVariablesFromEnhancedPrompts,
 } from "./utils"
 export type {ExecuteRunnableOptions} from "./utils"

web/packages/agenta-entities/src/runnable/portHelpers.ts

@@ -142,11 +142,14 @@ export interface GroupedTemplateVariable {
     /** Display label. Same as `key` under this model. */
     name: string
     /**
-     * Declared shape. `"object"` when any placeholder references a sub-path
-     * of this group (signals the UI to render a JSON editor); otherwise
-     * `"string"`.
+     * Declared shape.
+     *   - `"object"` when any placeholder references a sub-path of this
+     *     group (`{{geo.region}}` → object with `region` sub-path).
+     *   - `"array"` when the name appears ONLY as a mustache section opener
+     *     (`{{#languages}}{{.}}{{/languages}}` → array, no sub-paths).
+     *   - `"string"` otherwise.
      */
-    type: "string" | "object"
+    type: "string" | "object" | "array"
     /**
      * Known sub-paths beneath the group (populated only when `type === "object"`).
      * Used to seed a shape-hint default in the JSON editor so users see
@@ -191,11 +194,35 @@ function parseTemplateExpression(expr: string): ParsedTemplateExpression {
 
     const parseSegments = (segments: string[]): ParsedTemplateExpression => {
         if (segments.length === 0) return {envelope: "inputs", key: ""}
-        if (segments.length === 1) return {envelope: segments[0], key: ""}
+
+        const first = segments[0]
+        const firstIsEnvelope = KNOWN_ENVELOPE_SLOTS.has(first)
+
+        if (segments.length === 1) {
+            // `$.inputs` / `$.outputs` — envelope-only reference.
+            if (firstIsEnvelope) return {envelope: first, key: ""}
+            // `$.profile` — testcase-spread key. Per the RFC, testcase
+            // top-level columns are spread into the render context, so
+            // they live implicitly under the `inputs` envelope. Treating
+            // the first segment as the key under `inputs` keeps port
+            // discovery consistent with envelope-rooted writes.
+            return {envelope: "inputs", key: first}
+        }
+
+        if (firstIsEnvelope) {
+            return {
+                envelope: first,
+                key: segments[1],
+                subPath: segments.length > 2 ? segments.slice(2).join(".") : undefined,
+            }
+        }
+        // Testcase-spread key with a sub-path: `$.profile.name` →
+        // `{envelope: "inputs", key: "profile", subPath: "name"}`. The
+        // testcase spread makes this equivalent to `$.inputs.profile.name`.
         return {
-            envelope: segments[0],
-            key: segments[1],
-            subPath: segments.length > 2 ? segments.slice(2).join(".") : undefined,
+            envelope: "inputs",
+            key: first,
+            subPath: segments.length > 1 ? segments.slice(1).join(".") : undefined,
         }
     }
 
@@ -261,9 +288,33 @@ function parseTemplateExpression(expr: string): ParsedTemplateExpression {
  * `envelope === "inputs"`; other slots are runtime-resolved (backend
  * populates them from trace / workflow config / etc.).
  */
-export function groupTemplateVariables(placeholders: string[]): GroupedTemplateVariable[] {
+export function groupTemplateVariables(
+    placeholders: string[],
+    options?: {
+        /** Set of names that appeared as mustache section openers
+         *  (`{{#name}}` / `{{^name}}`) in the source template. Used to
+         *  refine type inference: a name referenced ONLY as a section
+         *  opener (no sub-paths) gets `type: "array"` — the iteration
+         *  intent is the strongest signal we have without parsing the
+         *  block body. Names with sub-paths stay `"object"` regardless. */
+        sectionOpeners?: Set<string>
+    },
+): GroupedTemplateVariable[] {
     const groups = new Map<string, {envelope: string; key: string; subPaths: Set<string>}>()
 
+    // Resolve section opener names through `parseTemplateExpression` and
+    // key them by envelope-scoped `${envelope}.${key}` ids — same identity
+    // the `groups` map uses below. Otherwise a section opener written as
+    // `{{#languages}}` would coerce BOTH `inputs.languages` AND
+    // `outputs.languages` (if both existed in the same prompt) to `array`.
+    const sectionOpenerIds = new Set<string>()
+    if (options?.sectionOpeners) {
+        for (const opener of options.sectionOpeners) {
+            const parsed = parseTemplateExpression(opener)
+            if (parsed.key) sectionOpenerIds.add(`${parsed.envelope}.${parsed.key}`)
+        }
+    }
+
     for (const placeholder of placeholders) {
         // Invalid envelope references (e.g. `$.input.xx.abc` — `input` is not
         // a known envelope slot) don't get an input control. The prompt
@@ -289,11 +340,20 @@ export function groupTemplateVariables(placeholders: string[]): GroupedTemplateV
 
     return Array.from(groups.values()).map(({envelope, key, subPaths}) => {
         const subPathList = Array.from(subPaths)
+        // Type inference priority:
+        //   1. Sub-paths present → `"object"` (the strongest signal — the
+        //      template addresses specific fields).
+        //   2. Section opener AND no sub-paths → `"array"` (iteration intent).
+        //   3. Otherwise → `"string"`.
+        const groupId = `${envelope}.${key}`
+        const isSectionOpener = sectionOpenerIds.has(groupId)
+        const type: GroupedTemplateVariable["type"] =
+            subPathList.length > 0 ? "object" : isSectionOpener ? "array" : "string"
         return {
             envelope,
             key,
             name: key,
-            type: subPathList.length > 0 ? ("object" as const) : ("string" as const),
+            type,
             ...(subPathList.length > 0 ? {subPaths: subPathList} : {}),
         }
     })