jev-recipes 0.2.0 → 0.3.0

package/dist/catalog/generated/details/ticket-match.json

@@ -0,0 +1,43 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "firstTicket": { "type": "string" },
+      "secondTicket": { "type": "string" },
+      "context": { "type": "string" },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["firstTicket", "secondTicket"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "verdict": { "type": "string", "enum": ["same_issue", "related", "different", "unclear"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": {
+          "type": "string",
+          "enum": ["same_issue", "related", "different", "unclear"]
+        },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["same_issue", "related", "different", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/tone-check.json

@@ -0,0 +1,63 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "draft": { "type": "string" },
+      "criteria": {
+        "minItems": 1,
+        "maxItems": 50,
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": { "id": { "type": "string" }, "text": { "type": "string" } },
+          "required": ["id", "text"]
+        }
+      },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["draft", "criteria"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "allPassed": { "type": "boolean" },
+      "checks": {
+        "minItems": 1,
+        "maxItems": 50,
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "id": { "type": "string" },
+            "status": { "type": "string", "enum": ["ready", "review"] },
+            "verdict": { "type": "string", "enum": ["pass", "fail", "unclear"] },
+            "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+            "probabilities": {
+              "type": "object",
+              "propertyNames": { "type": "string", "enum": ["pass", "fail", "unclear"] },
+              "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+              "required": ["pass", "fail", "unclear"]
+            }
+          },
+          "required": ["id", "status", "verdict", "confidence", "probabilities"],
+          "additionalProperties": false
+        }
+      }
+    },
+    "required": ["model", "usage", "status", "allPassed", "checks"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/tool-fit.json

@@ -0,0 +1,40 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "task": { "type": "string" },
+      "tool": { "type": "string" },
+      "context": { "type": "string" },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["task", "tool"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "verdict": { "type": "string", "enum": ["fits", "does_not_fit", "unclear"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": { "type": "string", "enum": ["fits", "does_not_fit", "unclear"] },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["fits", "does_not_fit", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/topic-shift.json

@@ -0,0 +1,43 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "currentTopic": { "type": "string" },
+      "message": { "type": "string" },
+      "context": { "type": "string" },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["currentTopic", "message"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "verdict": { "type": "string", "enum": ["same_topic", "new_topic", "mixed", "unclear"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": {
+          "type": "string",
+          "enum": ["same_topic", "new_topic", "mixed", "unclear"]
+        },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["same_topic", "new_topic", "mixed", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/troubleshooting-fit.json

@@ -0,0 +1,40 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "symptoms": { "type": "string" },
+      "procedure": { "type": "string" },
+      "context": { "type": "string" },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["symptoms", "procedure"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "verdict": { "type": "string", "enum": ["applicable", "unsuitable", "unclear"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": { "type": "string", "enum": ["applicable", "unsuitable", "unclear"] },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["applicable", "unsuitable", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/turn-intent.json

@@ -0,0 +1,69 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "message": { "type": "string" },
+      "context": { "type": "string" },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["message"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "verdict": {
+        "type": "string",
+        "enum": [
+          "request",
+          "answer",
+          "correction",
+          "cancellation",
+          "acknowledgment",
+          "other",
+          "unclear"
+        ]
+      },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": {
+          "type": "string",
+          "enum": [
+            "request",
+            "answer",
+            "correction",
+            "cancellation",
+            "acknowledgment",
+            "other",
+            "unclear"
+          ]
+        },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": [
+          "request",
+          "answer",
+          "correction",
+          "cancellation",
+          "acknowledgment",
+          "other",
+          "unclear"
+        ]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/urgency-signal.json

@@ -0,0 +1,39 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "message": { "type": "string" },
+      "context": { "type": "string" },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["message"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "verdict": { "type": "string", "enum": ["expressed", "not_expressed", "unclear"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": { "type": "string", "enum": ["expressed", "not_expressed", "unclear"] },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["expressed", "not_expressed", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/verify.json

@@ -0,0 +1,66 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "claims": {
+        "minItems": 1,
+        "maxItems": 100,
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "id": { "type": "string" },
+            "claim": { "type": "string" },
+            "evidence": { "type": "string" }
+          },
+          "required": ["id", "claim", "evidence"]
+        }
+      },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["claims"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "checks": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "id": { "type": "string" },
+            "status": { "type": "string", "enum": ["ready", "review"] },
+            "verdict": { "type": "string", "enum": ["supported", "contradicted", "unsupported"] },
+            "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+            "probabilities": {
+              "type": "object",
+              "propertyNames": {
+                "type": "string",
+                "enum": ["supported", "contradicted", "unsupported"]
+              },
+              "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+              "required": ["supported", "contradicted", "unsupported"]
+            }
+          },
+          "required": ["id", "status", "verdict", "confidence", "probabilities"],
+          "additionalProperties": false
+        }
+      },
+      "allSupported": { "type": "boolean" }
+    },
+    "required": ["model", "usage", "checks", "allSupported"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/workaround-fit.json

@@ -0,0 +1,40 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "issue": { "type": "string" },
+      "workaround": { "type": "string" },
+      "constraints": { "type": "string" },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["issue", "workaround", "constraints"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "verdict": { "type": "string", "enum": ["fits", "conflicts", "unclear"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": { "type": "string", "enum": ["fits", "conflicts", "unclear"] },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["fits", "conflicts", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/loaders.d.ts

@@ -0,0 +1,3 @@
+import type { RecipeName } from '../schema.js';
+import type { RecipeRunner } from '../runner.js';
+export declare const recipeLoaders: Record<RecipeName, () => Promise<RecipeRunner>>;

package/dist/catalog/generated/loaders.js

@@ -0,0 +1,68 @@
+export const recipeLoaders = {
+    'action-scope': () => import('../../recipes/action-scope/index.js').then((recipe) => (input, options) => recipe.actionScope(recipe.actionScopeInputSchema.parse(input), options)),
+    'answer-consistency': () => import('../../recipes/answer-consistency/index.js').then((recipe) => (input, options) => recipe.answerConsistency(recipe.answerConsistencyInputSchema.parse(input), options)),
+    'answer-coverage': () => import('../../recipes/answer-coverage/index.js').then((recipe) => (input, options) => recipe.answerCoverage(recipe.answerCoverageInputSchema.parse(input), options)),
+    'answer-invalidation': () => import('../../recipes/answer-invalidation/index.js').then((recipe) => (input, options) => recipe.answerInvalidation(recipe.answerInvalidationInputSchema.parse(input), options)),
+    'answer-relevance': () => import('../../recipes/answer-relevance/index.js').then((recipe) => (input, options) => recipe.answerRelevance(recipe.answerRelevanceInputSchema.parse(input), options)),
+    answerability: () => import('../../recipes/answerability/index.js').then((recipe) => (input, options) => recipe.answerability(recipe.answerabilityInputSchema.parse(input), options)),
+    'argument-fit': () => import('../../recipes/argument-fit/index.js').then((recipe) => (input, options) => recipe.argumentFit(recipe.argumentFitInputSchema.parse(input), options)),
+    'attempted-step': () => import('../../recipes/attempted-step/index.js').then((recipe) => (input, options) => recipe.attemptedStep(recipe.attemptedStepInputSchema.parse(input), options)),
+    'audience-fit': () => import('../../recipes/audience-fit/index.js').then((recipe) => (input, options) => recipe.audienceFit(recipe.audienceFitInputSchema.parse(input), options)),
+    'cache-match': () => import('../../recipes/cache-match/index.js').then((recipe) => (input, options) => recipe.cacheMatch(recipe.cacheMatchInputSchema.parse(input), options)),
+    'cancellation-check': () => import('../../recipes/cancellation-check/index.js').then((recipe) => (input, options) => recipe.cancellationCheck(recipe.cancellationCheckInputSchema.parse(input), options)),
+    'certainty-match': () => import('../../recipes/certainty-match/index.js').then((recipe) => (input, options) => recipe.certaintyMatch(recipe.certaintyMatchInputSchema.parse(input), options)),
+    'change-meaning': () => import('../../recipes/change-meaning/index.js').then((recipe) => (input, options) => recipe.changeMeaning(recipe.changeMeaningInputSchema.parse(input), options)),
+    'citation-match': () => import('../../recipes/citation-match/index.js').then((recipe) => (input, options) => recipe.citationMatch(recipe.citationMatchInputSchema.parse(input), options)),
+    'citation-needed': () => import('../../recipes/citation-needed/index.js').then((recipe) => (input, options) => recipe.citationNeeded(recipe.citationNeededInputSchema.parse(input), options)),
+    clarify: () => import('../../recipes/clarify/index.js').then((recipe) => (input, options) => recipe.clarify(recipe.clarifyInputSchema.parse(input), options)),
+    'confirmation-match': () => import('../../recipes/confirmation-match/index.js').then((recipe) => (input, options) => recipe.confirmationMatch(recipe.confirmationMatchInputSchema.parse(input), options)),
+    'context-role': () => import('../../recipes/context-role/index.js').then((recipe) => (input, options) => recipe.contextRole(recipe.contextRoleInputSchema.parse(input), options)),
+    'correction-target': () => import('../../recipes/correction-target/index.js').then((recipe) => (input, options) => recipe.correctionTarget(recipe.correctionTargetInputSchema.parse(input), options)),
+    'document-role': () => import('../../recipes/document-role/index.js').then((recipe) => (input, options) => recipe.documentRole(recipe.documentRoleInputSchema.parse(input), options)),
+    'draft-compare': () => import('../../recipes/draft-compare/index.js').then((recipe) => (input, options) => recipe.draftCompare(recipe.draftCompareInputSchema.parse(input), options)),
+    'evidence-conflict': () => import('../../recipes/evidence-conflict/index.js').then((recipe) => (input, options) => recipe.evidenceConflict(recipe.evidenceConflictInputSchema.parse(input), options)),
+    'evidence-novelty': () => import('../../recipes/evidence-novelty/index.js').then((recipe) => (input, options) => recipe.evidenceNovelty(recipe.evidenceNoveltyInputSchema.parse(input), options)),
+    'fact-stability': () => import('../../recipes/fact-stability/index.js').then((recipe) => (input, options) => recipe.factStability(recipe.factStabilityInputSchema.parse(input), options)),
+    'failure-kind': () => import('../../recipes/failure-kind/index.js').then((recipe) => (input, options) => recipe.failureKind(recipe.failureKindInputSchema.parse(input), options)),
+    'feedback-kind': () => import('../../recipes/feedback-kind/index.js').then((recipe) => (input, options) => recipe.feedbackKind(recipe.feedbackKindInputSchema.parse(input), options)),
+    'field-select': () => import('../../recipes/field-select/index.js').then((recipe) => (input, options) => recipe.fieldSelect(recipe.fieldSelectInputSchema.parse(input), options)),
+    'followup-link': () => import('../../recipes/followup-link/index.js').then((recipe) => (input, options) => recipe.followupLink(recipe.followupLinkInputSchema.parse(input), options)),
+    'freshness-needed': () => import('../../recipes/freshness-needed/index.js').then((recipe) => (input, options) => recipe.freshnessNeeded(recipe.freshnessNeededInputSchema.parse(input), options)),
+    'frustration-signal': () => import('../../recipes/frustration-signal/index.js').then((recipe) => (input, options) => recipe.frustrationSignal(recipe.frustrationSignalInputSchema.parse(input), options)),
+    handoff: () => import('../../recipes/handoff/index.js').then((recipe) => (input, options) => recipe.handoff(recipe.handoffInputSchema.parse(input), options)),
+    'incident-match': () => import('../../recipes/incident-match/index.js').then((recipe) => (input, options) => recipe.incidentMatch(recipe.incidentMatchInputSchema.parse(input), options)),
+    'instruction-fit': () => import('../../recipes/instruction-fit/index.js').then((recipe) => (input, options) => recipe.instructionFit(recipe.instructionFitInputSchema.parse(input), options)),
+    'intent-change': () => import('../../recipes/intent-change/index.js').then((recipe) => (input, options) => recipe.intentChange(recipe.intentChangeInputSchema.parse(input), options)),
+    'issue-impact': () => import('../../recipes/issue-impact/index.js').then((recipe) => (input, options) => recipe.issueImpact(recipe.issueImpactInputSchema.parse(input), options)),
+    'memory-relation': () => import('../../recipes/memory-relation/index.js').then((recipe) => (input, options) => recipe.memoryRelation(recipe.memoryRelationInputSchema.parse(input), options)),
+    'memory-scope': () => import('../../recipes/memory-scope/index.js').then((recipe) => (input, options) => recipe.memoryScope(recipe.memoryScopeInputSchema.parse(input), options)),
+    'memory-value': () => import('../../recipes/memory-value/index.js').then((recipe) => (input, options) => recipe.memoryValue(recipe.memoryValueInputSchema.parse(input), options)),
+    'passage-duplicate': () => import('../../recipes/passage-duplicate/index.js').then((recipe) => (input, options) => recipe.passageDuplicate(recipe.passageDuplicateInputSchema.parse(input), options)),
+    'preference-kind': () => import('../../recipes/preference-kind/index.js').then((recipe) => (input, options) => recipe.preferenceKind(recipe.preferenceKindInputSchema.parse(input), options)),
+    'promise-check': () => import('../../recipes/promise-check/index.js').then((recipe) => (input, options) => recipe.promiseCheck(recipe.promiseCheckInputSchema.parse(input), options)),
+    'query-equivalence': () => import('../../recipes/query-equivalence/index.js').then((recipe) => (input, options) => recipe.queryEquivalence(recipe.queryEquivalenceInputSchema.parse(input), options)),
+    'query-specificity': () => import('../../recipes/query-specificity/index.js').then((recipe) => (input, options) => recipe.querySpecificity(recipe.querySpecificityInputSchema.parse(input), options)),
+    'reference-resolve': () => import('../../recipes/reference-resolve/index.js').then((recipe) => (input, options) => recipe.referenceResolve(recipe.referenceResolveInputSchema.parse(input), options)),
+    'repeated-attempt': () => import('../../recipes/repeated-attempt/index.js').then((recipe) => (input, options) => recipe.repeatedAttempt(recipe.repeatedAttemptInputSchema.parse(input), options)),
+    'reply-template-match': () => import('../../recipes/reply-template-match/index.js').then((recipe) => (input, options) => recipe.replyTemplateMatch(recipe.replyTemplateMatchInputSchema.parse(input), options)),
+    rerank: () => import('../../recipes/rerank/index.js').then((recipe) => (input, options) => recipe.rerank(recipe.rerankInputSchema.parse(input), options)),
+    'resolution-check': () => import('../../recipes/resolution-check/index.js').then((recipe) => (input, options) => recipe.resolutionCheck(recipe.resolutionCheckInputSchema.parse(input), options)),
+    'response-needed': () => import('../../recipes/response-needed/index.js').then((recipe) => (input, options) => recipe.responseNeeded(recipe.responseNeededInputSchema.parse(input), options)),
+    'result-outcome': () => import('../../recipes/result-outcome/index.js').then((recipe) => (input, options) => recipe.resultOutcome(recipe.resultOutcomeInputSchema.parse(input), options)),
+    'result-usefulness': () => import('../../recipes/result-usefulness/index.js').then((recipe) => (input, options) => recipe.resultUsefulness(recipe.resultUsefulnessInputSchema.parse(input), options)),
+    'retrieval-needed': () => import('../../recipes/retrieval-needed/index.js').then((recipe) => (input, options) => recipe.retrievalNeeded(recipe.retrievalNeededInputSchema.parse(input), options)),
+    route: () => import('../../recipes/route/index.js').then((recipe) => (input, options) => recipe.route(recipe.routeInputSchema.parse(input), options)),
+    'source-applicability': () => import('../../recipes/source-applicability/index.js').then((recipe) => (input, options) => recipe.sourceApplicability(recipe.sourceApplicabilityInputSchema.parse(input), options)),
+    'step-complete': () => import('../../recipes/step-complete/index.js').then((recipe) => (input, options) => recipe.stepComplete(recipe.stepCompleteInputSchema.parse(input), options)),
+    'step-progress': () => import('../../recipes/step-progress/index.js').then((recipe) => (input, options) => recipe.stepProgress(recipe.stepProgressInputSchema.parse(input), options)),
+    'summary-coverage': () => import('../../recipes/summary-coverage/index.js').then((recipe) => (input, options) => recipe.summaryCoverage(recipe.summaryCoverageInputSchema.parse(input), options)),
+    'ticket-match': () => import('../../recipes/ticket-match/index.js').then((recipe) => (input, options) => recipe.ticketMatch(recipe.ticketMatchInputSchema.parse(input), options)),
+    'tone-check': () => import('../../recipes/tone-check/index.js').then((recipe) => (input, options) => recipe.toneCheck(recipe.toneCheckInputSchema.parse(input), options)),
+    'tool-fit': () => import('../../recipes/tool-fit/index.js').then((recipe) => (input, options) => recipe.toolFit(recipe.toolFitInputSchema.parse(input), options)),
+    'topic-shift': () => import('../../recipes/topic-shift/index.js').then((recipe) => (input, options) => recipe.topicShift(recipe.topicShiftInputSchema.parse(input), options)),
+    'troubleshooting-fit': () => import('../../recipes/troubleshooting-fit/index.js').then((recipe) => (input, options) => recipe.troubleshootingFit(recipe.troubleshootingFitInputSchema.parse(input), options)),
+    'turn-intent': () => import('../../recipes/turn-intent/index.js').then((recipe) => (input, options) => recipe.turnIntent(recipe.turnIntentInputSchema.parse(input), options)),
+    'urgency-signal': () => import('../../recipes/urgency-signal/index.js').then((recipe) => (input, options) => recipe.urgencySignal(recipe.urgencySignalInputSchema.parse(input), options)),
+    verify: () => import('../../recipes/verify/index.js').then((recipe) => (input, options) => recipe.verify(recipe.verifyInputSchema.parse(input), options)),
+    'workaround-fit': () => import('../../recipes/workaround-fit/index.js').then((recipe) => (input, options) => recipe.workaroundFit(recipe.workaroundFitInputSchema.parse(input), options)),
+};

package/dist/catalog/generated/metadata.d.ts

@@ -0,0 +1,2 @@
+import type { CatalogRecipe } from '../index.js';
+export declare const recipeMetadata: CatalogRecipe[];