@sweny-ai/core 0.1.84 → 0.1.86

package/dist/schema.js

@@ -90,7 +90,9 @@ export const outputMatchZ = z
     const operators = [m.equals !== undefined, m.in !== undefined, m.matches !== undefined];
     return operators.filter(Boolean).length === 1;
 }, { message: "output_matches entry must declare exactly one of: equals, in, matches" });
-export const nodeVerifyZ = z
+export const evaluatorKindZ = z.enum(["value", "function", "judge"]);
+export const evalPolicyZ = z.enum(["all_pass", "any_pass", "weighted"]);
+export const evaluatorRuleZ = z
     .object({
     any_tool_called: z.array(z.string().min(1)).min(1).optional(),
     all_tools_called: z.array(z.string().min(1)).min(1).optional(),
@@ -98,18 +100,71 @@ export const nodeVerifyZ = z
     output_required: z.array(z.string().min(1)).min(1).optional(),
     output_matches: z.array(outputMatchZ).min(1).optional(),
 })
-    // Fix #4 gap: the exported JSON Schema sets additionalProperties: false.
-    // Without .strict() here Zod would silently drop unknown keys and then
-    // the refine would run on the stripped object, producing a different
-    // verdict than ajv (which rejects the unknown key directly). Keep them
-    // in sync.
     .strict()
-    .refine((v) => v.any_tool_called !== undefined ||
-    v.all_tools_called !== undefined ||
-    v.no_tool_called !== undefined ||
-    v.output_required !== undefined ||
-    v.output_matches !== undefined, {
-    message: "verify must declare at least one check (any_tool_called, all_tools_called, no_tool_called, output_required, or output_matches)",
+    .refine((r) => r.any_tool_called !== undefined ||
+    r.all_tools_called !== undefined ||
+    r.no_tool_called !== undefined ||
+    r.output_required !== undefined ||
+    r.output_matches !== undefined, {
+    message: "evaluator rule must declare at least one of: any_tool_called, all_tools_called, no_tool_called, output_required, output_matches",
+});
+/**
+ * A single evaluator. The `kind` field discriminates required-fields:
+ * `value` and `function` need `rule`; `judge` needs `rubric`.
+ *
+ * Strict object: unknown keys are rejected to match the public JSON Schema.
+ */
+export const evaluatorZ = z
+    .object({
+    name: z.string().min(1),
+    kind: evaluatorKindZ,
+    rule: evaluatorRuleZ.optional(),
+    rubric: z.string().min(1).optional(),
+    // `pass_when` is parsed against a single VERDICT token from the model's
+    // response (default `yes`). Whitespace breaks the prompt format and the
+    // verdict comparison, so reject it at parse time rather than producing
+    // a confusing runtime mismatch.
+    pass_when: z
+        .string()
+        .min(1)
+        .refine((v) => !/\s/.test(v), { message: "pass_when must be a single whitespace-free token" })
+        .optional(),
+    model: z.string().min(1).optional(),
+})
+    .strict()
+    .superRefine((e, ctx) => {
+    if (e.kind === "value" || e.kind === "function") {
+        if (!e.rule) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `evaluator '${e.name}' (kind: ${e.kind}) must declare a rule`,
+                path: ["rule"],
+            });
+        }
+        if (e.rubric !== undefined || e.pass_when !== undefined || e.model !== undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `evaluator '${e.name}' (kind: ${e.kind}) must not declare rubric / pass_when / model (those are 'judge' only)`,
+                path: [],
+            });
+        }
+    }
+    else if (e.kind === "judge") {
+        if (!e.rubric) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `evaluator '${e.name}' (kind: judge) must declare a rubric`,
+                path: ["rubric"],
+            });
+        }
+        if (e.rule !== undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `evaluator '${e.name}' (kind: judge) must not declare a rule`,
+                path: ["rule"],
+            });
+        }
+    }
 });
 export const nodeRequiresZ = z
     .object({
@@ -138,7 +193,9 @@ export const nodeZ = z
     max_turns: z.number().int().min(1).optional(),
     rules: nodeSourcesZ.optional(),
     context: nodeSourcesZ.optional(),
-    verify: nodeVerifyZ.optional(),
+    eval: z.array(evaluatorZ).min(1).optional(),
+    eval_policy: evalPolicyZ.optional(),
+    judge_model: z.string().min(1).optional(),
     requires: nodeRequiresZ.optional(),
     retry: nodeRetryZ.optional(),
 })
@@ -167,9 +224,41 @@ export const workflowZ = z.object({
     skills: z.record(skillDefinitionZ).default({}),
     rules: z.array(sourceZ).optional(),
     context: z.array(sourceZ).optional(),
+    judge_model: z.string().min(1).optional(),
+    judge_budget: z.number().int().min(0).optional(),
 });
+const LEGACY_VERIFY_MESSAGE = "uses the legacy 'verify:' field. It was renamed to 'eval:' in @sweny-ai/core v0.2.0 with a different shape (named evaluators with kind: value | function | judge). " +
+    "Migration guide: https://spec.sweny.ai/nodes/#eval";
+/**
+ * Detect legacy `verify:` blocks before parse and throw a clear migration
+ * error. Without this preflight, the user gets Zod's generic "Unrecognized
+ * key(s)" message at the node level (and silent passthrough at the
+ * workflow level, since workflowZ allows extra top-level fields for
+ * marketplace metadata).
+ *
+ * Catches:
+ *   - Top-level `workflow.verify` (typo / wrong scope).
+ *   - Per-node `nodes[*].verify` (the most common shape pre-rename).
+ */
+function preflightLegacyVerify(raw) {
+    if (!raw || typeof raw !== "object")
+        return;
+    const wf = raw;
+    if ("verify" in wf) {
+        throw new Error(`Workflow ${LEGACY_VERIFY_MESSAGE}`);
+    }
+    const nodes = wf.nodes;
+    if (!nodes || typeof nodes !== "object")
+        return;
+    for (const [id, node] of Object.entries(nodes)) {
+        if (node && typeof node === "object" && "verify" in node) {
+            throw new Error(`Node "${id}" ${LEGACY_VERIFY_MESSAGE}`);
+        }
+    }
+}
 /** Parse + validate a raw object as a Workflow. Throws on invalid input. */
 export function parseWorkflow(raw) {
+    preflightLegacyVerify(raw);
     return workflowZ.parse(raw);
 }
 /**
@@ -353,7 +442,7 @@ export const workflowJsonSchema = {
     required: ["id", "name", "nodes", "edges", "entry"],
     // Top-level is intentionally open: marketplace workflows carry extra
     // metadata (author, category, tags) that publish.ts reads. Inner
-    // objects (nodes, edges, skills, verify, requires, etc.) are strict.
+    // objects (nodes, edges, skills, eval, requires, etc.) are strict.
     additionalProperties: true,
     $defs: {
         Source: sourceJsonSchema,
@@ -371,6 +460,70 @@ export const workflowJsonSchema = {
                 },
             ],
         },
+        OutputMatch: {
+            type: "object",
+            required: ["path"],
+            additionalProperties: false,
+            properties: {
+                path: { type: "string", minLength: 1 },
+                equals: {},
+                in: { type: "array" },
+                matches: { type: "string", minLength: 1 },
+            },
+            oneOf: [{ required: ["equals"] }, { required: ["in"] }, { required: ["matches"] }],
+        },
+        Evaluator: {
+            type: "object",
+            required: ["name", "kind"],
+            additionalProperties: false,
+            properties: {
+                name: {
+                    type: "string",
+                    minLength: 1,
+                    description: "Stable identifier for this evaluator. Used in EvalResult and retry preambles.",
+                },
+                kind: { type: "string", enum: ["value", "function", "judge"] },
+                rule: {
+                    type: "object",
+                    description: "Required for value and function kinds. Shape depends on kind.",
+                    additionalProperties: false,
+                    minProperties: 1,
+                    properties: {
+                        any_tool_called: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
+                        all_tools_called: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
+                        no_tool_called: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
+                        output_required: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
+                        output_matches: { type: "array", items: { $ref: "#/$defs/OutputMatch" }, minItems: 1 },
+                    },
+                },
+                rubric: {
+                    type: "string",
+                    minLength: 1,
+                    description: "Required for judge kind. Natural-language criterion the judge model evaluates.",
+                },
+                pass_when: {
+                    type: "string",
+                    minLength: 1,
+                    default: "yes",
+                    description: "judge only. Verdict token that indicates pass. Default 'yes'.",
+                },
+                model: {
+                    type: "string",
+                    minLength: 1,
+                    description: "judge only. Override the judge model for this evaluator.",
+                },
+            },
+            allOf: [
+                {
+                    if: { properties: { kind: { enum: ["value", "function"] } } },
+                    then: { required: ["rule"] },
+                },
+                {
+                    if: { properties: { kind: { const: "judge" } } },
+                    then: { required: ["rubric"] },
+                },
+            ],
+        },
     },
     properties: {
         id: { type: "string", minLength: 1 },
@@ -387,6 +540,18 @@ export const workflowJsonSchema = {
             items: { $ref: "#/$defs/Source" },
             description: "Background knowledge prepended to every node's instruction.",
         },
+        judge_model: {
+            type: "string",
+            minLength: 1,
+            default: "claude-haiku-4-5",
+            description: "Default model for judge evaluators across the workflow. Overridable per-node and per-evaluator.",
+        },
+        judge_budget: {
+            type: "integer",
+            minimum: 0,
+            default: 50,
+            description: "Soft cap on expected judge calls per workflow run. Executor warns at load time if exceeded; not a hard runtime cap in v1.",
+        },
         nodes: {
             type: "object",
             additionalProperties: {
@@ -418,42 +583,29 @@ export const workflowJsonSchema = {
                         $ref: "#/$defs/NodeSources",
                         description: "Per-node context. Additive by default; set { only: true } to block cascade.",
                     },
-                    verify: {
-                        type: "object",
-                        description: "Machine-checked post-conditions evaluated after the LLM finishes.",
-                        additionalProperties: false,
-                        // Fix #4: at least one check must be declared.
-                        minProperties: 1,
-                        properties: {
-                            any_tool_called: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
-                            all_tools_called: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
-                            no_tool_called: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
-                            output_required: { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 },
-                            output_matches: {
-                                type: "array",
-                                items: {
-                                    type: "object",
-                                    required: ["path"],
-                                    additionalProperties: false,
-                                    properties: {
-                                        path: { type: "string", minLength: 1 },
-                                        equals: {},
-                                        in: { type: "array" },
-                                        matches: { type: "string", minLength: 1 },
-                                    },
-                                    // Fix #4: exactly one operator must be declared.
-                                    oneOf: [{ required: ["equals"] }, { required: ["in"] }, { required: ["matches"] }],
-                                },
-                                minItems: 1,
-                            },
-                        },
+                    eval: {
+                        type: "array",
+                        description: "Named evaluators (value, function, judge) run after the LLM finishes the node.",
+                        items: { $ref: "#/$defs/Evaluator" },
+                        minItems: 1,
+                    },
+                    eval_policy: {
+                        type: "string",
+                        enum: ["all_pass", "any_pass", "weighted"],
+                        default: "all_pass",
+                        description: "How evaluator results aggregate. v1 implements all_pass; the others are reserved.",
+                    },
+                    judge_model: {
+                        type: "string",
+                        minLength: 1,
+                        description: "Default model for judge evaluators on this node. Overrides workflow-level judge_model.",
                     },
                     requires: {
                         type: "object",
                         description: "Pre-condition checks evaluated before the LLM runs.",
                         additionalProperties: false,
                         // Fix #4: at least one of output_required / output_matches must be declared.
-                        // on_fail alone is not sufficient — it only tags how a failing check behaves.
+                        // on_fail alone is not sufficient. It only tags how a failing check behaves.
                         anyOf: [{ required: ["output_required"] }, { required: ["output_matches"] }],
                         properties: {
                             output_required: {
@@ -463,19 +615,7 @@ export const workflowJsonSchema = {
                             },
                             output_matches: {
                                 type: "array",
-                                items: {
-                                    type: "object",
-                                    required: ["path"],
-                                    additionalProperties: false,
-                                    properties: {
-                                        path: { type: "string", minLength: 1 },
-                                        equals: {},
-                                        in: { type: "array" },
-                                        matches: { type: "string", minLength: 1 },
-                                    },
-                                    // Fix #4: exactly one operator must be declared.
-                                    oneOf: [{ required: ["equals"] }, { required: ["in"] }, { required: ["matches"] }],
-                                },
+                                items: { $ref: "#/$defs/OutputMatch" },
                                 minItems: 1,
                             },
                             on_fail: { type: "string", enum: ["fail", "skip"] },
@@ -483,7 +623,7 @@ export const workflowJsonSchema = {
                     },
                     retry: {
                         type: "object",
-                        description: "Node-local retry on verify failure.",
+                        description: "Node-local retry on eval failure.",
                         required: ["max"],
                         additionalProperties: false,
                         properties: {
@@ -519,11 +659,11 @@ export const workflowJsonSchema = {
                 properties: {
                     from: { type: "string", minLength: 1 },
                     to: { type: "string", minLength: 1 },
-                    when: { type: "string", description: "Natural language condition — Claude evaluates at runtime" },
+                    when: { type: "string", description: "Natural language condition. Claude evaluates at runtime." },
                     max_iterations: {
                         type: "integer",
                         minimum: 1,
-                        description: "Max times this edge can be followed — enables controlled retry loops",
+                        description: "Max times this edge can be followed. Enables controlled retry loops.",
                     },
                 },
             },

package/dist/skills/index.js

@@ -192,7 +192,7 @@ export function buildToolAliases(skills, logger) {
     for (const [name, claimers] of mcpClaims) {
         if (claimers.length > 1) {
             ambiguous.add(name);
-            logger?.warn(`Tool alias "${name}" is declared by multiple skills (${claimers.join(", ")}); dropping from verify alias table to avoid cross-provider false positives.`);
+            logger?.warn(`Tool alias "${name}" is declared by multiple skills (${claimers.join(", ")}); dropping from eval alias table to avoid cross-provider false positives.`);
         }
     }
     // Second pass: union-find over the remaining pairs.

package/dist/types.d.ts

@@ -37,20 +37,20 @@ export interface Skill {
     /** External MCP server definition wired for nodes referencing this skill. */
     mcp?: McpServerConfig;
     /**
-     * Tool-name aliases recognized by `verify`.
+     * Tool-name aliases recognized by `function` evaluators.
      *
      * When a workflow references `any_tool_called: [linear_create_issue]` and
      * the agent instead calls the equivalent MCP tool exposed by this skill's
      * MCP server (e.g. `save_issue` on Linear's remote MCP), the two names
      * should count as equivalent. Each skill owns the mapping for its own
-     * domain — core stays vendor-neutral.
+     * domain. Core stays vendor-neutral.
      *
      * Key: a canonical tool name (usually one of this skill's `tools[].name`,
      * but any name the skill wants to equate is valid).
      * Value: list of equivalent names, typically tool names exposed by this
      * skill's external MCP server.
      *
-     * Aliases are symmetric: a verify rule naming either side matches a call
+     * Aliases are symmetric: a function rule naming either side matches a call
      * on either side. Omit names that are ambiguous across providers
      * (e.g. `get_issue` is exposed by both Linear and GitHub MCP servers).
      */
@@ -68,30 +68,74 @@ export type NodeSources = _Source[] | {
     only?: boolean;
     sources: _Source[];
 };
+/** Kind of evaluator. See {@link Evaluator}. */
+export type EvaluatorKind = "value" | "function" | "judge";
+/** Aggregation policy for a node's evaluator results. v1 implements `all_pass`. */
+export type EvalPolicy = "all_pass" | "any_pass" | "weighted";
 /**
- * Machine-checked post-condition for a node.
+ * The deterministic rule body for a `value` or `function` evaluator.
  *
- * Evaluated by the executor AFTER the LLM finishes. If any declared check
- * fails, the node is marked `failed` even if the LLM itself returned success.
- *
- * All declared checks are AND-ed. The executor runs every check (no fast-fail)
- * and concatenates failures into a single error string on `result.data.error`.
- *
- * Keep the shape small and declarative. Anything richer should be a skill or
- * a dedicated workflow node, not a verify clause.
+ * `value` rules use `output_required` and `output_matches` (data-shape).
+ * `function` rules use `any_tool_called` / `all_tools_called` / `no_tool_called`
+ * (trace-shape). Mixing the two on a single rule is allowed for compactness
+ * but discouraged: a single evaluator should test a single thing.
  */
-export interface NodeVerify {
-    /** At least one of these tools was called and succeeded during this node. */
+export interface EvaluatorRule {
+    /** At least one of these tools was called and succeeded. (`function` rules.) */
     any_tool_called?: string[];
-    /** Every named tool was called and succeeded at least once during this node. */
+    /** Every named tool was called and succeeded at least once. (`function` rules.) */
     all_tools_called?: string[];
-    /** None of these tools may have been invoked during this node. */
+    /** None of these tools may have been invoked. (`function` rules.) */
     no_tool_called?: string[];
-    /** Listed paths must be present and non-null in `result.data` (see Path resolution in the spec). */
+    /** Listed paths must be present and non-null in `result.data`. (`value` rules.) */
     output_required?: string[];
-    /** Each assertion must hold against `result.data`. */
+    /** Each assertion must hold against `result.data`. (`value` rules.) */
     output_matches?: OutputMatch[];
 }
+/**
+ * A single evaluator on a node.
+ *
+ * - `value` and `function` use `rule`.
+ * - `judge` uses `rubric` (and optional `pass_when`, `model`).
+ *
+ * Each evaluator produces an {@link EvalResult}. The executor aggregates
+ * the results per the node's `eval_policy` (default `all_pass`).
+ */
+export interface Evaluator {
+    /** Stable identifier. Used in EvalResult and retry preambles. */
+    name: string;
+    /** Discriminator. Determines which fields apply. */
+    kind: EvaluatorKind;
+    /** Required for `value` / `function`. */
+    rule?: EvaluatorRule;
+    /** Required for `judge`. Natural-language criterion. */
+    rubric?: string;
+    /** `judge` only. Verdict token that indicates pass. Default: `"yes"`. */
+    pass_when?: string;
+    /** `judge` only. Override the judge model for this evaluator. */
+    model?: string;
+}
+/**
+ * Per-evaluator result.
+ *
+ * The executor produces one EvalResult per declared evaluator. The list
+ * lands on {@link NodeResult.evals}.
+ */
+export interface EvalResult {
+    /** Echoes the evaluator's name. */
+    name: string;
+    /** Echoes the evaluator's kind. */
+    kind: EvaluatorKind;
+    /** Whether this evaluator passed. */
+    pass: boolean;
+    /**
+     * Failure detail for value/function (formatted by the executor) or judge
+     * (returned by the model). Capped at ~500 characters when emitted.
+     */
+    reasoning?: string;
+    /** Reserved for `weighted` policies. Not populated in v1. */
+    score?: number;
+}
 /**
  * Machine-checked pre-condition for a node.
  *
@@ -102,7 +146,7 @@ export interface NodeVerify {
  * Path roots resolve against the cross-node context map:
  *   { input: <runtime input>, [priorNodeId]: <data of prior node>, ... }
  *
- * Reuses the same path grammar as `verify` (dotted segments, `[*]` wildcard,
+ * Reuses the same path grammar as `eval` (dotted segments, `[*]` wildcard,
  * optional `all:`/`any:` prefix).
  */
 export interface NodeRequires {
@@ -114,15 +158,15 @@ export interface NodeRequires {
     on_fail?: "fail" | "skip";
 }
 /**
- * Node-local retry on verify failure.
+ * Node-local retry on eval failure.
  *
  * Re-runs the LLM up to `max` additional times, prepending feedback derived
- * from the verify failure. Triggered ONLY by verify failure — not by tool/API
- * errors and not by `requires` failure.
+ * from the failing evaluators. Triggered ONLY by eval failure, not by tool
+ * / API errors and not by `requires` failure.
  *
  * `instruction` shapes the feedback preamble:
- *   - omitted        → default "## Previous attempt failed verification..."
- *   - string         → static text + verify error
+ *   - omitted        → default "## Previous attempt failed evaluation..."
+ *   - string         → static text + structured eval failure list
  *   - { auto: true } → LLM-generated diagnosis from default reflection prompt
  *   - { reflect: s } → LLM-generated diagnosis from author-provided prompt
  */
@@ -167,23 +211,27 @@ export interface Node {
     rules?: NodeSources;
     /** Per-node background knowledge. Additive by default; set `{ only: true, sources: [...] }` to block cascade. */
     context?: NodeSources;
-    /** Machine-checked post-conditions. Enforced by the executor after the LLM finishes. */
-    verify?: NodeVerify;
+    /** Named evaluators run after the LLM finishes. Each produces an {@link EvalResult}. */
+    eval?: Evaluator[];
+    /** How evaluator results aggregate. Default `all_pass`. v1 implements only `all_pass`. */
+    eval_policy?: EvalPolicy;
+    /** Default model for judge evaluators on this node. Overrides workflow-level `judge_model`. */
+    judge_model?: string;
     /** Machine-checked pre-conditions. Enforced by the executor before the LLM runs. */
     requires?: NodeRequires;
-    /** Node-local retry on verify failure (with optional autonomous reflection). */
+    /** Node-local retry on eval failure (with optional autonomous reflection). */
     retry?: NodeRetry;
 }
 /** An edge connecting two nodes */
 export interface Edge {
     from: string;
     to: string;
-    /** Natural language condition — Claude evaluates at runtime */
+    /** Natural language condition. Claude evaluates at runtime. */
     when?: string;
     /** Max times this edge can be followed (enables retry loops). Default: unlimited. */
     max_iterations?: number;
 }
-/** A complete workflow definition — pure data, fully serializable */
+/** A complete workflow definition. Pure data, fully serializable. */
 export interface Workflow {
     id: string;
     name: string;
@@ -196,6 +244,10 @@ export interface Workflow {
     rules?: _Source[];
     /** Background knowledge prepended to every node's instruction. Cascade into per-node context. */
     context?: _Source[];
+    /** Default model for judge evaluators across the workflow. Overridable per-node and per-evaluator. */
+    judge_model?: string;
+    /** Soft cap on expected judge calls per workflow run. Warning at load time when exceeded. */
+    judge_budget?: number;
 }
 /**
  * Inline skill definition in a workflow's `skills` block.
@@ -215,6 +267,12 @@ export interface NodeResult {
     data: Record<string, unknown>;
     /** Tool calls made during this node's execution */
     toolCalls: ToolCall[];
+    /**
+     * Per-evaluator results from `node.eval` (one entry per declared evaluator,
+     * in declaration order). Absent when the node has no `eval` block or when
+     * eval was not run (e.g. node failed during execution).
+     */
+    evals?: EvalResult[];
 }
 export interface ToolCall {
     tool: string;
@@ -223,13 +281,13 @@ export interface ToolCall {
     /**
      * Authoritative outcome of the tool invocation.
      *
-     * When present, this is the source of truth for `verify` checks — the
+     * When present, this is the source of truth for `function` evaluators. The
      * output-shape heuristic is a legacy fallback only. Set by the Claude
      * runtime on tool completion: "success" when the tool returned normally,
      * "error" when it threw or the MCP server returned is_error=true.
      *
-     * Absent status indicates a legacy or hand-constructed ToolCall — verify
-     * falls back to inspecting `output` for an `error` key.
+     * Absent status indicates a legacy or hand-constructed ToolCall. Function
+     * evaluators fall back to inspecting `output` for an `error` key.
      */
     status?: "success" | "error";
 }
@@ -334,11 +392,16 @@ export interface Claude {
     }): Promise<string>;
     /**
      * Single-completion free-text query. No tools, no output schema.
-     * Used by the executor to generate retry strategies in autonomous reflection mode.
+     * Used by the executor to generate retry strategies in autonomous reflection mode
+     * and by judge evaluators to score node results against a rubric.
+     *
+     * `model` overrides the client's default for this call. Implementations
+     * SHOULD use it; mocks MAY ignore it.
      */
     ask(opts: {
         instruction: string;
         context: Record<string, unknown>;
+        model?: string;
     }): Promise<string>;
 }
 export interface McpServerConfig {