@sweny-ai/core 0.1.99 → 0.1.100

package/dist/claude.d.ts

@@ -74,6 +74,26 @@ export declare class ClaudeClient implements Claude {
  * `"42"`) from a tool that returned the string "42" (wrapper also sends
  * `"42"`). Preserving the string is safer than guessing.
  */
+/**
+ * Build the prompt used by `ClaudeClient.evaluate()` to pick a routing edge.
+ *
+ * Extracted as a pure function so the prompt body can be unit tested without
+ * spinning up an SDK query. The body is part of the routing contract: workflow
+ * authors and downstream maintainers rely on the model leaning on structured
+ * fields rather than prose narrative when picking an edge, especially in the
+ * fallback case where a source node did not declare an `output` schema (the
+ * executor's schema-strict filter only kicks in when a schema is present;
+ * see `buildRouteEvalEntry` in executor.ts).
+ *
+ * Any change to this prompt should keep:
+ *   - The three "Evaluation rules" pointing the model at structured fields
+ *     and away from prose narrative.
+ *   - A terminal directive to return ONLY the choice ID.
+ */
+export declare function buildEvaluatePrompt(question: string, context: Record<string, unknown>, choices: {
+    id: string;
+    description: string;
+}[]): string;
 export declare function parseToolResultContent(content: unknown): unknown;
 /**
  * Produce a short, single-line description of a tool-error payload suitable

package/dist/claude.js

@@ -214,13 +214,7 @@ export class ClaudeClient {
     }
     async evaluate(opts) {
         const { question, context, choices } = opts;
-        const choiceList = choices.map((c) => `- "${c.id}": ${c.description}`).join("\n");
-        const prompt = [
-            question,
-            `\nContext:\n\`\`\`json\n${JSON.stringify(context, null, 2)}\n\`\`\``,
-            `\nChoices:\n${choiceList}`,
-            `\nRespond with ONLY the choice ID, nothing else.`,
-        ].join("\n");
+        const prompt = buildEvaluatePrompt(question, context, choices);
         const env = this.buildEnv();
         let response = "";
         try {
@@ -351,6 +345,35 @@ function coreToolToSdkTool(coreTool, defaultCtx) {
  * `"42"`) from a tool that returned the string "42" (wrapper also sends
  * `"42"`). Preserving the string is safer than guessing.
  */
+/**
+ * Build the prompt used by `ClaudeClient.evaluate()` to pick a routing edge.
+ *
+ * Extracted as a pure function so the prompt body can be unit tested without
+ * spinning up an SDK query. The body is part of the routing contract: workflow
+ * authors and downstream maintainers rely on the model leaning on structured
+ * fields rather than prose narrative when picking an edge, especially in the
+ * fallback case where a source node did not declare an `output` schema (the
+ * executor's schema-strict filter only kicks in when a schema is present;
+ * see `buildRouteEvalEntry` in executor.ts).
+ *
+ * Any change to this prompt should keep:
+ *   - The three "Evaluation rules" pointing the model at structured fields
+ *     and away from prose narrative.
+ *   - A terminal directive to return ONLY the choice ID.
+ */
+export function buildEvaluatePrompt(question, context, choices) {
+    const choiceList = choices.map((c) => `- "${c.id}": ${c.description}`).join("\n");
+    return [
+        question,
+        `\nContext:\n\`\`\`json\n${JSON.stringify(context, null, 2)}\n\`\`\``,
+        `\nChoices:\n${choiceList}`,
+        `\nEvaluation rules:`,
+        `1. Read each choice's condition literally and match against the structured fields in the context (e.g. status, counts, enum values, boolean flags).`,
+        `2. Ignore prose narrative fields ("summary", free-form rationale, conversational commentary). They are not the contract.`,
+        `3. When a field's value contradicts what a prose field claims, trust the field's value.`,
+        `\nRespond with ONLY the choice ID, nothing else.`,
+    ].join("\n");
+}
 export function parseToolResultContent(content) {
     if (typeof content !== "string")
         return content;

package/dist/executor.js

@@ -315,6 +315,73 @@ function buildPriorNodeContext(result) {
     // Spread evals first so a data-side `evals` key shadows it (back-compat).
     return { evals: evalsByName, ...data };
 }
+/**
+ * Build the prior-node entry shown to the LLM route evaluator.
+ *
+ * Differs from `buildPriorNodeContext` (which feeds downstream node `run()`
+ * calls) in one way: when the source node declared an `output` schema with
+ * a `properties` block, the data view is restricted to those declared
+ * properties. The `evals` namespace is always preserved when present.
+ *
+ * Why this exists. The route evaluator is a natural-language model. Anything
+ * it sees in the context can sway the decision, including prose narrative
+ * fields like the always-injected `summary` from the reference Claude
+ * client (claude.ts: `data: { summary: response, ...parsed }`). Real-world
+ * symptom: a node correctly emits `status: "pass"` but also adds a
+ * conversational `summary` like "the quality_retry_count is 1", and the
+ * evaluator pattern-matches the retry mention to flip the routing decision.
+ *
+ * The fix is to treat the `output` schema as the routing contract. If the
+ * author declared which fields matter, only those reach the route
+ * evaluator. When no schema is declared we fall back to the full data
+ * (back-compat for workflows without structured outputs).
+ *
+ * The downstream node prompt is untouched: nodes still see the full prior
+ * `data` including any prose `summary`, so workflows that consume the
+ * narrative in subsequent steps keep working.
+ */
+function buildRouteEvalEntry(result, sourceNode) {
+    const fullData = (result.data ?? {});
+    const declaredProps = getDeclaredOutputProperties(sourceNode?.output);
+    const dataView = declaredProps ? pickKeys(fullData, declaredProps) : fullData;
+    const evals = result.evals ?? [];
+    if (evals.length === 0)
+        return dataView;
+    const evalsByName = {};
+    for (const e of evals) {
+        evalsByName[e.name] = e;
+    }
+    // Spread evals first so a data-side `evals` key shadows it (back-compat).
+    return { evals: evalsByName, ...dataView };
+}
+/**
+ * Return the declared output property names for a node, or null when the
+ * node has no `output` schema or its schema does not declare a `properties`
+ * block. Null signals "no contract" and routing falls back to the full
+ * data view.
+ *
+ * Tolerant of malformed schemas because `output` is `JSONSchema =
+ * Record<string, unknown>` and is not parsed further by the executor.
+ */
+function getDeclaredOutputProperties(output) {
+    if (!output || typeof output !== "object")
+        return null;
+    const props = output.properties;
+    if (!props || typeof props !== "object")
+        return null;
+    const keys = Object.keys(props);
+    if (keys.length === 0)
+        return null;
+    return new Set(keys);
+}
+function pickKeys(obj, keys) {
+    const out = {};
+    for (const k of keys) {
+        if (k in obj)
+            out[k] = obj[k];
+    }
+    return out;
+}
 function nodeSourcesToArray(ns) {
     if (!ns)
         return { sources: [], only: false };
@@ -512,9 +579,16 @@ async function resolveNext(workflow, current, results, input, claude, observer,
     // Claude evaluates which condition matches. Include input so conditions
     // can reference workflow-level flags like dryRun, and expose evals so
     // routing edges can read `priorNode.evals.X.pass`.
+    //
+    // Crucial difference from the run() context: when a prior node declared
+    // an `output` schema, the routing view of its data is restricted to the
+    // declared properties. Without this, non-schema fields (notably the
+    // always-injected `summary` prose from the reference Claude client) can
+    // sway the natural-language route evaluator and override the actual
+    // structured result. See `buildRouteEvalEntry` for the full rationale.
     const context = {
         input,
-        ...Object.fromEntries([...results.entries()].map(([k, v]) => [k, buildPriorNodeContext(v)])),
+        ...Object.fromEntries([...results.entries()].map(([k, v]) => [k, buildRouteEvalEntry(v, workflow.nodes[k])])),
     };
     const choices = conditionalEdges.map((e) => ({
         id: e.to,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.99",
+  "version": "0.1.100",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"