@aid-framework/runtime 0.0.0-stage → 0.1.39

package/dist/steps.js

@@ -0,0 +1,199 @@
+/**
+ * Leaf pipeline steps: `generate`, `retrieve`, `tool` and `emit`.
+ *
+ * `pipeline.ts` runs steps and `control.ts` composes them; this module is the third
+ * part of the family and builds the leaves a pipeline actually reaches the outside
+ * world with. Each factory returns an ordinary {@link CompositeStep}, so a leaf
+ * composes with a composite by the same rule.
+ *
+ * Why these exist at all: a generated application inlines its steps as hand-written
+ * async functions, which leaves a caller who is *not* the generator -- a test, a
+ * conformance runner, a hand-built pipeline -- with no way to drive one step kind
+ * without re-writing the primitive's call and its binding rule. That duplication is
+ * where the two disagree. A step here is the same primitive the generator calls:
+ *
+ * - `retrieve` calls {@link RetrieverSeam.retrieve} and binds the `RetrievalResult`.
+ * - `tool` calls {@link ToolExecutor.execute} and binds what the tool returned,
+ *   refusing an error outcome and parsing the content.
+ * - `generate` renders a prompt, calls {@link ModelGateway.generate}, and runs the
+ *   structured path when the caller names an output type.
+ * - `emit` projects the context into the event fields a caller names.
+ *
+ * Every factory takes its inputs **already resolved**: the query string, the argument
+ * mapping, the prompt values. Interpolating a spec template against the context is the
+ * *emitted step body's* job, and a second implementation of it here would be a second
+ * thing to keep in step with the generator's. What is not duplicated is the part that
+ * is the same for every caller: the primitive call, the error contract, the parse, and
+ * the name the result is bound under.
+ *
+ * `emit` is the one leaf whose whole behaviour is reading the context, so
+ * {@link resolveSource} lives here rather than in a caller: a field's source is a
+ * binding name, optionally followed by one attribute, which is exactly the reference
+ * path the generator derives for the same field.
+ */
+import { PipelineError } from './errors.js';
+import { repr } from './internal/json.js';
+import { parseStructured, runStructured } from './structured.js';
+import { CompletionRequest, Message, ToolCall } from './types.js';
+/**
+ * The context key an `emit` step binds its projected payload under.
+ *
+ * Deliberately *not* in `RESERVED_KEYS`. That set is mirrored in the generator and
+ * pinned against the runtime by a generator test, so a seventh entry would have to be
+ * emitted as well -- and the generated applications do not compose their response
+ * through this step yet. A generated route keeps building its event object itself;
+ * adding the key here would reserve a spec name for a step the emitted apps never
+ * call. {@link emitStep} takes the key as an option so the generator can adopt it
+ * under its own name when it does.
+ */
+export const EMITTED_KEY = 'emitted';
+/**
+ * Name a step's callable, so a trace and {@link Pipeline.of} identify it.
+ *
+ * `Pipeline.of` reads `step.name`, so this is the same mechanism as Python assigning
+ * `__name__` -- the two runtimes name a leaf identically rather than one of them
+ * requiring an explicit name at construction.
+ */
+function named(step, name) {
+    if (name !== undefined) {
+        Object.defineProperty(step, 'name', { value: name, configurable: true });
+    }
+    return step;
+}
+/**
+ * One `emit` field's value: a binding, then at most one attribute below it.
+ *
+ * The one-segment form is the request event's or a scalar binding's whole value; the
+ * two-segment form is a struct's field. Deeper paths are not accepted, because the
+ * spec layer's reference paths stop at one field and this resolver exists to read
+ * exactly what the generator reads.
+ *
+ * A missing binding is a {@link PipelineError} naming the key -- the same refusal
+ * {@link PipelineContext.require} makes -- and a missing attribute is one naming both
+ * the source and the field, because "the field is not there" and "the binding is not
+ * there" are different mistakes and both mean the response would be wrong.
+ */
+export function resolveSource(context, source) {
+    const dot = source.indexOf('.');
+    const root = dot === -1 ? source : source.slice(0, dot);
+    const attribute = dot === -1 ? '' : source.slice(dot + 1);
+    const value = context.require(root);
+    if (attribute === '')
+        return value;
+    if (attribute.includes('.')) {
+        throw new PipelineError(`emit source ${repr(source)} names more than one attribute below ${repr(root)}; ` +
+            'a field is read from a binding or one struct below it');
+    }
+    // An *own* property: that is where a declared field lands both in an object parsed
+    // from JSON and in a class that assigns its fields, and it keeps `toString` and
+    // `constructor` from reading as fields of every struct.
+    const fields = value;
+    if (typeof value !== 'object' || fields === null || !Object.hasOwn(fields, attribute)) {
+        throw new PipelineError(`emit source ${repr(source)} names the field ${repr(attribute)}, which the ` +
+            `${repr(root)} binding does not carry`);
+    }
+    return fields[attribute];
+}
+/**
+ * Build the event payload from the context, field by field.
+ *
+ * `fields` maps each event field to its source, in the order the caller declared
+ * them: an insertion-ordered mapping keeps the payload's own order stable, so a
+ * projection that reorders its fields is observable rather than invisible. Each source
+ * is a binding name or a `binding.attribute` path, which is the shape the generator
+ * derives for the same field via `responsePlan`.
+ *
+ * The step **binds** its payload and does not stop the pipeline. Stopping would lose
+ * it: both runtimes carry the *pre-step* context out of a stop, so a stopping step
+ * cannot bind anything. A generated route does not stop at its emit either -- it runs
+ * every step and only then builds the response object -- so a later step still runs
+ * after this one, which is the behaviour a pipeline that composed it would see.
+ */
+export function emitStep(fields, options = {}) {
+    const key = options.key ?? EMITTED_KEY;
+    const ordered = Object.entries(fields);
+    return named(async (context) => {
+        const payload = {};
+        for (const [field, source] of ordered)
+            payload[field] = resolveSource(context, source);
+        return context.withValues({ [key]: payload });
+    }, options.name);
+}
+/**
+ * Search `retriever` and bind the cited passages under `binding`.
+ *
+ * `topK` is passed through rather than resolved here, so `undefined` keeps meaning
+ * "the binding's own ceiling" exactly as `Retriever.retrieve` defines it.
+ */
+export function retrieveStep(retriever, options) {
+    return named(async (context) => {
+        const found = await retriever.retrieve(options.query, {
+            topK: options.topK,
+        });
+        return context.withValues({ [options.binding]: found });
+    }, options.name);
+}
+/**
+ * Call `tool` and bind what it returned, refusing an error outcome.
+ *
+ * The call id is the binding name, which makes a trace of a tool step name the value
+ * it produced. An error outcome throws rather than binding a message: a tool the model
+ * called and that failed is not a value the next step can meaningfully read, and the
+ * generator's own step throws for the same reason.
+ *
+ * `output` is the struct to parse the content into when the spec declared a named
+ * output; without one the content is bound as parsed JSON, so a tool declaring
+ * `string` binds the string it returned rather than a re-encoded copy.
+ */
+export function toolStep(tools, options) {
+    return named(async (context) => {
+        const outcome = await tools.execute(new ToolCall({
+            id: options.binding,
+            name: options.tool,
+            arguments: { ...options.arguments },
+        }));
+        if (outcome.isError) {
+            throw new PipelineError(`tool ${options.tool} failed: ${outcome.content}`);
+        }
+        const value = options.output === undefined
+            ? JSON.parse(outcome.content)
+            : parseStructured(outcome.content, options.output);
+        return context.withValues({ [options.binding]: value });
+    }, options.name);
+}
+/**
+ * Render `prompt`, ask `model` for one completion, and bind the answer.
+ *
+ * The call is built once and handed to the structured path as its `call`, so a repair
+ * round re-sends an already-rendered prompt instead of rendering again -- the same
+ * closure the generated step emits, and the reason a retry cannot silently re-read a
+ * binding that changed underneath it.
+ *
+ * `values` are the prompt's own values and are passed to the registry unrendered:
+ * {@link PromptRegistry.render} is the one place a template becomes text. With
+ * `structured` the answer is parsed into that type, and a parse failure throws after
+ * the repair rounds rather than binding a half-valid object.
+ */
+export function generateStep(gateway, prompts, options) {
+    return named(async (context) => {
+        const rendered = prompts.render(options.prompt, options.values ?? {}, options.version);
+        const call = async (text) => {
+            const request = options.temperature === undefined && options.maxOutputTokens === undefined
+                ? CompletionRequest.prompt(text)
+                : new CompletionRequest({
+                    messages: [Message.user(text)],
+                    temperature: options.temperature,
+                    maxOutputTokens: options.maxOutputTokens,
+                });
+            const response = await gateway.generate(options.model, request, {
+                fallbacks: options.fallbacks ?? [],
+            });
+            return response.text;
+        };
+        const value = options.structured === undefined
+            ? await call(rendered.text)
+            : await runStructured(call, options.structured, rendered.text);
+        return context.withValues({ [options.binding]: value });
+    }, options.name);
+}
+//# sourceMappingURL=steps.js.map

package/dist/steps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps.js","sourceRoot":"","sources":["../src/steps.ts"],"names":[],"mappings":"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"}

package/dist/structured.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Structured-output enforcement with a parse-repair loop.
+ *
+ * This is the only place zod is used, and it is used for what it is good at: getting
+ * a typed object out of an untrusted model response. Pipeline control flow is plain
+ * async; zod is a validation dependency here, not an orchestration one.
+ *
+ * Two entry points:
+ *
+ * - {@link parseStructured} coerces already-received text into a typed value.
+ * - {@link runStructured} drives a call-repair-retry loop, feeding the validation
+ *   failure back to the model. This is the difference between "the model must be
+ *   right the first time" and "the model must eventually be right", and only the
+ *   second is an achievable contract.
+ */
+import { z } from 'zod';
+import { StructuredOutputError } from './errors.js';
+/** The correction turn appended after a failed parse. */
+export declare const REPAIR_INSTRUCTION: string;
+/**
+ * A named output schema.
+ *
+ * The name exists because Python's reference implementation reads
+ * `output_type.__name__` and every diagnostic it produces names the type. A zod
+ * schema has no runtime name, so the name is carried alongside it rather than
+ * inferred.
+ */
+export interface StructuredOutput<T> {
+    readonly name: string;
+    readonly schema: z.ZodType<T>;
+}
+/** Name a schema so diagnostics can say which type failed. */
+export declare function structuredOutput<T>(name: string, schema: z.ZodType<T>): StructuredOutput<T>;
+/** The members of a zod issue this module reads. */
+interface Issue {
+    readonly path: readonly PropertyKey[];
+    readonly message: string;
+}
+/** Flatten validation issues into `location: message` strings. */
+export declare function formatProblems(issues: readonly Issue[]): string[];
+/**
+ * Validate `text` as `outputType`.
+ *
+ * Every problem is reported, not just the first: feeding one error back at a time
+ * turns a two-round repair into a five-round one.
+ */
+export declare function parseStructured<T>(text: string, outputType: StructuredOutput<T>): T;
+/**
+ * Call, parse, and on failure ask again with the validation errors attached.
+ *
+ * `retries` counts *repair* attempts beyond the first call, so `retries: 2` means at
+ * most three calls. Throwing after the final attempt is correct: an endpoint that
+ * returns a half-valid object is worse than one that fails loudly.
+ */
+export declare function runStructured<T>(call: (prompt: string) => Promise<string>, outputType: StructuredOutput<T>, prompt: string, options?: {
+    readonly retries?: number;
+}): Promise<T>;
+/** The corrective turn for a failed parse. */
+export declare function repairPrompt(error: StructuredOutputError): string;
+/** The seam a `buildAgent` caller supplies: one prompt in, one model answer out. */
+export interface AgentModel {
+    complete(prompt: string): Promise<string>;
+}
+/** A typed agent: `run` drives the repair loop and returns the parsed value. */
+export declare class StructuredAgent<T> {
+    private readonly _model;
+    private readonly _outputType;
+    private readonly _systemPrompt;
+    private readonly _retries;
+    constructor(model: AgentModel, outputType: StructuredOutput<T>, options?: {
+        readonly systemPrompt?: string;
+        readonly retries?: number;
+    });
+    /** Run one prompt through the model, repairing until the schema validates. */
+    run(prompt: string): Promise<T>;
+}
+/**
+ * Build a typed agent over `outputType`.
+ *
+ * The reference runtime delegates this to Pydantic AI's `Agent`. The TypeScript
+ * runtime has no equivalent, so this is the same contract implemented against the
+ * repair loop above -- typed output with retries -- rather than a new orchestration
+ * layer.
+ */
+export declare function buildAgent<T>(model: AgentModel, outputType: StructuredOutput<T>, options?: {
+    readonly systemPrompt?: string;
+    readonly retries?: number;
+}): StructuredAgent<T>;
+/** Re-export zod so generated code can declare schemas without a second dependency. */
+export { z };
+//# sourceMappingURL=structured.d.ts.map

package/dist/structured.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured.d.ts","sourceRoot":"","sources":["../src/structured.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEpD,yDAAyD;AACzD,eAAO,MAAM,kBAAkB,QAE6B,CAAC;AAE7D;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;CAC/B;AAED,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAG3F;AAED,oDAAoD;AACpD,UAAU,KAAK;IACb,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,kEAAkE;AAClE,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,MAAM,EAAE,CAKjE;AA0BD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,CAqBnF;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,EACzC,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC/B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAC1C,OAAO,CAAC,CAAC,CAAC,CAuBZ;AAED,8CAA8C;AAC9C,wBAAgB,YAAY,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAGjE;AAED,oFAAoF;AACpF,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3C;AAED,gFAAgF;AAChF,qBAAa,eAAe,CAAC,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IACpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsB;IAClD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IACnD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,YACE,KAAK,EAAE,UAAU,EACjB,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC/B,OAAO,GAAE;QAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO,EAM5E;IAED,8EAA8E;IACxE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAMpC;CACF;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,KAAK,EAAE,UAAU,EACjB,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC/B,OAAO,GAAE;IAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAC1E,eAAe,CAAC,CAAC,CAAC,CAEpB;AAED,uFAAuF;AACvF,OAAO,EAAE,CAAC,EAAE,CAAC"}

package/dist/structured.js

@@ -0,0 +1,155 @@
+/**
+ * Structured-output enforcement with a parse-repair loop.
+ *
+ * This is the only place zod is used, and it is used for what it is good at: getting
+ * a typed object out of an untrusted model response. Pipeline control flow is plain
+ * async; zod is a validation dependency here, not an orchestration one.
+ *
+ * Two entry points:
+ *
+ * - {@link parseStructured} coerces already-received text into a typed value.
+ * - {@link runStructured} drives a call-repair-retry loop, feeding the validation
+ *   failure back to the model. This is the difference between "the model must be
+ *   right the first time" and "the model must eventually be right", and only the
+ *   second is an achievable contract.
+ */
+import { z } from 'zod';
+import { StructuredOutputError } from './errors.js';
+/** The correction turn appended after a failed parse. */
+export const REPAIR_INSTRUCTION = 'Your previous response could not be parsed. Reply with corrected JSON only, ' +
+    'matching the required schema exactly. Errors: {problems}';
+/** Name a schema so diagnostics can say which type failed. */
+export function structuredOutput(name, schema) {
+    if (name.length === 0)
+        throw new RangeError('a structured output type needs a name');
+    return { name, schema };
+}
+/** Flatten validation issues into `location: message` strings. */
+export function formatProblems(issues) {
+    return issues.map((issue) => {
+        const location = issue.path.map((part) => String(part)).join('.') || '<root>';
+        return `${location}: ${issue.message}`;
+    });
+}
+/**
+ * Remove a ```json fence if the model wrapped its answer in one.
+ *
+ * Models do this constantly when asked for JSON. Treating a valid payload as invalid
+ * because of presentation is a self-inflicted repair loop.
+ */
+function stripCodeFence(text) {
+    const stripped = text.trim();
+    if (!stripped.startsWith('```'))
+        return stripped;
+    const lines = stripped.split('\n');
+    if (lines.length < 2)
+        return stripped;
+    const body = lines.slice(1);
+    const last = body.at(-1);
+    if (last?.trim().startsWith('```'))
+        body.pop();
+    return body.join('\n');
+}
+function invalidJson(outputType) {
+    return new StructuredOutputError(`output did not validate as ${outputType.name}`, {
+        attempts: 1,
+        problems: ['<root>: invalid JSON'],
+    });
+}
+/**
+ * Validate `text` as `outputType`.
+ *
+ * Every problem is reported, not just the first: feeding one error back at a time
+ * turns a two-round repair into a five-round one.
+ */
+export function parseStructured(text, outputType) {
+    const stripped = stripCodeFence(text).trim();
+    if (stripped.length === 0) {
+        throw new StructuredOutputError(`model returned empty output for ${outputType.name}`, {
+            attempts: 1,
+        });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stripped);
+    }
+    catch {
+        throw invalidJson(outputType);
+    }
+    const result = outputType.schema.safeParse(parsed);
+    if (!result.success) {
+        throw new StructuredOutputError(`output did not validate as ${outputType.name}`, {
+            attempts: 1,
+            problems: formatProblems(result.error.issues),
+        });
+    }
+    return result.data;
+}
+/**
+ * Call, parse, and on failure ask again with the validation errors attached.
+ *
+ * `retries` counts *repair* attempts beyond the first call, so `retries: 2` means at
+ * most three calls. Throwing after the final attempt is correct: an endpoint that
+ * returns a half-valid object is worse than one that fails loudly.
+ */
+export async function runStructured(call, outputType, prompt, options = {}) {
+    const retries = options.retries ?? 2;
+    if (retries < 0)
+        throw new RangeError('retries must not be negative');
+    let current = prompt;
+    let problems = [];
+    for (let attempt = 1; attempt <= retries + 1; attempt += 1) {
+        const text = await call(current);
+        try {
+            return parseStructured(text, outputType);
+        }
+        catch (error) {
+            if (!(error instanceof StructuredOutputError))
+                throw error;
+            problems = [...error.problems];
+            if (attempt <= retries) {
+                current = `${prompt}\n\n${repairPrompt(error)}`;
+            }
+        }
+    }
+    throw new StructuredOutputError(`${outputType.name} not produced from ${retries + 1} attempt(s)`, { attempts: retries + 1, problems });
+}
+/** The corrective turn for a failed parse. */
+export function repairPrompt(error) {
+    const problems = error.problems.length > 0 ? error.problems.join('; ') : error.message;
+    return REPAIR_INSTRUCTION.replace('{problems}', () => problems);
+}
+/** A typed agent: `run` drives the repair loop and returns the parsed value. */
+export class StructuredAgent {
+    _model;
+    _outputType;
+    _systemPrompt;
+    _retries;
+    constructor(model, outputType, options = {}) {
+        this._model = model;
+        this._outputType = outputType;
+        this._systemPrompt = options.systemPrompt;
+        this._retries = options.retries ?? 2;
+    }
+    /** Run one prompt through the model, repairing until the schema validates. */
+    async run(prompt) {
+        const composed = this._systemPrompt === undefined ? prompt : `${this._systemPrompt}\n\n${prompt}`;
+        return runStructured((current) => this._model.complete(current), this._outputType, composed, {
+            retries: this._retries,
+        });
+    }
+}
+/**
+ * Build a typed agent over `outputType`.
+ *
+ * The reference runtime delegates this to Pydantic AI's `Agent`. The TypeScript
+ * runtime has no equivalent, so this is the same contract implemented against the
+ * repair loop above -- typed output with retries -- rather than a new orchestration
+ * layer.
+ */
+export function buildAgent(model, outputType, options = {}) {
+    return new StructuredAgent(model, outputType, options);
+}
+/** Re-export zod so generated code can declare schemas without a second dependency. */
+export { z };
+//# sourceMappingURL=structured.js.map

package/dist/structured.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured.js","sourceRoot":"","sources":["../src/structured.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEpD,yDAAyD;AACzD,MAAM,CAAC,MAAM,kBAAkB,GAC7B,8EAA8E;IAC9E,0DAA0D,CAAC;AAe7D,8DAA8D;AAC9D,MAAM,UAAU,gBAAgB,CAAI,IAAY,EAAE,MAAoB;IACpE,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,uCAAuC,CAAC,CAAC;IACrF,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AAC1B,CAAC;AAQD,kEAAkE;AAClE,MAAM,UAAU,cAAc,CAAC,MAAwB;IACrD,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC1B,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC;QAC9E,OAAO,GAAG,QAAQ,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC;IACzC,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,SAAS,cAAc,CAAC,IAAY;IAClC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAC7B,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC;QAAE,OAAO,QAAQ,CAAC;IACjD,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,QAAQ,CAAC;IACtC,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACzB,IAAI,IAAI,EAAE,IAAI,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC;QAAE,IAAI,CAAC,GAAG,EAAE,CAAC;IAC/C,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACzB,CAAC;AAED,SAAS,WAAW,CAAC,UAAqC;IACxD,OAAO,IAAI,qBAAqB,CAAC,8BAA8B,UAAU,CAAC,IAAI,EAAE,EAAE;QAChF,QAAQ,EAAE,CAAC;QACX,QAAQ,EAAE,CAAC,sBAAsB,CAAC;KACnC,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAI,IAAY,EAAE,UAA+B;IAC9E,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;IAC7C,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,qBAAqB,CAAC,mCAAmC,UAAU,CAAC,IAAI,EAAE,EAAE;YACpF,QAAQ,EAAE,CAAC;SACZ,CAAC,CAAC;IACL,CAAC;IACD,IAAI,MAAe,CAAC;IACpB,IAAI,CAAC;QACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,WAAW,CAAC,UAAU,CAAC,CAAC;IAChC,CAAC;IACD,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACnD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,IAAI,qBAAqB,CAAC,8BAA8B,UAAU,CAAC,IAAI,EAAE,EAAE;YAC/E,QAAQ,EAAE,CAAC;YACX,QAAQ,EAAE,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC;SAC9C,CAAC,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,IAAyC,EACzC,UAA+B,EAC/B,MAAc,EACd,OAAO,GAAkC,EAAE;IAE3C,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,CAAC,CAAC;IACrC,IAAI,OAAO,GAAG,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,8BAA8B,CAAC,CAAC;IAEtE,IAAI,OAAO,GAAG,MAAM,CAAC;IACrB,IAAI,QAAQ,GAAa,EAAE,CAAC;IAC5B,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,CAAC,EAAE,CAAC;QAC3D,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC;YACH,OAAO,eAAe,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAC3C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,CAAC,KAAK,YAAY,qBAAqB,CAAC;gBAAE,MAAM,KAAK,CAAC;YAC3D,QAAQ,GAAG,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC;YAC/B,IAAI,OAAO,IAAI,OAAO,EAAE,CAAC;gBACvB,OAAO,GAAG,GAAG,MAAM,OAAO,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;YAClD,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,IAAI,qBAAqB,CAC7B,GAAG,UAAU,CAAC,IAAI,sBAAsB,OAAO,GAAG,CAAC,aAAa,EAChE,EAAE,QAAQ,EAAE,OAAO,GAAG,CAAC,EAAE,QAAQ,EAAE,CACpC,CAAC;AACJ,CAAC;AAED,8CAA8C;AAC9C,MAAM,UAAU,YAAY,CAAC,KAA4B;IACvD,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC;IACvF,OAAO,kBAAkB,CAAC,OAAO,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC;AAClE,CAAC;AAOD,gFAAgF;AAChF,MAAM,OAAO,eAAe;IACT,MAAM,CAAa;IACnB,WAAW,CAAsB;IACjC,aAAa,CAAqB;IAClC,QAAQ,CAAS;IAElC,YACE,KAAiB,EACjB,UAA+B,EAC/B,OAAO,GAAkE,EAAE;QAE3E,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAC9B,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;QAC1C,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,OAAO,IAAI,CAAC,CAAC;IACvC,CAAC;IAED,8EAA8E;IAC9E,KAAK,CAAC,GAAG,CAAC,MAAc;QACtB,MAAM,QAAQ,GACZ,IAAI,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,OAAO,MAAM,EAAE,CAAC;QACnF,OAAO,aAAa,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE;YAC3F,OAAO,EAAE,IAAI,CAAC,QAAQ;SACvB,CAAC,CAAC;IACL,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,UAAU,CACxB,KAAiB,EACjB,UAA+B,EAC/B,OAAO,GAAkE,EAAE;IAE3E,OAAO,IAAI,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;AACzD,CAAC;AAED,uFAAuF;AACvF,OAAO,EAAE,CAAC,EAAE,CAAC"}

package/dist/tools.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Tool dispatch with schema validation.
+ *
+ * The one place this module cannot mirror the reference runtime is the seam itself:
+ * Python infers a tool's JSON schema from `inspect.signature` and a docstring, and
+ * JavaScript has neither. So the schema is declared explicitly and validated against
+ * the tool set here instead -- the runtime's job is to refuse a *wrong* invocation,
+ * and that job is identical either way.
+ *
+ * The validator implements a deliberate subset of JSON Schema: `type`, `required`
+ * and `additionalProperties: false`. That subset is documented rather than silently
+ * partial, and an unknown `type` value is treated as unconstrained instead of
+ * failing, because a schema written for a newer draft must not reject every call.
+ */
+import type { ConcurrencyLimiter } from './concurrency.js';
+import { type ToolCall, ToolDefinition, ToolResult } from './types.js';
+/** A handler receives validated arguments and may return anything serialisable. */
+export type ToolHandler = (args: Record<string, unknown>) => unknown | Promise<unknown>;
+/** The JSON-Schema subset this validator enforces. */
+export interface ToolParameters {
+    readonly type?: string;
+    readonly properties?: Readonly<Record<string, {
+        readonly type?: string;
+    }>>;
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean;
+}
+/** A registered tool: its public definition plus the code behind it. */
+export declare class Tool {
+    readonly definition_: ToolDefinition;
+    readonly handler: ToolHandler;
+    constructor(init: {
+        readonly name: string;
+        readonly handler: ToolHandler;
+        readonly description?: string;
+        readonly parameters?: ToolParameters;
+    });
+    /**
+     * Declare a tool.
+     *
+     * `parameters` is required where Python would infer it. A schema whose `required`
+     * list names a property it does not define is a wiring mistake, and it is reported
+     * here rather than at the first call: that is the same failure Python reports as
+     * "not accepted by the handler", just discovered from the other direction.
+     */
+    static of(init: {
+        readonly name: string;
+        readonly handler: ToolHandler;
+        readonly description?: string;
+        readonly parameters?: ToolParameters;
+    }): Tool;
+    get name(): string;
+    get definition(): ToolDefinition;
+    private checkSchema;
+}
+/**
+ * Validate `args` against `schema`, returning every problem rather than the first.
+ *
+ * Returning all problems is what makes a single repair turn enough: a model told
+ * about one bad field per round trips once per field.
+ */
+export declare function validateArguments(schema: ToolParameters, args: unknown): string[];
+/**
+ * A set of tools, and the dispatcher for them.
+ *
+ * `strict` decides what a crashing handler means. The default is to hand the model
+ * an error result so it can react; strict mode rethrows, because a caller that has
+ * already decided a crash is a bug should not have to inspect a result to find out.
+ */
+export declare class ToolExecutor {
+    private readonly _tools;
+    private readonly _strict;
+    private readonly _limiter;
+    constructor(tools?: Iterable<Tool>, options?: {
+        readonly strict?: boolean;
+        readonly limiter?: ConcurrencyLimiter;
+    });
+    /** The registered names, sorted. */
+    names(): string[];
+    /** Add a tool. A duplicate name replaces, because a registry is a map. */
+    register(tool: Tool): void;
+    /** One tool's public definition. */
+    definition(name: string): ToolDefinition;
+    /** Every registered definition, ordered by name. */
+    definitions(): ToolDefinition[];
+    /** Whether a name is registered. */
+    has(name: string): boolean;
+    /**
+     * Run one call.
+     *
+     * An unknown tool throws: that is a wiring error in generated code, not something
+     * a model can fix by trying again with the same name.
+     */
+    execute(call: ToolCall): Promise<ToolResult>;
+    private dispatch;
+    /** Run calls in order. Sequential on purpose: a tool set is a transcript, not a race. */
+    executeAll(calls: Iterable<ToolCall>): Promise<ToolResult[]>;
+    private require;
+}
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"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"}