callman-core 1.20.0 → 1.22.0

package/dist/ai/prompts/diagram.js

@@ -0,0 +1,132 @@
+// Prompt builders for the diagram-studio assistant. Mirrors the unified prompt
+// pattern (system = rules + output shape, user = context + instruction) but the
+// model produces a whole DiagramDocument instead of contract/script changes.
+//
+// The DiagramDocument schema itself lives in the desktop app
+// (features/diagram-studio/model/schema.ts) — it is described here in prose so
+// the model emits the right shape; the client runs the authoritative validator
+// (safeParseDiagramDocument) before applying anything to the canvas.
+export const buildDiagramSystemPrompt = () => [
+    "You are a STAFF-level software/systems architect and domain expert embedded in a visual",
+    "diagram studio. You have deep, practical knowledge of real production systems across",
+    "domains (fintech/investing, e-commerce, payments, streaming, IoT, ML, SaaS, etc.). From",
+    "the user's instruction plus the CONTEXT below, YOU produce a diagram. Respond with ONE",
+    "JSON object ONLY (no markdown, no prose outside JSON), shaped:",
+    "",
+    '{"reply": string, "diagram": <DiagramDocument> | null}',
+    "",
+    "DiagramDocument shape:",
+    "{",
+    '  "schemaVersion": 1,',
+    '  "id": string,                       // keep the existing id on edits; a short id when creating',
+    '  "meta": {"title": string},          // a concise diagram title',
+    '  "nodes": [{',
+    '    "id": string,                     // stable + unique; REUSE existing ids on edits',
+    '    "type": string,                   // MUST be one of AVAILABLE COMPONENT TYPES below',
+    '    "position": {"x": number, "y": number},',
+    '    "size": {"width": number, "height": number},',
+    '    "label": string,                  // short, clear',
+    '    "rotation": number,               // optional; degrees clockwise 0-359 (omit or 0 = upright)',
+    '    "style": {                        // ALL fields optional',
+    '      "fill": {"raw":"#RRGGBB"}, "stroke": {"raw":"#RRGGBB"}, "textColor": {"raw":"#RRGGBB"},',
+    '      "strokeWidth": number, "radius": number, "dashed": boolean, "opacity": number,          // opacity 0-100',
+    '      "fontSize": number, "fontFamily": string, "fontStyle": number,                          // fontStyle BITMASK: bold=1|italic=2|underline=4',
+    '      "align": "left"|"center"|"right", "verticalAlign": "top"|"middle"|"bottom", "shadow": boolean',
+    "    },",
+    '    "parentId": string                // optional: id of a container/group/pool node',
+    "  }],",
+    '  "edges": [{',
+    '    "id": string,',
+    '    "source": string,                 // an existing node id',
+    '    "target": string,                 // an existing node id',
+    '    "label": string,                  // optional edge label',
+    '    "routing": "orthogonal"|"straight"|"curved",  // optional (default orthogonal)',
+    '    "markerEnd": "classicThin"|"classic"|"none"    // optional arrowhead',
+    "  }]",
+    "}",
+    "",
+    "RULES:",
+    "- Use ONLY `type` values from AVAILABLE COMPONENT TYPES. When unsure, fall back to a",
+    "  generic shape: `rect`, `flow.process`, `flow.decision`, `flow.terminator`, `cylinder`.",
+    "- Every node needs a short, meaningful `label` and a sensible `size` (e.g. 140x64).",
+    '- COLORS in `style` MUST be objects: `{"raw": "#ff0000"}` (a hex string wrapped in',
+    '  `{"raw": ...}`), NEVER a bare string like `"#ff0000"`. Applies to fill/stroke/textColor.',
+    "- STYLING (all `style` fields optional; use TASTEFULLY — clarity over decoration): you may set",
+    "  strokeWidth, radius (rounded corners), dashed, opacity (0-100), fontSize, fontFamily,",
+    "  fontStyle, align, verticalAlign, and shadow to emphasize structure. `fontStyle` is a BITMASK:",
+    "  bold=1, italic=2, underline=4 — combine by ADDING (bold+italic = 3). A node's `rotation` is",
+    "  degrees clockwise; only rotate when it genuinely helps (a rotated label/arrow) — keep primary",
+    "  shapes upright. Default to NO extra styling unless it improves readability.",
+    "- Every edge's `source` and `target` MUST reference a node `id` that exists in `nodes`.",
+    "- Positions need not be exact — the app auto-lays-out the result — but still give rough,",
+    "  non-overlapping coordinates (step nodes down/right so nothing stacks at 0,0).",
+    "- CREATE mode: build the whole diagram from scratch.",
+    "- EDIT mode: return the COMPLETE updated document. REUSE the ids of existing nodes/edges",
+    "  and KEEP their `position` unless the user asked to move them; only add, remove, or",
+    "  change what the instruction implies. Never drop unrelated nodes/edges.",
+    "- EDIT mode — EDGES: copy every UNCHANGED edge VERBATIM. Keep its id, source, target AND",
+    "  every field already on it (including routing, waypoints, sourceAnchor, targetAnchor)",
+    "  EXACTLY as given — do NOT re-route, re-point, reorder, or strip routing fields. Only touch",
+    "  the specific edge(s) the instruction is about, and add new edges only for genuinely new",
+    "  connections. This preserves the existing tidy layout instead of scrambling every edge.",
+    "- If the message is a question or implies no change → `diagram` null, `reply` only.",
+    "- `reply` is ALWAYS a short, natural sentence: what you built or changed (or the answer).",
+    "",
+    "DEPTH & DOMAIN EXPERTISE (this is what separates a good diagram from a toy one):",
+    "- Before emitting, THINK like a senior engineer designing this system for real. Enumerate",
+    "  the components a production-grade version of THIS specific domain actually needs — the",
+    "  end-to-end flows, the supporting services, the data stores, and the cross-cutting concerns",
+    "  (auth/identity, caching, queues/streaming, observability, external/third-party integrations).",
+    "- Be COMPREHENSIVE, not minimal. A vague ask like \"design an X platform\" should yield a",
+    "  realistic architecture (typically ~10-20 nodes), NOT 4-5 generic boxes. Cover the whole",
+    "  lifecycle, not just the happy path.",
+    "- Example of the expected depth — \"design an event-driven investment platform\" should include",
+    "  things a real one has: client apps, API gateway, auth/identity (OAuth/OIDC), user",
+    "  onboarding/KYC, account & funding/payments, an order/trade service, an execution/broker",
+    "  integration (e.g. a third-party like DriveWealth), a market-data / real-time price feed,",
+    "  portfolio & positions, a ledger, a notification service, an event bus / streaming (Kafka),",
+    "  primary DB(s), a cache (Redis), and observability. Apply the SAME rigor to any domain.",
+    "- Prefer SPECIFIC catalog components over generic rectangles when they fit (e.g. an API",
+    "  gateway, message queue/Kafka, Redis cache, a concrete database like Postgres/MongoDB, an",
+    "  auth provider) — pick the closest matching `type` from AVAILABLE COMPONENT TYPES.",
+    "- Organize for readability: group related components under a container/frame or pool",
+    "  (`frame`, `pool.horizontal`/`pool.vertical`) via `parentId`, and give edges meaningful",
+    "  labels for the real interaction (e.g. \"Place order\", \"Stream quotes\", \"Publish event\").",
+    "- Only trim when the user explicitly asks for something simple/high-level.",
+    "",
+    "GROUPS / CONTAINERS (how nesting works here):",
+    "- To group nodes, add ONE container node (`type` = `frame`, `pool.horizontal`, or",
+    "  `pool.vertical`) with a title `label`, then set each member node's `parentId` to that",
+    "  container's `id`. The container must appear in `nodes` too.",
+    "- The app AUTO-LAYS-OUT children INSIDE the container and AUTO-SIZES the container to fit",
+    "  them — so you do NOT need exact child positions or a correct container size. Just declare",
+    "  the parentId relationships and give each child a normal node `size` (e.g. 150x60). Do not",
+    "  try to hand-pack children into a box; let the layout do it.",
+    "- Edges may connect a child to a node outside its container, or to the container itself.",
+].join("\n");
+export const buildDiagramUserPrompt = ({ instruction, mode, document, components = [], selection = [], canvas, }) => {
+    const componentLines = components.length
+        ? components.map((c) => `${c.type} — ${c.label} (${c.category})`).join("\n")
+        : "(none provided — use generic shapes)";
+    const documentBlock = mode === "edit" && document ? JSON.stringify(document) : "(none — creating a new diagram)";
+    const canvasLine = canvas && (canvas.width || canvas.height)
+        ? `CANVAS SIZE: ${Math.round(canvas.width ?? 0)} x ${Math.round(canvas.height ?? 0)}`
+        : null;
+    return [
+        `MODE: ${mode}`,
+        canvasLine,
+        "",
+        "AVAILABLE COMPONENT TYPES (type — label (category)):",
+        componentLines,
+        "",
+        "CURRENT DIAGRAM (edit mode; full document JSON):",
+        documentBlock,
+        "",
+        `SELECTED CELL IDS: ${selection.length ? selection.join(", ") : "(none)"}`,
+        "",
+        `INSTRUCTION: ${instruction}`,
+    ]
+        .filter((line) => line !== null)
+        .join("\n");
+};
+//# sourceMappingURL=diagram.js.map

package/dist/ai/prompts/diagram.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagram.js","sourceRoot":"","sources":["../../../src/ai/prompts/diagram.ts"],"names":[],"mappings":"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"}

package/dist/ai/prompts/fragments.d.ts

@@ -0,0 +1,5 @@
+import type { AiScriptStage } from "../types.js";
+export declare const CONTRACT_RULES_SPEC: string;
+export declare const STAGE_DESCRIPTIONS: Record<AiScriptStage, string>;
+export declare const truncateForPrompt: (value: string, max?: number) => string;
+//# sourceMappingURL=fragments.d.ts.map

package/dist/ai/prompts/fragments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragments.d.ts","sourceRoot":"","sources":["../../../src/ai/prompts/fragments.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,eAAO,MAAM,mBAAmB,QAQpB,CAAC;AAIb,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAS5D,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,OAAO,MAAM,EAAE,YAAQ,KAAG,MACJ,CAAC"}

package/dist/ai/prompts/fragments.js

@@ -0,0 +1,27 @@
+// Shared prompt fragments consumed by more than one assistant prompt (and by
+// the backend's legacy contract-only prompt). Single source — the backend and
+// desktop copies of these constants were duplicated and had already drifted
+// before centralization.
+import { SCENARIO_CONTRACT_FORMATS } from "../../contract/formats.js";
+// Terse operator vocabulary the model must stick to. Kept compact on purpose —
+// it's the bulk of the system prompt and we pay tokens for every word. Mirrors
+// ContractRuleRules so the output maps 1:1 onto a rule.
+export const CONTRACT_RULES_SPEC = [
+    "Each rule's `rules` object may use ONLY these keys (omit the rest):",
+    "- common: required(bool), type(string|number|boolean|object|array|null), equals(string|number|bool), notEmpty(bool)",
+    "- number: min,max,greaterThan,lessThan(number); integer,positive,negative,nonZero(bool)",
+    "- string: minLength,maxLength(int); pattern,contains,notContains,startsWith,endsWith(string); caseSensitive(bool); enumValues(array); format(enum)",
+    "- array: minItems,maxItems(int); sorted({order:asc|desc,field?}); unique({mode:whole|byField,fields?})",
+    "- object: requiredKeys,forbiddenKeys(string[]); minProperties,maxProperties(int); strictSchema(bool)",
+    `- format values: ${SCENARIO_CONTRACT_FORMATS.join(", ")}`,
+].join("\n");
+// What each request-script slot means + which pm.* surface it exposes. Fed to
+// the model so it knows, e.g., that pm.response does not exist pre-request.
+export const STAGE_DESCRIPTIONS = {
+    "pre-request": "Runs BEFORE the HTTP call. `pm.response` does NOT exist. `pm.request` mutations (setHeader/setQueryParam/setRawBody/setUrl) take effect. Use for setup: auth tokens, computed headers/body, seeding env/DB/Redis.",
+    "post-response": "Runs immediately AFTER the response. `pm.response` is available; `pm.request` mutations have no effect. Use to capture values from the response into variables.",
+    tests: "Runs after the response and any declared DB/Redis steps. `pm.response`, `pm.db.post`, `pm.redis.results.post` are available. Put assertions inside `pm.test(...)`.",
+    kafka: "Runs when a Kafka event is matched (post-response/tests context). `pm.response` and `pm.kafka.event()` / `pm.kafka.messages()` are available. Put assertions inside `pm.test(...)`.",
+};
+export const truncateForPrompt = (value, max = 80) => value.length > max ? `${value.slice(0, max)}…` : value;
+//# sourceMappingURL=fragments.js.map

package/dist/ai/prompts/fragments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragments.js","sourceRoot":"","sources":["../../../src/ai/prompts/fragments.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,8EAA8E;AAC9E,4EAA4E;AAC5E,yBAAyB;AAEzB,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAGtE,+EAA+E;AAC/E,+EAA+E;AAC/E,wDAAwD;AACxD,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,qEAAqE;IACrE,qHAAqH;IACrH,yFAAyF;IACzF,oJAAoJ;IACpJ,wGAAwG;IACxG,sGAAsG;IACtG,oBAAoB,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;CAC3D,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb,8EAA8E;AAC9E,4EAA4E;AAC5E,MAAM,CAAC,MAAM,kBAAkB,GAAkC;IAC/D,aAAa,EACX,mNAAmN;IACrN,eAAe,EACb,iKAAiK;IACnK,KAAK,EACH,oKAAoK;IACtK,KAAK,EACH,qLAAqL;CACxL,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,KAAa,EAAE,GAAG,GAAG,EAAE,EAAU,EAAE,CACnE,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC"}

package/dist/ai/prompts/scenario.d.ts

@@ -0,0 +1,12 @@
+import type { ScenarioPromptInput } from "../types.js";
+export declare const SCENARIO_AI_REFERENCE_TYPES: readonly ["request", "db", "redis", "kafka", "condition", "assertion", "script", "set-vars", "poll", "foreach", "websocket", "ai", "wait", "notification", "aggregator", "end"];
+export interface BuildScenarioSystemPromptOptions {
+    /**
+     * Canonical default config per node type shown in the reference. Hosts with
+     * a real node factory (desktop) inject it; default = core's static map.
+     */
+    defaultConfigFor?: (type: string) => unknown;
+}
+export declare const buildScenarioSystemPrompt: (options?: BuildScenarioSystemPromptOptions) => string;
+export declare const buildScenarioUserPrompt: (input: ScenarioPromptInput) => string;
+//# sourceMappingURL=scenario.d.ts.map

package/dist/ai/prompts/scenario.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenario.d.ts","sourceRoot":"","sources":["../../../src/ai/prompts/scenario.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAMvD,eAAO,MAAM,2BAA2B,iLAiB9B,CAAC;AAwCX,MAAM,WAAW,gCAAgC;IAC/C;;;OAGG;IACH,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CAC9C;AAqBD,eAAO,MAAM,yBAAyB,GACpC,UAAS,gCAAqC,KAC7C,MAwFW,CAAC;AAEf,eAAO,MAAM,uBAAuB,GAAI,OAAO,mBAAmB,KAAG,MA+CpE,CAAC"}

package/dist/ai/prompts/scenario.js

@@ -0,0 +1,204 @@
+// Prompt builders for the scenario-builder assistant. Canonical source —
+// ported from the desktop (which was the only copy while generation was
+// local-CLI-only); backend's hosted /ai/scenario-generate consumes it too.
+//
+// The system prompt teaches the whole Scenario JSON contract + every node
+// type's config syntax; the user prompt carries the dynamic context
+// (connections by name, importable requests, the current document for edits).
+//
+// The per-node "canonical default config" blocks come from `defaultConfigFor`:
+// hosts with a real node factory (desktop `createScenarioNode`) inject it so
+// the prompt can never drift from what the app actually accepts; hosts without
+// one (backend) fall back to core's `SCENARIO_NODE_DEFAULT_CONFIGS`, which a
+// desktop drift-guard test keeps honest.
+import { REDIS_COMMAND_SPECS } from "../../host/redis/redisService.js";
+import { renderDbQueryReference } from "../../host/db/db-query-reference.js";
+import { defaultScenarioNodeConfig } from "./scenarioNodeDefaults.js";
+// Types shown in the reference. `subscenario` + `scenario-ref` are intentionally
+// omitted — they are advanced/nested and `scenario-ref` can't be spawned blank;
+// the model is told to avoid them.
+export const SCENARIO_AI_REFERENCE_TYPES = [
+    "request",
+    "db",
+    "redis",
+    "kafka",
+    "condition",
+    "assertion",
+    "script",
+    "set-vars",
+    "poll",
+    "foreach",
+    "websocket",
+    "ai",
+    "wait",
+    "notification",
+    "aggregator",
+    "end",
+];
+// Per-type intent + EVERY mode/variant the model needs to know (which fields are
+// required in each mode). Kept in step with the node executors and the desktop's
+// getScenarioNodeValidationMessage. The default JSON below each note shows the
+// base shape; the note explains the alternatives.
+const NODE_NOTES = {
+    request: "HTTP call. REQUIRED: url. PREFER a saved request: set data.importRequestId to its id (from AVAILABLE REQUESTS) and the app fills method/url/headers/body/auth/scripts — only hand-write config when no saved request fits. MODES: body.mode = \"none\" | \"raw\" (set body.raw, body.rawLanguage \"json\"|\"xml\"|\"text\") | \"formdata\"|\"urlencoded\" (use body.formEntries:[{key,value,enabled:true}]). In formdata a row can be a multipart FILE part: {key, type:\"file\", fixtureId, fileName, localPath} — fixtureId references an uploaded workspace fixture file (REQUIRED for server runs), localPath is an absolute path on the user's machine (used by desktop-local runs). NEVER invent fixtureId or localPath values; emit the row with type:\"file\" and leave both unset so the user attaches the file in the builder. auth.type = \"none\" | \"bearer\" (auth.bearerToken) | \"basic\" (auth.basicUsername + auth.basicPassword) | \"apikey\" (auth.apiKeyKey + auth.apiKeyValue + auth.apiKeyLocation \"header\"|\"query\"). headers/query are [{key,value,enabled:true}]. Capture outputs in postResponseScript (pm.environment.set('token', pm.response.json().token)). Output: <Label>.status = HTTP status code (number); read RESPONSE BODY fields via <Label>.body.<path> (e.g. <Label>.body.token, <Label>.body.user.name) — NOT the bare <Label>.<field>, which collides with the HTTP metadata (see the response-reading rule). SOAP: for a SOAP call keep body.mode:\"raw\" + rawLanguage:\"xml\" with the full envelope in body.raw and add config.soap = { enabled:true, version:\"1.1\"|\"1.2\", action?:\"urn:Op\" (template-resolved), wsSecurity?:{ enabled, username, password, passwordType:\"text\"|\"digest\" } } — the app derives Content-Type/SOAPAction from the version at send time (a user header row named Content-Type wins) and injects the WS-Security UsernameToken into the XML at send time (never write it into body.raw yourself). CONTRACT ASSERTIONS: config.contractAssertions:[{ id, path, enabled:true, rules }] validate the response; default engine is a dot-path over the parsed body. For XML responses add engine:\"xpath\" + namespaces:{prefix:\"uri\",...} — `path` is then a namespace-aware XPath 1.0 expression over the RAW XML text (e.g. \"//tns:Rate/text()\", \"count(//tns:Rate)\"); every prefix used in the expression MUST appear in `namespaces`.",
+    db: "Query a stored DB connection. REQUIRED: connectionId (type=database) + query. The `query` STRING format depends on the connection type — see the DB & REDIS NODE QUERY FORMAT section (Mongo = JSON command-object string; SQL = plain SQL, incl. SQL Server T-SQL). Optional `params` array binds positional SQL placeholders — $1 (Postgres), ? (MySQL), @p1..@pN (SQL Server). Output: <Label>.rows (array) + <Label>.rowCount.",
+    redis: 
+    // Supported command list is derived from the runtime specs so it can
+    // never drift from what the runtime actually accepts.
+    `Run Redis commands on a stored connection. REQUIRED: connectionId (type=redis) + ≥1 non-empty entry in \`commands\`. Each entry is ONE command string; supported commands: ${Object.keys(REDIS_COMMAND_SPECS).join(", ")} — e.g. "GET order:{{CreateOrder.orderId}}", "HGETALL user:{{env.userId}}" or "SET key {{env.value}}". SCAN is Callman-managed: \`SCAN pattern [count]\` returns {keys,count,truncated}. Output exposed under the label + as redis.result.`,
+    kafka: "Consume OR publish (config.mode). CONSUME (mode:\"consume\"): REQUIRED connectionId (type=kafka) + topic + a matcher with ≥1 non-empty rule. TWO matchModes: (a) matchMode:\"regex\" → rules[0] is a single REGEX tested against the whole message, e.g. rules:[\"order.created\"]. (b) matchMode:\"rules\" → rules is a LIST OF EXPRESSIONS (expert-condition syntax), ALL must be true. Reference the captured event as kafkaEvent.<field>: for a JSON message its JSON keys are top-level, e.g. rules:[\"kafkaEvent.event == 'order.created'\", \"kafkaEvent.orderId == '{{CreateOrder.orderId}}'\"]. NEVER leave rules empty. PUBLISH (mode:\"publish\"): REQUIRED connectionId + topic + messageValue; optional messageKey, publishValueFormat \"json\"|\"raw\" (json validates the payload as JSON), messageHeaders:[{key,value,enabled:true}].",
+    condition: "The ONLY branching node and the ONLY node WITHOUT executionPolicy. Must have EXACTLY one outgoing edge type \"yes\" and one \"no\". TWO modes: mode:\"builder\" (default) uses rootGroup { operator:\"AND\"|\"OR\", children:[ rule | nested group ] } where each rule is { id, type:\"rule\", left, operator, right } (operands per the OPERANDS section); mode:\"expert\" uses expertExpression, a single string like \"response.status == 200 && {Login.token} != ''\". Prefer builder mode.",
+    assertion: "Pass/fail checkpoint (does NOT branch; on failure executionPolicy decides stop/continue). config.matchMode:\"all\" (every enabled check passes) | \"any\" (≥1 passes). checks:[{ id, name, enabled:true, rule }] with ≥1 enabled check — each rule is { left, operator, right } (operands per the OPERANDS section).",
+    script: "JS sandbox (Postman pm.*). REQUIRED: non-empty, syntactically-valid `script`; its `return` value is exposed downstream by the node label. Optional timeoutMs (default 3000). Can pm.environment.set(...), pm.expect(...), pm.test(...), and await pm.db.query / pm.redis.command (same formats as the DB & REDIS section) for logic a plain db/redis node can't express.",
+    "set-vars": "No-code variable capture — prefer this over a script node for plain \"save X into a variable\" steps. config.assignments:[{ id, scope:\"environment\"|\"global\", key, value, enabled:true }] applied top-to-bottom (a later row can use an earlier row's variable). DEFAULT (template) row: `value` is template-resolved, e.g. \"{{CreateOrder.body.id}}\". EXTRACTOR row: add extractorType:\"jsonpath\"|\"regex\" + source + expression (`value` is then ignored). `source` is a BARE runtime dot-path WITHOUT braces (same semantics as condition operands), e.g. \"CreateOrder.body\". `expression` is a JSONPath like \"$.items[0].id\" or a JS regex source like \"ord-(\\\\d+)\". Regex rows may add `flags` (subset of \"gimsuy\") and `group` (capture group index, default: first group, else whole match). Optional select:\"first\" (default, writes one value) | \"all\" (writes a JSON array of every match). A failed extraction SKIPS that write and is reported in the node output — it does not fail the node.",
+    poll: "Wait-until: repeats ONE embedded action until a condition passes or the budget runs out — prefer this over wait+loop chains for \"poll until ready\" steps. REQUIRED: actionType:\"request\"|\"db\"|\"redis\"|\"script\" + the MATCHING embedded config object (`request` | `db` | `redis` | `script`, same shape as the standalone node of that type) + successCondition (a full condition config: { mode:\"builder\", rootGroup } — same shape as the condition node, evaluated after EVERY tick against the tick's result, e.g. left { mode:\"runtime\", valueType:\"number\", value:\"response.status\" } for a request action) + intervalMs (delay between ticks, ≤ 3600000). OPTIONAL: maxAttempts (default 30, max 1000), timeoutMs (wall-clock cap, ≤ 86400000), backoffMultiplier (1..10, exponential backoff on the interval), maxDelayMs (backoff cap), onTimeout:\"fail\" (default — normal failure path, error edges apply) | \"continue\" (mark degraded and continue). Action errors are polled through (a failing tick is retried, not fatal); per-node retry is force-disabled — the loop IS the retry. Output: { attempts, maxAttempts, elapsedMs, timedOut, conditionResult, lastTickError? }; the last tick's action result is ALSO published like the standalone node would (response.*, rows, redis.result).",
+    foreach: "Per-item loop container: runs an EMBEDDED body graph once per item of an array — the go-to node for \"do X for every user/order/row\". config = { nodes:[...], edges:[...], sourceMode:\"path\"|\"inline\", itemsPath?, itemsInline?, itemAlias?, maxIterations? (default 100, max 1000), delayMs? (pause between items, ms), onItemFailure:\"stop\" (default; first failed item fails this node) | \"continue\" (failed items degrade to partial success, loop keeps going), collectResults?:true }. ITEMS SOURCE: sourceMode:\"path\" + itemsPath = a BARE runtime dot-path WITHOUT braces resolving to an array (e.g. \"Users.body.items\" — or, inside an outer foreach, a path off the outer item/alias like \"customer.accounts\"); sourceMode:\"inline\" + itemsInline = a JSON array STRING ({{tokens}} inside resolve first). BODY: config.nodes/config.edges form a normal mini-graph (same node shapes, ids unique, EVERY label unique across the WHOLE scenario incl. all bodies; conditions still need exactly one yes + one no edge; do NOT add end nodes inside the body). PER-ITERATION TEMPLATE ROOTS available to body nodes: {{item}} = current item ({{item.id}}, {{item.name}}...), the alias root when itemAlias is set (e.g. itemAlias:\"user\" → {{user.id}} — set one whenever foreaches nest, the inner {{item}} shadows the outer), {{each.index}} (0-based), {{each.iteration}} (1-based), {{each.total}}, {{each.remaining}}, and {{eaches.<ThisForeachLabel>.iteration}} etc. for reaching an OUTER foreach's counters from inside an inner one. The same roots work as bare condition/assertion operand paths (item.tier, each.total). NESTING: a foreach node may appear inside another foreach's body (source the inner items from the outer item, e.g. itemsPath:\"customer.accounts\" with itemAlias:\"account\"). OUTPUT: { results:[ per-item snapshots — results[i].<ChildLabel>.body..., a failed item's child carries only results[i].<ChildLabel>.__meta.failed:true ], itemCount, processedCount, truncated, failedItems } — downstream nodes read e.g. <Label>.processedCount or <Label>.results[0].<ChildLabel>.body.id. Per-node retry is force-disabled (the item loop IS the repeat); with onItemFailure:\"continue\" a run with failed items ends completed-with-failures by design.",
+    websocket: "Live socket conversation as ONE scenario step: connect, run the steps in order, close. config = { url (ws:// or wss://, template-resolved), headers:[{key,value,enabled:true}], subprotocols:[string], connectTimeoutMs?, steps:[...], closeCode?, rejectUnauthorized?:false to accept self-signed TLS }. STEPS (ordered): { id, kind:\"send\", payload } sends one text frame (payload template-resolved; JSON payloads welcome); { id, kind:\"expect\", timeoutMs? (default 10000, max 300000), matchMode?:\"all\"|\"any\", rules:[ConditionRule,...] } waits for a frame matching the rules — each rule is the SAME { id, type:\"rule\", left, operator, right } shape as condition/assertion rules, with runtime paths over the CURRENT FRAME roots: ws.text (raw text), ws.json.<field> (parsed JSON), ws.direction, ws.index. Example rule: left { mode:\"runtime\", valueType:\"string\", value:\"ws.json.event\" }, operator:\"equals\", right { mode:\"literal\", valueType:\"string\", value:\"subscribed\" }; { id, kind:\"wait\", durationMs } pauses. A failed expect (timeout) fails the node — error edges / executionPolicy apply; retry re-runs the WHOLE conversation. Output: { connected, messages:[{text, direction, ...}], steps, closeCode, messageCount, failedSteps } — downstream reads <Label>.messages[0].text or bare paths like <Label>.messageCount in conditions.",
+    ai: "One LLM chat call as a step — create ONLY if a type=ai connection is available (managed AI connections). REQUIRED: connectionId (type=ai) + prompt (template-resolved, may embed {{Label.body.field}} references) + responseExample (a JSON OBJECT string describing the reply shape, e.g. \"{\\\"sentiment\\\":\\\"positive\\\",\\\"score\\\":0.9}\" — top-level keys become REQUIRED in the reply, extra keys allowed). Optional maxTokens (1..32000), timeoutMs (1000..300000). The parsed JSON reply IS the node output: downstream nodes read <Label>.<exampleKey> (e.g. <Label>.sentiment) in templates and condition operands.",
+    wait: "Delay. durationMs milliseconds (1 .. 2147483647). Output: { configuredDurationMs, actualDurationMs, status }.",
+    notification: "Slack only — create ONLY if a type=notification (provider=slack) connection is available. REQUIRED: connectionId + messageTemplate. provider:\"slack\", severity:\"info\"|\"success\"|\"warning\"|\"error\", optional channelOverride, advanced.useRichBlocks.",
+    aggregator: "Merges upstream outputs into one JSON object. config.template MUST be valid JSON once tokens are filled, e.g. {\"userId\":\"{Login.data.id}\",\"total\":\"{CreateOrder.total}\"}. Output = the resolved object.",
+    end: "Terminator. Needs ≥1 incoming edge. Default loop:false. To loop: loop:true + loopTargetNodeId (an earlier node id) + loopIterations (1..1000) + loopDelayMs (0..600000).",
+};
+const buildNodeReference = (defaultConfigFor) => SCENARIO_AI_REFERENCE_TYPES.map((type) => {
+    let config = null;
+    try {
+        config = defaultConfigFor(type);
+    }
+    catch {
+        config = null;
+    }
+    const note = NODE_NOTES[type] ?? "";
+    return [
+        `### type: "${type}"`,
+        note,
+        "canonical default config (fill/override the fields you need):",
+        "```json",
+        JSON.stringify(config, null, 2),
+        "```",
+    ].join("\n");
+}).join("\n\n");
+export const buildScenarioSystemPrompt = (options = {}) => [
+    "You are the scenario builder assistant for an API testing app. You design COMPLETE, ready-to-run API test scenarios as a directed graph of nodes and edges. The user runs the result once and it should just work — so every node must be fully configured, with valid syntax.",
+    "",
+    "Reply with ONE JSON object and NOTHING else (no prose, no markdown fences):",
+    "```",
+    JSON.stringify({
+        reply: "one or two sentences: what you built + which default/placeholder values the user must replace with real values",
+        scenario: {
+            name: "optional — a short scenario name",
+            description: "optional",
+            nodes: [
+                {
+                    id: "n1",
+                    type: "request",
+                    position: { x: 0, y: 0 },
+                    data: { label: "Login", config: {} },
+                },
+            ],
+            edges: [{ id: "e1", source: "n1", target: "n2", type: "default" }],
+            environments: [
+                {
+                    id: "env1",
+                    name: "Default",
+                    variables: [{ id: "v1", key: "baseUrl", value: "https://api.example.com", enabled: true }],
+                },
+            ],
+        },
+    }, null, 2),
+    "```",
+    'Set "scenario" to null when you are only replying or asking a clarifying question.',
+    "",
+    "NODE ENVELOPE — every node is:",
+    '{ "id": string (unique), "type": <one below>, "position": { "x": number, "y": number }, "data": { "label": string, "config": { ... } } }',
+    "- `label` is REQUIRED, non-empty, UNIQUE across the scenario, and must NOT be \"workflow\" or \"__meta\". Downstream nodes read a node's output by its label: {{Login.data.token}}.",
+    "- Every config EXCEPT `condition` carries an `executionPolicy` object (see defaults below).",
+    "- position: the app AUTO-ARRANGES the whole graph (top-to-bottom flow, branches fanned out side-by-side, centered, never overlapping), so layout is NOT your concern — just give each node any distinct {x,y} (e.g. step y by 150). Focus on correct edges + config, not coordinates. Model the flow by EDGES (branches, merges), not by stacking every node in one long line.",
+    "",
+    "EDGES — { \"id\": string, \"source\": <node id>, \"target\": <node id>, \"type\"?: \"default\" | \"yes\" | \"no\" }.",
+    "- Omit `type` (or use \"default\") for normal flow.",
+    "- \"yes\"/\"no\" are ONLY used on the two edges leaving a `condition` node.",
+    "",
+    "GRAPH RULES (a scenario that breaks these is rejected):",
+    "- Exactly ONE start node (a node with no incoming edge).",
+    "- No cycles (except an `end` node's explicit loop).",
+    "- A `condition` node needs exactly one \"yes\" and one \"no\" outgoing edge.",
+    "- An `end` node needs ≥1 incoming edge.",
+    "- Fill each node's REQUIRED fields (see notes per type).",
+    "",
+    "TEMPLATING — chain data between nodes:",
+    "- {{env.KEY}} / {{KEY}} — environment/global variables.",
+    "- {{Label.field}} or {Label.field} — a prior node's output by its label. Array indices are concrete: items[0].id (no wildcards).",
+    "- Generators: {{$randomUUID}}, {{$timestamp}}, {{$randomEmail}}.",
+    "- request nodes: capture with postResponseScript, e.g. \"pm.environment.set('token', pm.response.json().token)\".",
+    "",
+    "READING A REQUEST'S RESPONSE (IMPORTANT — avoid the status collision):",
+    "- A request node exposes the HTTP status as a NUMBER at `<Label>.status` (e.g. 200/201). It also spreads the JSON body's top-level keys, BUT the reserved keys `status`, `data`, `body`, `headers`, `text`, `cookies`, `statusText`, `durationMs` are the HTTP metadata and OVERRIDE any same-named body field.",
+    "- So to read a RESPONSE BODY field, ALWAYS go through `.body`: `<Label>.body.<path>` — e.g. `Login.body.token`, `CreateOrder.body.status`, `CreateOrder.body.total`, `GetUser.body.user.name`. This is collision-proof: `CreateOrder.body.status` is the body's status (\"created\"), while `CreateOrder.status` is the HTTP status (201).",
+    "- If the API wraps its payload in a top-level `data` object, `<Label>.data.<path>` also works. For DB nodes use `<Label>.rows[0].<col>`; for Kafka use `kafkaEvent.<field>`; for Redis use `redis.result`.",
+    "",
+    "ASSERTION / CONDITION OPERANDS — how comparisons are structured (each check's `rule` has `left`, `operator`, optional `right`; each operand is { mode, valueType, value }):",
+    "- To reference a prior node's output, use `mode:\"runtime\"` and set `value` to a BARE dotted path WITHOUT braces — e.g. \"CreateOrder.body.total\", \"CheckDb.rows[0].status\", \"Login.status\". NEVER put {{ }} or { } inside a condition/assertion operand. For a request's RESPONSE BODY field use the `.body.` path (see the response-reading rule above).",
+    "- Use `mode:\"literal\"` ONLY for constants. When `valueType:\"number\"` the `value` MUST be a real number (40, not \"40\" and not a template); `valueType:\"boolean\"` → true/false; otherwise `valueType:\"string\"`.",
+    "- Numeric example — “the order total is 40”: left { mode:\"runtime\", valueType:\"number\", value:\"CreateOrder.body.total\" }, operator:\"equals\", right { mode:\"literal\", valueType:\"number\", value:40 }.",
+    "- Text example — “the order body status is created”: left { mode:\"runtime\", valueType:\"string\", value:\"CreateOrder.body.status\" }, operator:\"equals\", right { mode:\"literal\", valueType:\"string\", value:\"created\" }.",
+    "- Operators: equals, not_equals, strict_equals, strict_not_equals, greater_than, less_than, greater_or_equal, less_or_equal, between (right = array of 2 numbers), contains, not_contains, starts_with, ends_with, regex, in, not_in (right = array). UNARY (no right operand): exists, not_exists, is_empty, not_empty, is_null, not_null.",
+    "- Optional operand `extract` — { type:\"jsonpath\"|\"regex\", expression, flags?, group?, select?:\"first\"|\"all\" } — applied to the RESOLVED operand value before valueType coercion. Use it when a dotted path can't reach the value (JSONPath filters/wildcards, or pulling a fragment out of a string). Example: left { mode:\"runtime\", valueType:\"string\", value:\"CreateOrder.body\", extract:{ type:\"jsonpath\", expression:\"$.items[?(@.sku=='A1')].id\" } }. Regex: expression is a JS regex source (e.g. \"ord-(\\\\d+)\"), optional flags (subset of \"gimsuy\") and group (capture group index). select:\"all\" yields an array of every match. A failed extraction behaves as not-exists.",
+    "",
+    "CONNECTIONS — never invent ids. Use a connectionId ONLY from the AVAILABLE CONNECTIONS list in the user message (matching the node's type: db→database, redis→redis, kafka→kafka, notification→slack). If the needed connection isn't listed, still create the node with connectionId \"\" and tell the user in `reply` to pick a connection.",
+    "",
+    "SAVED REQUESTS — when the user references one of their requests, add a request node with data.importRequestId set to that request's id (from AVAILABLE REQUESTS); the app fills its full config. Do not copy headers/body yourself.",
+    "",
+    "ENVIRONMENTS & DEFAULTS — where a real value is unknown (base URL, credentials, ids), create an environment variable with a clearly-placeholder value and reference it via {{env.KEY}}, then tell the user in `reply` to replace the placeholders. Prefer this over hard-coding fake values inline.",
+    "",
+    "Avoid `subscenario` and `scenario-ref` node types.",
+    "",
+    "=== NODE TYPES & SYNTAX ===",
+    buildNodeReference(options.defaultConfigFor ?? defaultScenarioNodeConfig),
+    "",
+    "=== DB & REDIS NODE QUERY FORMAT (authoritative — follow EXACTLY) ===",
+    "For a `db` node, `config.query` is ONLY the query string itself: for MongoDB the JSON.stringify(...) CONTENT (a command object), for SQL the plain SQL text. Do NOT write the surrounding `pm.db.query(...)` / `await` JS shown in the examples below — that only illustrates the shape. Never use mongo-shell syntax like `db.orders.find(...)`. For a `redis` node, each entry of `config.commands[]` is one command string. {{tokens}} inside are resolved before running, so embed {{Label.field}} / {{env.X}} directly.",
+    "MongoDB db node — set config.query to a JSON string like: {\"collection\":\"orders\",\"operation\":\"findOne\",\"filter\":{\"orderId\":\"{{CreateOrder.orderId}}\"}}  — the result rows are exposed under the node's label as <Label>.rows, so an assertion reads e.g. the runtime path CheckDb.rows[0].status (NOT CheckDb.result.rows...).",
+    "",
+    renderDbQueryReference(),
+].join("\n");
+export const buildScenarioUserPrompt = (input) => {
+    const { instruction, mode, document, context, selection } = input;
+    const lines = [];
+    lines.push(mode === "edit" ? "MODE: edit (extend/modify the current scenario)" : "MODE: create (new scenario)");
+    lines.push("");
+    if (context.connections.length > 0) {
+        lines.push("AVAILABLE CONNECTIONS (use the id, never a secret):");
+        for (const c of context.connections) {
+            lines.push(`- id=${c.id} · name="${c.name}" · type=${c.type} · provider=${c.provider}`);
+        }
+    }
+    else {
+        lines.push("AVAILABLE CONNECTIONS: (none configured — leave connectionId \"\" and tell the user to add one)");
+    }
+    lines.push("");
+    if (context.requests.length > 0) {
+        lines.push("AVAILABLE REQUESTS (reference by importRequestId to reuse a saved request):");
+        for (const r of context.requests) {
+            lines.push(`- id=${r.id} · "${r.collectionName} / ${r.name}" · ${r.method} ${r.url}`);
+        }
+    }
+    else {
+        lines.push("AVAILABLE REQUESTS: (none — build request nodes from scratch)");
+    }
+    lines.push("");
+    if (mode === "edit" && document) {
+        lines.push("CURRENT SCENARIO (JSON — keep existing node ids/labels/positions unless changing them, and return the WHOLE updated scenario):");
+        lines.push("```json");
+        lines.push(JSON.stringify({ name: document.name, nodes: document.nodes, edges: document.edges, environments: document.environments ?? [] }, null, 2));
+        lines.push("```");
+        if (selection && selection.length > 0) {
+            lines.push(`SELECTED NODE IDS: ${selection.join(", ")}`);
+        }
+        lines.push("");
+    }
+    lines.push("USER REQUEST:");
+    lines.push(instruction);
+    return lines.join("\n");
+};
+//# sourceMappingURL=scenario.js.map

package/dist/ai/prompts/scenario.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenario.js","sourceRoot":"","sources":["../../../src/ai/prompts/scenario.ts"],"names":[],"mappings":"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"}

package/dist/ai/prompts/scenarioNodeDefaults.d.ts

@@ -0,0 +1,3 @@
+export declare const SCENARIO_NODE_DEFAULT_CONFIGS: Record<string, unknown>;
+export declare const defaultScenarioNodeConfig: (type: string) => unknown;
+//# sourceMappingURL=scenarioNodeDefaults.d.ts.map

package/dist/ai/prompts/scenarioNodeDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenarioNodeDefaults.d.ts","sourceRoot":"","sources":["../../../src/ai/prompts/scenarioNodeDefaults.ts"],"names":[],"mappings":"AAsDA,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAkHjE,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAI,MAAM,MAAM,KAAG,OACZ,CAAC"}

package/dist/ai/prompts/scenarioNodeDefaults.js

@@ -0,0 +1,166 @@
+// Canonical per-type default configs for the scenario-builder assistant's node
+// reference. Mirrors what the desktop's `createScenarioNode` factory produces
+// (with STABLE placeholder ids where the factory generates UUIDs — stable ids
+// read better in a prompt). The desktop passes its real factory into
+// `buildScenarioSystemPrompt({ defaultConfigFor })` so the in-app prompt can
+// never drift; a desktop drift-guard test asserts this map matches the factory
+// (ids normalized). The backend — which has no node factory — uses this map.
+const STRICT_POLICY = {
+    onFailure: "stop",
+    retry: { enabled: false, maxAttempts: 0, delayMs: 0 },
+};
+const REQUEST_CONFIG = {
+    method: "GET",
+    url: "",
+    headers: [],
+    query: [],
+    body: { mode: "none", raw: "", formEntries: [] },
+    auth: {
+        type: "none",
+        bearerToken: "",
+        basicUsername: "",
+        basicPassword: "",
+        apiKeyKey: "",
+        apiKeyValue: "",
+        apiKeyLocation: "header",
+    },
+    preRequestScript: "",
+    postResponseScript: "",
+    testsScript: "",
+    contractAssertions: [],
+    executionPolicy: STRICT_POLICY,
+};
+const DEFAULT_CONDITION_CONFIG = {
+    mode: "builder",
+    rootGroup: {
+        id: "g1",
+        type: "group",
+        operator: "AND",
+        children: [
+            {
+                id: "r1",
+                type: "rule",
+                left: { mode: "runtime", valueType: "number", value: "response.status" },
+                operator: "equals",
+                right: { mode: "literal", valueType: "number", value: 200 },
+            },
+        ],
+    },
+    expertExpression: "{{response.status}} == 200",
+};
+export const SCENARIO_NODE_DEFAULT_CONFIGS = {
+    request: REQUEST_CONFIG,
+    db: {
+        connectionId: "",
+        query: "SELECT *\nFROM users\nWHERE id = {{env.userId}}",
+        executionPolicy: STRICT_POLICY,
+    },
+    redis: {
+        connectionId: "",
+        commands: [],
+        executionPolicy: {
+            onFailure: "continue",
+            retry: { enabled: true, maxAttempts: 2, delayMs: 1000 },
+        },
+    },
+    kafka: {
+        connectionId: "",
+        topic: "",
+        mode: "consume",
+        matchMode: "regex",
+        rules: [],
+        publishValueFormat: "json",
+        messageKey: "",
+        messageValue: "",
+        messageHeaders: [],
+        executionPolicy: {
+            onFailure: "continue",
+            retry: { enabled: true, maxAttempts: 3, delayMs: 2000 },
+        },
+    },
+    condition: DEFAULT_CONDITION_CONFIG,
+    assertion: {
+        matchMode: "all",
+        checks: [
+            {
+                id: "c1",
+                name: "",
+                enabled: true,
+                rule: {
+                    id: "cr1",
+                    type: "rule",
+                    left: { mode: "runtime", valueType: "string", value: "" },
+                    operator: "equals",
+                    right: { mode: "runtime", valueType: "string", value: "" },
+                },
+            },
+        ],
+        executionPolicy: STRICT_POLICY,
+    },
+    script: {
+        script: "return {\n  ok: true,\n};",
+        timeoutMs: 3000,
+        executionPolicy: STRICT_POLICY,
+    },
+    "set-vars": {
+        assignments: [{ id: "a1", scope: "environment", key: "", value: "", enabled: true }],
+        executionPolicy: STRICT_POLICY,
+    },
+    poll: {
+        actionType: "request",
+        request: REQUEST_CONFIG,
+        successCondition: DEFAULT_CONDITION_CONFIG,
+        intervalMs: 2000,
+        maxAttempts: 30,
+        onTimeout: "fail",
+        executionPolicy: STRICT_POLICY,
+    },
+    foreach: {
+        nodes: [],
+        edges: [],
+        sourceMode: "path",
+        onItemFailure: "stop",
+        collectResults: true,
+        executionPolicy: STRICT_POLICY,
+    },
+    websocket: {
+        url: "",
+        headers: [],
+        subprotocols: [],
+        steps: [],
+        executionPolicy: STRICT_POLICY,
+    },
+    ai: {
+        connectionId: "",
+        prompt: "",
+        responseExample: "",
+        executionPolicy: STRICT_POLICY,
+    },
+    wait: { durationMs: 5000, executionPolicy: STRICT_POLICY },
+    notification: {
+        provider: "slack",
+        connectionId: "",
+        severity: "info",
+        messageTemplate: "Scenario {{workflow.name}} finished with status {{workflow.__meta.status}}.",
+        channelOverride: "",
+        continueOnFailure: true,
+        advanced: { useRichBlocks: true },
+        executionPolicy: {
+            onFailure: "continue",
+            retry: { enabled: false, maxAttempts: 0, delayMs: 0 },
+        },
+    },
+    aggregator: {
+        template: '{\n  "key": "{Label.field}"\n}',
+        executionPolicy: STRICT_POLICY,
+    },
+    end: {
+        loop: false,
+        loopTargetNodeId: null,
+        loopIterations: 1,
+        loopDelayMs: 1000,
+        executionPolicy: STRICT_POLICY,
+    },
+};
+export const defaultScenarioNodeConfig = (type) => SCENARIO_NODE_DEFAULT_CONFIGS[type] ?? null;
+//# sourceMappingURL=scenarioNodeDefaults.js.map