mcp-recipes 1.3.0 → 2.0.0

package/dist/sources/client.d.ts

@@ -24,10 +24,10 @@ interface Config {
     logLevel: LogLevel;
 }
 interface Logger {
-    debug(message: string): void;
-    info(message: string): void;
-    warn(message: string): void;
-    error(message: string): void;
+    debug: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
 }
 
 /** The shapes the source layer produces. Nothing here knows about MCP. */
@@ -249,12 +249,10 @@ interface SourceAdapter extends SourceProfile {
      * no source claims is refused, instead of being sent somewhere that would
      * answer it with a confident absence.
      */
-    claims(raw: string): Claim | null;
-    search(query: string, limit: number): Promise<ReadRows>;
-    getRecipe(reference: string): Promise<ReadRecipe>;
+    claims: (raw: string) => Claim | null;
+    search: (query: string, limit: number) => Promise<ReadRows>;
+    getRecipe: (reference: string) => Promise<ReadRecipe>;
 }
-/** Build the identifier this server hands out for a row from a source. */
-declare function namespacedId(source: SourceId, reference: string): string;
 
 /**
  * Identifiers that name the source they came from.
@@ -272,21 +270,6 @@ interface ResolvedId {
     /** Set when the shape was read rather than stated, so the answer can say so. */
     inferred: string | null;
 }
-/**
- * Work out which source an identifier belongs to.
- *
- * A prefixed identifier is routed on what it says. A raw one is offered to each
- * source in turn, and a source claims only the shapes it mints: digits for one,
- * a namespaced page key for another. Exactly one claim routes the read and the
- * answer says which reading it used.
- *
- * More than one claim is refused rather than resolved, because picking a winner
- * would send the read somewhere a caller did not intend and answer with a
- * confident recipe for the wrong dish. No claim at all is refused too: a bare
- * dish name is a search, not an identifier, and guessing a page name from it
- * returns whatever that guess happens to hit.
- */
-declare function resolveId(rawId: string, sources: readonly SourceAdapter[]): ResolvedId;
 
 /**
  * The Cookbook on the English Wikibooks, as a source.
@@ -329,13 +312,13 @@ interface CookbookRecipe {
 }
 /** The part of the Cookbook's client this server uses. */
 interface CookbookReader {
-    search(query: string, limit: number): Promise<{
+    search: (query: string, limit: number) => Promise<{
         data: {
             results: CookbookSummary[];
         };
         cached: boolean;
     }>;
-    getRecipe(reference: string): Promise<{
+    getRecipe: (reference: string) => Promise<{
         data: CookbookRecipe;
         cached: boolean;
     }>;
@@ -382,14 +365,14 @@ interface MarmitonRecipe {
 }
 /** The part of Marmiton's client this server uses. */
 interface MarmitonReader {
-    search(query: string): Promise<{
+    search: (query: string) => Promise<{
         data: MarmitonSummary[];
         cached: boolean;
     }>;
-    getRecipe(ref: {
+    getRecipe: (ref: {
         id?: string;
         url?: string;
-    }): Promise<{
+    }) => Promise<{
         data: MarmitonRecipe;
         cached: boolean;
     }>;
@@ -412,109 +395,6 @@ interface Readers {
     marmiton?: MarmitonReader;
     cookbook?: CookbookReader;
 }
-/** The sources a caller can name, in the order an answer takes them. */
-declare const SOURCE_IDS: readonly SourceId[];
-
-/**
- * Several wordings from one question.
- *
- * A person asks for a recipe in a sentence, and a recipe index reads none of
- * it. One of the indexes behind this server requires every word given to appear
- * on the same page, so a sentence returns nothing where the corpus holds several
- * of the dish. The other ranks pages on the words it was handed, so the words
- * framing the question pull up whatever happens to share them and push the dish
- * down the list or out of it. Both come back to a reader looking like a
- * statement about a corpus when they are statements about a wording. Deriving
- * the shorter wordings and asking for the union is what keeps the two apart.
- *
- * Every wording is built from the words the question carried, with no
- * dictionary, no corpus statistics and no translation. That has two
- * consequences worth stating. A derived wording is one a reader can retype by
- * hand, so an answer built from several of them stays checkable. And the
- * derivations that would need a lexicon are not made: a question asked in one
- * language is never turned into the other, because a source that publishes in
- * the other language and holds nothing under the words written is an honest
- * absence, while a guessed translation is a word nobody wrote.
- *
- * The order runs from the wording closest to what was asked to the widest.
- *
- * A question also states what the recipe must not hold, and that part is read
- * by the role its words play rather than by the turn of phrase they are written
- * in: a negation, a sentence about how a food affects the person, or the name
- * of a diet. All three put a food out of the dish, so all three are set aside
- * from the derived wordings and named back to the caller. Reading them off a
- * list of phrasings is what lets a declared allergen become a word to search
- * for, and there is no phrasing whose absence from such a list is safe.
- */
-/** One wording, and how it was arrived at. */
-interface Wording {
-    query: string;
-    /** How this wording was derived from the question, in words. */
-    derivation: string;
-}
-/**
- * The most searches one source receives for one question.
- *
- * A ceiling per source rather than a budget shared between them, because the
- * sources are asked in parallel and each is paced on its own, so the worst case
- * is three of one source's intervals rather than six. Three is also the whole
- * ladder: the question as asked, the dish words, and the word naming the dish.
- */
-declare const MAX_WORDINGS_PER_SOURCE = 3;
-/** How a question put a condition, which decides how it is reported back. */
-type ConditionKind = 
-/** The question wrote the recipe must not hold this. */
-"excluded"
-/** The question said the person reacts to this food. */
- | "allergy"
-/** The question named a diet, which is a class defined by what it leaves out. */
- | "diet";
-/** One thing a question asks the recipe not to hold. */
-interface Condition {
-    /**
-     * The words the question used for the food, or null where the question states
-     * a condition and the sentence does not say plainly which food it covers.
-     *
-     * A word named here is a word the recipe must not hold and a word no wording
-     * looks for, so naming the wrong one both hides a dish and leaves the food
-     * being avoided in the search. Where the reading is not certain, the caller is
-     * told a condition was stated and that its food was not read, which is a
-     * smaller claim than either.
-     */
-    named: string | null;
-    kind: ConditionKind;
-}
-/** What a question asks the dish to avoid, and how many it has to serve. */
-interface Conditions {
-    /** What the dish must not hold, in the words the question used. */
-    conditions: Condition[];
-    /** How many the dish has to serve, when the question said. */
-    servings: number | null;
-}
-/**
- * Read what the question asks the recipe to avoid or to serve.
- *
- * These are the parts of a question no recipe index answers. A page is not
- * named for what it leaves out, and the number of people at a table is not
- * printed in a title at all, so both are read here and handled as what they
- * are rather than as words to look for.
- */
-declare function readConditions(question: string): Conditions;
-declare function deriveWordings(question: string): Wording[];
-/**
- * Whether a row's title carries a word naming the dish that was asked for.
- *
- * This decides whether a wording answered, and nothing else: no row is dropped
- * and no row is moved for failing it. A source that ranks on the words it was
- * handed answers a sentence with a page of recipes that share its framing
- * words, and counting those as an answer would stop the search on the page that
- * proves it has not found the dish.
- *
- * Diacritics and punctuation fold away, so "crêpes" reads the same as "crepes"
- * and a namespace in front of a page name settles nothing. A question that
- * names no dish has nothing to check against, and every row passes.
- */
-declare function namesDish(title: string, question: string): boolean;
 
 /**
  * The one place that talks to the sources.
@@ -622,4 +502,4 @@ declare class RecipesClient {
     }>;
 }
 
-export { type Conditions, type CookbookReader, MAX_LIMIT_PER_SOURCE, MAX_WORDINGS_PER_SOURCE, type MarmitonReader, type MergedSearch, type ReadRecipe, type ReadRows, type Readers, type RecipeDetail, type RecipeRow, RecipesClient, type RecipesClientOptions, SOURCE_IDS, type SearchOptions, type SourceAdapter, type SourceId, type SourceProfile, type SourceReport, type Wording, type WordingAttempt, deriveWordings, interleave, namesDish, namespacedId, readConditions, resolveId };
+export { type CookbookReader, MAX_LIMIT_PER_SOURCE, type MarmitonReader, type MergedSearch, type ReadRecipe, type ReadRows, type Readers, type RecipeDetail, type RecipeRow, RecipesClient, type RecipesClientOptions, type SearchOptions, type SourceAdapter, type SourceId, type SourceProfile, type SourceReport, type WordingAttempt, interleave };