@graphext/cuery 0.3.0 → 0.5.1

package/script/src/tools/generic.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * Generic AI step tool for processing records with LLM-inferred response schemas.
+ *
+ * This tool allows for generic tasks that iterate over data, where the response schema
+ * is either provided directly or inferred from the user's instructions using an LLM.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchema = generateSchema;
+exports.generic = generic;
+exports.genericBatch = genericBatch;
+exports.auto = auto;
+exports.autoBatch = autoBatch;
+const index_js_1 = require("../../deps/jsr.io/@zod/zod/4.3.6/src/index.js");
+const async_js_1 = require("../helpers/async.js");
+const llm_js_1 = require("../llm.js");
+const response_js_1 = require("../response.js");
+const utils_js_1 = require("../helpers/utils.js");
+// ============================================================================
+// Prompts
+// ============================================================================
+const GENERIC_PROMPT = (0, utils_js_1.dedent)(`
+# Instructions
+
+{instructions}
+
+# Data Record
+
+{record}
+`);
+const SCHEMA_GENERATION_SYSTEM_PROMPT = (0, utils_js_1.dedent)(`
+You are an expert at designing JSON schemas for structured data extraction from LLMs.
+
+Your role is to:
+1. Understand what kind of data the user wants to extract
+2. Define appropriate field names, types, constraints and descriptions
+3. Return a valid JSON schema specification
+
+Schema design considerations:
+- Use appropriate data types (string, number, integer, boolean, array, object)
+- Include constraints if appropriate (minLength, maxLength, minimum, maximum, enum, etc.)
+- Use "format" attributes where relevant (email, uri, date, etc.)
+- Provide clear, helpful descriptions for each field
+- Consider whether fields should be required or optional
+- Use consistent naming conventions (camelCase preferred)
+
+The "reasoning" field should contain your thought process behind the schema design,
+and the "jsonSchema" field should contain the complete JSON schema.
+`);
+const SCHEMA_GENERATION_PROMPT = (0, utils_js_1.dedent)(`
+Create a JSON schema for extracting information based on these instructions:
+
+{instructions}
+
+The schema will be used to validate LLM outputs when processing data records.
+Design a schema that captures all the information described in the instructions.
+`);
+const SCHEMA_CONVERSION_PROMPT = (0, utils_js_1.dedent)(`
+A user has provided instructions for a task that involves extracting information
+from data records. Your task is to translate these instructions into new instructions
+for generating a JSON schema that describes the information to extract.
+
+## Example 1
+
+- User instruction: "Extract any emails and URLs from the text."
+- Your instruction: "Create a JSON schema with fields for 'emails' (array of strings with email format) and 'urls' (array of strings with uri format)."
+
+## Example 2
+
+- User instruction: "Extract the name and age of the person from their bio."
+- Your instruction: "Create a JSON schema with fields for 'name' (string) and 'age' (integer, minimum 0)."
+
+Make sure to capture all relevant details from the user's instructions, e.g. whether fields
+should be scalar or arrays, whether they should be required or optional, and any specific
+formats that should be used.
+
+# User instruction
+
+{instructions}
+`);
+// ============================================================================
+// Schemas
+// ============================================================================
+/**
+ * Schema for the schema generation response.
+ */
+const SchemaResponseSchema = index_js_1.z.object({
+    reasoning: index_js_1.z.string().describe('Brief explanation of schema design choices'),
+    jsonSchema: index_js_1.z.record(index_js_1.z.string(), index_js_1.z.unknown()).describe('Valid JSON schema as an object')
+});
+/**
+ * Schema for the schema instruction conversion response.
+ */
+const SchemaInstructionsSchema = index_js_1.z.object({
+    instructions: index_js_1.z.string().describe('Instructions for generating the JSON schema')
+});
+// ============================================================================
+// Utilities
+// ============================================================================
+/**
+ * Formats a record object into a human-readable text representation.
+ */
+function formatRecord(record) {
+    return Object.entries(record)
+        .map(([key, value]) => `${key}: ${JSON.stringify(value, null, 2)}`)
+        .join('\n\n');
+}
+/**
+ * Generates a JSON schema from natural language instructions.
+ *
+ * @param options - Configuration options
+ * @returns The generated schema response with reasoning and JSON schema
+ */
+async function generateSchema({ instructions, model = 'gpt-4.1', modelParams = {}, maxRetries = 5 }) {
+    const prompt = [
+        { role: 'system', content: SCHEMA_GENERATION_SYSTEM_PROMPT },
+        { role: 'user', content: SCHEMA_GENERATION_PROMPT.replace('{instructions}', instructions) }
+    ];
+    const { parsed, error } = await (0, llm_js_1.askLLMSafe)({
+        prompt,
+        model,
+        schema: SchemaResponseSchema,
+        params: modelParams,
+        maxRetries,
+        onError: 'return',
+    });
+    if (error || !parsed) {
+        throw new Error(`Failed to generate schema: ${error?.message ?? 'Unknown error'}`);
+    }
+    return parsed;
+}
+/**
+ * Converts general task instructions into schema generation instructions.
+ * This is used when the user provides only task instructions without a schema.
+ */
+async function convertToSchemaInstructions(instructions, model, modelParams, maxRetries) {
+    const prompt = SCHEMA_CONVERSION_PROMPT.replace('{instructions}', instructions);
+    const { parsed, error } = await (0, llm_js_1.askLLMSafe)({
+        prompt,
+        model,
+        schema: SchemaInstructionsSchema,
+        params: modelParams,
+        maxRetries,
+        onError: 'return',
+    });
+    if (error || !parsed) {
+        throw new Error(`Failed to convert instructions: ${error?.message ?? 'Unknown error'}`);
+    }
+    return parsed.instructions;
+}
+/**
+ * Processes a single record using an LLM with a provided JSON schema.
+ * Returns both the result and usage information.
+ */
+async function generic({ record, instructions, schema, model = 'gpt-4.1-mini', modelParams = {}, maxRetries = 3 }) {
+    if (record == null || Object.keys(record).length === 0) {
+        return { parsed: null, text: null, usage: null, error: null };
+    }
+    const zodSchema = index_js_1.z.fromJSONSchema(schema);
+    const prompt = GENERIC_PROMPT
+        .replace('{instructions}', instructions)
+        .replace('{record}', formatRecord(record));
+    const response = await (0, llm_js_1.askLLMSafe)({
+        prompt,
+        model,
+        schema: zodSchema,
+        params: modelParams,
+        maxRetries,
+        onError: 'return',
+    });
+    if (response.error || response.parsed == null) {
+        throw new Error(`Failed to process record: ${response.error?.message ?? 'Unknown error'}`);
+    }
+    return { parsed: response.parsed, text: response.text, usage: response.usage, error: null };
+}
+/**
+ * Processes multiple records using an LLM with a provided JSON schema.
+ * Returns a BatchResponse with usage tracking.
+ */
+async function genericBatch({ records, instructions, schema, model = 'gpt-4.1-mini', modelParams = {}, maxRetries = 3, maxConcurrency = 100, trackCost = false, }) {
+    const responses = await (0, async_js_1.mapParallel)(records, maxConcurrency, (record) => generic({ record, instructions, schema, model, modelParams, maxRetries }));
+    return new response_js_1.BatchResponse(responses.map(r => r.parsed), trackCost ? responses.map(r => r.usage) : undefined, trackCost ? model : undefined);
+}
+/**
+ * Resolves a schema from various input types:
+ * - If schemaOrInstructions is an object, use it directly as the schema
+ * - If it's a string, use it as instructions to generate a schema
+ * - If it's null/undefined, derive schema instructions from the task instructions
+ */
+async function resolveSchema(schemaOrInstructions, taskInstructions, model, modelParams, maxRetries) {
+    // Schema already provided as object
+    if (schemaOrInstructions != null && typeof schemaOrInstructions === 'object') {
+        return {
+            schema: schemaOrInstructions,
+            schemaReasoning: 'Schema was provided directly'
+        };
+    }
+    // Determine schema instructions
+    const schemaInstructions = typeof schemaOrInstructions === 'string'
+        ? schemaOrInstructions
+        : await convertToSchemaInstructions(taskInstructions, model, modelParams, maxRetries);
+    // Generate the schema
+    const schemaResponse = await generateSchema({
+        instructions: schemaInstructions,
+        model,
+        modelParams,
+        maxRetries
+    });
+    return {
+        schema: schemaResponse.jsonSchema,
+        schemaReasoning: schemaResponse.reasoning
+    };
+}
+/**
+ * Automatically generates a response schema from instructions and processes a single record.
+ *
+ * This is a fully automatic tool that:
+ * 1. Optionally converts general instructions into schema-specific instructions
+ * 2. Generates a JSON schema from the instructions
+ * 3. Processes the record using the generated schema
+ */
+async function auto({ record, instructions, schemaOrInstructions = null, model = 'gpt-4.1-mini', schemaModel = 'gpt-4.1', modelParams = {}, maxRetries = 3 }) {
+    const { schema, schemaReasoning } = await resolveSchema(schemaOrInstructions, instructions, schemaModel, modelParams, maxRetries);
+    const response = await generic({
+        record,
+        instructions,
+        schema,
+        model,
+        modelParams,
+        maxRetries
+    });
+    return { data: response.parsed, schema, schemaReasoning };
+}
+/**
+ * Automatically generates a response schema and processes multiple records.
+ *
+ * The schema is generated once from the instructions, then used to process all records.
+ */
+async function autoBatch({ records, instructions, schemaOrInstructions = null, model = 'gpt-4.1-mini', schemaModel = 'gpt-4.1', modelParams = {}, maxRetries = 3, maxConcurrency = 100 }) {
+    const { schema, schemaReasoning } = await resolveSchema(schemaOrInstructions, instructions, schemaModel, modelParams, maxRetries);
+    const data = await genericBatch({
+        records,
+        instructions,
+        schema,
+        model,
+        modelParams,
+        maxRetries,
+        maxConcurrency
+    });
+    return { data, schema, schemaReasoning };
+}

package/script/src/tools/keywords.js

@@ -16,11 +16,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expandKeywords = expandKeywords;
 exports.generateKeywords = generateKeywords;
-const async_js_1 = require("../async.js");
-const openai_js_1 = require("../openai.js");
+const async_js_1 = require("../helpers/async.js");
+const llm_js_1 = require("../llm.js");
 const brands_js_1 = require("./brands.js");
 const keyword_schema_js_1 = require("../schemas/keyword.schema.js");
-const utils_js_1 = require("../utils.js");
+const utils_js_1 = require("../helpers/utils.js");
 const keywordPlanner_js_1 = require("../apis/googleAds/keywordPlanner.js");
 async function expandKeywords({ seedKeywords, url, urlAsExpandRelevanceContext, language = 'EN', countryISOCode, generateIdeasFromSeeds = false, includeSeedKeywords = false }) {
     url = url?.trim();
@@ -181,9 +181,9 @@ async function generateKeywords({ sector, market, brand, brandDomain, language =
         .replaceAll('{brandsInfo}', brandsInfo || '')
         .replaceAll('{personasInfo}', personasInfo || '')
         .replaceAll('{funnelInfo}', funnelInfo || '');
-    const { parsed } = await (0, openai_js_1.askOpenAISafe)(content, model, keyword_schema_js_1.KeywordsResponseSchema);
+    const { parsed } = await (0, llm_js_1.askLLMSafe)({ prompt: content, model, schema: keyword_schema_js_1.KeywordsResponseSchema });
     if (!parsed) {
-        throw new Error('Failed to parse response from OpenAI');
+        throw new Error('Failed to parse response from LLM');
     }
     return parsed;
 }

package/script/src/tools/personas.d.ts

@@ -1,3 +1,50 @@
-import type { PersonasOptions, PersonasResponse } from '../schemas/persona.schema.js';
-export declare function generatePersonas({ sector, market, brand, brandDomain, language, userLanguage, count, model, briefing, instructions, personas }: PersonasOptions): Promise<PersonasResponse>;
+import { Tool, type ModelConfig } from '../tool.js';
+import type { Persona, PersonasResponse } from '../schemas/persona.schema.js';
+/**
+ * Configuration for the PersonaGenerator tool.
+ */
+export interface PersonaGeneratorConfig {
+    /** Industry sector the brand operates in */
+    sector: string;
+    /** Geographical market or region */
+    market: string;
+    /** Brand name */
+    brand?: string;
+    /** Brand domain */
+    brandDomain?: string;
+    /** Language for keyword seeds (default: 'english') */
+    language?: string;
+    /** Language for persona descriptions (default: same as language) */
+    userLanguage?: string | null;
+    /** Number of personas to generate (default: 5) */
+    count?: number;
+    /** Brand briefing context */
+    briefing?: string;
+    /** Additional instructions */
+    instructions?: string | null;
+}
+/**
+ * A tool that generates customer personas for a brand.
+ */
+export declare class PersonaGenerator extends Tool<Array<Persona> | null, PersonasResponse, PersonasResponse> {
+    private readonly promptTemplate;
+    constructor(config: PersonaGeneratorConfig, modelConfig: ModelConfig);
+    protected schema(): import("../../deps/jsr.io/@zod/zod/4.3.6/src/index.js").ZodObject<{
+        personas: import("../../deps/jsr.io/@zod/zod/4.3.6/src/index.js").ZodArray<import("../../deps/jsr.io/@zod/zod/4.3.6/src/index.js").ZodObject<{
+            name: import("../../deps/jsr.io/@zod/zod/4.3.6/src/index.js").ZodString;
+            description: import("../../deps/jsr.io/@zod/zod/4.3.6/src/index.js").ZodString;
+            keywordSeeds: import("../../deps/jsr.io/@zod/zod/4.3.6/src/index.js").ZodArray<import("../../deps/jsr.io/@zod/zod/4.3.6/src/index.js").ZodString>;
+        }, import("../../deps/jsr.io/@zod/zod/4.3.6/src/v4/core/schemas.js").$strip>>;
+        explanation: import("../../deps/jsr.io/@zod/zod/4.3.6/src/index.js").ZodString;
+    }, import("../../deps/jsr.io/@zod/zod/4.3.6/src/v4/core/schemas.js").$strip>;
+    protected prompt(existingPersonas: Array<Persona> | null): string;
+    protected isEmpty(_input: Array<Persona> | null): boolean;
+    /**
+     * Not supported. PersonaGenerator is configured for a specific brand context
+     * and generates personas in a single call. Use invoke() instead.
+     */
+    batch(): never;
+}
+export type { Persona, PersonasResponse, PersonasOptions } from '../schemas/persona.schema.js';
+export { PersonaSchema, PersonasResponseSchema } from '../schemas/persona.schema.js';
 //# sourceMappingURL=personas.d.ts.map

package/script/src/tools/personas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"personas.d.ts","sourceRoot":"","sources":["../../../src/src/tools/personas.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAkDtF,wBAAsB,gBAAgB,CAAC,EACtC,MAAM,EACN,MAAM,EACN,KAAK,EACL,WAAW,EACX,QAAoB,EACpB,YAAmB,EACnB,KAAS,EACT,KAAiB,EACjB,QAAQ,EACR,YAAY,EACZ,QAAe,EACf,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA4C7C"}
+{"version":3,"file":"personas.d.ts","sourceRoot":"","sources":["../../../src/src/tools/personas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAEpD,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAsD9E;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mBAAmB;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8BAA8B;IAC9B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,gBAAgB,EAAE,gBAAgB,CAAC;IACpG,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;gBAE5B,MAAM,EAAE,sBAAsB,EAAE,WAAW,EAAE,WAAW;cAgDjD,MAAM;;;;;;;;IAIzB,SAAS,CAAC,MAAM,CAAC,gBAAgB,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,MAAM;cAW9C,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,OAAO;IAKlE;;;OAGG;IACM,KAAK,IAAI,KAAK;CAOvB;AAGD,YAAY,EAAE,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/F,OAAO,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC"}

package/script/src/tools/personas.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generatePersonas = generatePersonas;
-const openai_js_1 = require("../openai.js");
+exports.PersonasResponseSchema = exports.PersonaSchema = exports.PersonaGenerator = void 0;
+const tool_js_1 = require("../tool.js");
 const brands_js_1 = require("./brands.js");
 const persona_schema_js_1 = require("../schemas/persona.schema.js");
-const utils_js_1 = require("../utils.js");
+const utils_js_1 = require("../helpers/utils.js");
 const PROMPT = (0, utils_js_1.dedent)(`
 You're a marketing expert identifying typical profiles/personas of people searching
 for brands, products or services. Generate {count} detailed customer personas for a brand
@@ -49,43 +49,70 @@ from this list, you MUST return at least all the same competitors that are alrea
 current data. If no modification instructions are provided, maintain the existing list and only add
 new competitors if they are relevant.
 `);
-async function generatePersonas({ sector, market, brand, brandDomain, language = 'english', userLanguage = null, count = 5, model = 'gpt-4.1', briefing, instructions, personas = null }) {
-    if (!brand && !brandDomain) {
-        throw new Error('Either brand or brandDomain must be provided');
-    }
-    const brandContext = (0, brands_js_1.buildBrandContext)({
-        brand,
-        brandDomain,
-        sector,
-        market,
-        briefing
-    });
-    let brandExclusion;
-    if (brandDomain) {
-        if (brand) {
-            brandExclusion = ` "${brand}" or the domain`;
+/**
+ * A tool that generates customer personas for a brand.
+ */
+class PersonaGenerator extends tool_js_1.Tool {
+    promptTemplate;
+    constructor(config, modelConfig) {
+        super(modelConfig);
+        const { sector, market, brand, brandDomain, language = 'english', userLanguage = null, count = 5, briefing, instructions } = config;
+        if (!brand && !brandDomain) {
+            throw new Error('Either brand or brandDomain must be provided');
+        }
+        const brandContext = (0, brands_js_1.buildBrandContext)({
+            brand,
+            brandDomain,
+            sector,
+            market,
+            briefing
+        });
+        let brandExclusion;
+        if (brandDomain) {
+            if (brand) {
+                brandExclusion = ` "${brand}" or the domain`;
+            }
+            else {
+                brandExclusion = ' or domain';
+            }
         }
         else {
-            brandExclusion = ' or domain';
+            brandExclusion = ` "${brand}"`;
         }
+        this.promptTemplate = PROMPT
+            .replace('{count}', count.toString())
+            .replaceAll('{sector}', sector)
+            .replaceAll('{market}', market)
+            .replaceAll('{brand_context}', brandContext)
+            .replaceAll('{brand_exclusion}', brandExclusion)
+            .replaceAll('{language}', language)
+            .replaceAll('{userLanguage}', userLanguage ?? language)
+            .replaceAll('{instructions}', instructions || '');
+    }
+    schema() {
+        return persona_schema_js_1.PersonasResponseSchema;
+    }
+    prompt(existingPersonas) {
+        const currentData = existingPersonas && existingPersonas.length > 0
+            ? CURRENT_DATA_CLAUSE.replace('{currentData}', JSON.stringify({ personas: existingPersonas }, null, 2))
+            : '';
+        return this.promptTemplate.replace('{currentPersonasInfo}', currentData);
     }
-    else {
-        brandExclusion = ` "${brand}"`;
+    isEmpty(_input) {
+        // Never skip - null means generate fresh personas
+        return false;
     }
-    const currentData = personas && personas.length > 0 ? CURRENT_DATA_CLAUSE.replace('{currentData}', JSON.stringify({ personas }, null, 2)) : null;
-    const content = PROMPT
-        .replace('{count}', count.toString())
-        .replaceAll('{sector}', sector)
-        .replaceAll('{market}', market)
-        .replaceAll('{brand_context}', brandContext)
-        .replaceAll('{brand_exclusion}', brandExclusion)
-        .replaceAll('{language}', language)
-        .replaceAll('{userLanguage}', userLanguage ?? language)
-        .replaceAll('{instructions}', instructions || '')
-        .replaceAll('{currentPersonasInfo}', currentData || '');
-    const { parsed } = await (0, openai_js_1.askOpenAISafe)(content, model, persona_schema_js_1.PersonasResponseSchema);
-    if (!parsed) {
-        throw new Error('Failed to parse response from OpenAI');
+    /**
+     * Not supported. PersonaGenerator is configured for a specific brand context
+     * and generates personas in a single call. Use invoke() instead.
+     */
+    batch() {
+        throw new Error('PersonaGenerator.batch() is not supported. ' +
+            'This tool generates personas for a specific brand context. ' +
+            'Use invoke() instead.');
     }
-    return parsed;
 }
+exports.PersonaGenerator = PersonaGenerator;
+var persona_schema_js_2 = require("../schemas/persona.schema.js");
+Object.defineProperty(exports, "PersonaSchema", { enumerable: true, get: function () { return persona_schema_js_2.PersonaSchema; } });
+Object.defineProperty(exports, "PersonasResponseSchema", { enumerable: true, get: function () { return persona_schema_js_2.PersonasResponseSchema; } });

package/script/src/tools/scorer.d.ts

@@ -1,14 +1,32 @@
-import { z } from '../../deps/jsr.io/@zod/zod/4.1.12/src/index.js';
-export type ScoreSchema = z.ZodObject<{
+import { z } from '../../deps/jsr.io/@zod/zod/4.3.6/src/index.js';
+import { Tool, type ModelConfig } from '../tool.js';
+type ScoreSchema = z.ZodObject<{
     value: z.ZodNumber;
 }>;
 /**
- * Dynamically create a Zod schema for a score based on provided parameters.
+ * Configuration for the Scorer tool.
  */
-export declare function makeScoreSchema(type: 'integer' | 'number', min: number, max: number, description: string): ScoreSchema;
+export interface ScorerConfig {
+    name: string;
+    description: string;
+    type: 'integer' | 'number';
+    min: number;
+    max: number;
+}
 /**
- * Assumes only remaining placeholder in prompt is {record}
+ * A tool that scores records based on configured criteria.
  */
-export declare function score(record: Record<string, unknown>, prompt: string, schema: ScoreSchema, model?: string): Promise<number>;
-export declare function scoreBatch(records: Array<Record<string, unknown>>, name: string, description: string, type: 'integer' | 'number', min: number, max: number, model?: string, maxConcurrency?: number): Promise<Array<number>>;
+export declare class Scorer extends Tool<Record<string, unknown> | null, {
+    value: number;
+}, number> {
+    private readonly scoreSchema;
+    private readonly promptTemplate;
+    constructor(config: ScorerConfig, modelConfig: ModelConfig);
+    protected schema(): ScoreSchema;
+    protected prompt(record: Record<string, unknown> | null): string;
+    protected extractResult(parsed: {
+        value: number;
+    }): number;
+}
+export {};
 //# sourceMappingURL=scorer.d.ts.map

package/script/src/tools/scorer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scorer.d.ts","sourceRoot":"","sources":["../../../src/src/tools/scorer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,gDAAgD,CAAC;AAqBnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,SAAS,CAAC;IAAE,KAAK,EAAE,CAAC,CAAC,SAAS,CAAA;CAAE,CAAC,CAAC;AAE9D;;GAEG;AACH,wBAAgB,eAAe,CAC9B,IAAI,EAAE,SAAS,GAAG,QAAQ,EAC1B,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,GACjB,WAAW,CAWb;AAED;;GAEG;AACH,wBAAsB,KAAK,CAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,EACnB,KAAK,GAAE,MAAuB,GAC5B,OAAO,CAAC,MAAM,CAAC,CAajB;AAED,wBAAsB,UAAU,CAC/B,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACvC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,SAAS,GAAG,QAAQ,EAC1B,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,KAAK,GAAE,MAAuB,EAC9B,cAAc,GAAE,MAAY,GAC1B,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAcxB"}
+{"version":3,"file":"scorer.d.ts","sourceRoot":"","sources":["../../../src/src/tools/scorer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,+CAA+C,CAAC;AAClE,OAAO,EAAE,IAAI,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAkBpD,KAAK,WAAW,GAAG,CAAC,CAAC,SAAS,CAAC;IAAE,KAAK,EAAE,CAAC,CAAC,SAAS,CAAA;CAAE,CAAC,CAAC;AAuBvD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACZ;AAED;;GAEG;AACH,qBAAa,MAAO,SAAQ,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,CAAC;IAC1F,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;gBAE5B,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW;cAYvC,MAAM;IAIzB,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;cAIpC,aAAa,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE;CAG1D"}

package/script/src/tools/scorer.js

@@ -1,12 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeScoreSchema = makeScoreSchema;
-exports.score = score;
-exports.scoreBatch = scoreBatch;
-const index_js_1 = require("../../deps/jsr.io/@zod/zod/4.1.12/src/index.js");
-const async_js_1 = require("../async.js");
-const openai_js_1 = require("../openai.js");
-const utils_js_1 = require("../utils.js");
+exports.Scorer = void 0;
+const index_js_1 = require("../../deps/jsr.io/@zod/zod/4.3.6/src/index.js");
+const tool_js_1 = require("../tool.js");
+const utils_js_1 = require("../helpers/utils.js");
 const PROMPT = (0, utils_js_1.dedent)(`
 # Instructions
 
@@ -33,27 +30,34 @@ function makeScoreSchema(type, min, max, description) {
         schema = index_js_1.z.number().min(min).max(max).describe(description);
     }
     return index_js_1.z.object({
-        value: schema
+        value: schema,
     });
 }
 /**
- * Assumes only remaining placeholder in prompt is {record}
+ * A tool that scores records based on configured criteria.
  */
-async function score(record, prompt, schema, model = 'gpt-4.1-mini') {
-    const renderedPrompt = prompt.replace('record', JSON.stringify(record, null, 2));
-    const response = await (0, openai_js_1.askOpenAISafe)(renderedPrompt, model, schema);
-    if (response.parsed == null) {
-        throw new Error('Failed to parse score from OpenAI response');
+class Scorer extends tool_js_1.Tool {
+    scoreSchema;
+    promptTemplate;
+    constructor(config, modelConfig) {
+        super(modelConfig);
+        const { name, description, type, min, max } = config;
+        this.scoreSchema = makeScoreSchema(type, min, max, description);
+        this.promptTemplate = PROMPT
+            .replace('{name}', name)
+            .replace('{type}', type)
+            .replace('{min}', min.toString())
+            .replace('{max}', max.toString())
+            .replace('{description}', description);
+    }
+    schema() {
+        return this.scoreSchema;
+    }
+    prompt(record) {
+        return this.promptTemplate.replace('{record}', JSON.stringify(record, null, 2));
+    }
+    extractResult(parsed) {
+        return parsed.value;
     }
-    return response.parsed.value;
-}
-async function scoreBatch(records, name, description, type, min, max, model = 'gpt-4.1-mini', maxConcurrency = 100) {
-    const schema = makeScoreSchema(type, min, max, description);
-    const prompt = PROMPT
-        .replace('{name}', name)
-        .replace('{type}', type)
-        .replace('{min}', min.toString())
-        .replace('{max}', max.toString())
-        .replace('{description}', description);
-    return (0, async_js_1.mapParallel)(records, maxConcurrency, (record) => score(record, prompt, schema, model));
 }
+exports.Scorer = Scorer;

package/script/src/tools/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/src/tools/search.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAK3H,YAAY,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,EAClC,MAAM,EACN,KAAsB,EACtB,SAAgB,EAChB,cAAqB,EACrB,WAAmB,EACnB,eAAuB,EACvB,UAAyB,EACzB,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAqBvC;AAqED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EAAE,EACzC,MAAM,EACN,KAAK,EACL,cAAc,EACd,SAAgB,EAChB,cAAqB,EACrB,WAAsB,EACtB,eAAuB,EACvB,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CA0BxC;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,EAC3B,OAAO,EACP,KAAsB,EACtB,SAAgB,EAChB,cAAqB,EACrB,WAAsB,EACtB,eAAuB,EACvB,cAAoB,EACpB,EAAE,kBAAkB,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAanD"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/src/tools/search.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AA0B3H,YAAY,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,EAClC,MAAM,EACN,KAAsB,EACtB,SAAgB,EAChB,cAAqB,EACrB,WAAmB,EACnB,eAAuB,EACvB,UAAyB,EACzB,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CA4BvC;AAqED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EAAE,EACzC,MAAM,EACN,KAAK,EACL,cAAc,EACd,SAAgB,EAChB,cAAqB,EACrB,WAAsB,EACtB,eAAuB,EACvB,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CA0BxC;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,EAC3B,OAAO,EACP,KAAsB,EACtB,SAAgB,EAChB,cAAqB,EACrB,WAAsB,EACtB,eAAuB,EACvB,cAAoB,EACpB,EAAE,kBAAkB,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAanD"}