@spendgraph/tools 0.5.0 → 0.6.0

package/dist/bus/select.js

@@ -1,44 +1 @@
-import { score } from "./score.js";
-export function selectTools(tools, calls, declare, query, ceiling) {
-    const terms = query
-        .toLowerCase()
-        .split(/[^a-z0-9]+/)
-        .filter(Boolean);
-    const chosen = [];
-    const take = (t) => {
-        if (!chosen.includes(t) && chosen.length < ceiling)
-            chosen.push(t);
-    };
-    for (const t of tools)
-        if (t.pinned)
-            take(t);
-    const rest = tools.filter((t) => !t.pinned);
-    const ranked = rest
-        .map((t) => ({ t, n: score(t, terms) }))
-        .filter((x) => x.n > 0)
-        .sort((a, b) => b.n - a.n || (calls.get(b.t.name) ?? 0) - (calls.get(a.t.name) ?? 0));
-    const room = ceiling - chosen.length;
-    const decisive = ranked.length > 1 && ranked[0].n >= ranked[1].n * 2;
-    const budget = chosen.length + (decisive ? Math.min(3, room) : room);
-    for (const { t } of ranked) {
-        if (chosen.length >= budget)
-            break;
-        take(t);
-    }
-    const byUse = [...rest].sort((a, b) => (calls.get(b.name) ?? 0) - (calls.get(a.name) ?? 0));
-    for (const t of byUse) {
-        if (chosen.length >= budget)
-            break;
-        if ((calls.get(t.name) ?? 0) === 0)
-            break;
-        take(t);
-    }
-    if (ranked.length === 0) {
-        for (const t of rest) {
-            if (chosen.length >= ceiling)
-                break;
-            take(t);
-        }
-    }
-    return chosen.map(declare);
-}
+import{termsIn as u}from"./terms.js";function v(m,e,h,a,p,f){const d=u(p),n=[],r=t=>{!n.includes(t)&&n.length<f&&n.push(t)};for(const t of m)t.pinned&&r(t);const i=m.filter(t=>!t.pinned),o=i.map(t=>({t,n:a(t,d)})).filter(t=>t.n>0).sort((t,s)=>s.n-t.n||(e.get(s.t.name)??0)-(e.get(t.t.name)??0)),c=f-n.length,k=o.length>1&&o[0].n>=o[1].n*2,g=n.length+(k?Math.min(3,c):c);for(const{t}of o){if(n.length>=g)break;r(t)}const b=[...i].sort((t,s)=>(e.get(s.name)??0)-(e.get(t.name)??0));for(const t of b){if(n.length>=g||(e.get(t.name)??0)===0)break;r(t)}if(o.length===0)for(const t of i){if(n.length>=f)break;r(t)}return n.map(h)}export{v as selectTools};

package/dist/bus/step.js

@@ -1,11 +1 @@
-export function toStep(result, index) {
-    return {
-        index,
-        source: result.name,
-        input: result.args,
-        output: result.output,
-        status: result.status,
-        error: result.error,
-        latencyMs: result.latencyMs,
-    };
-}
+function n(t,o){return{index:o,source:t.name,input:t.args,output:t.output,status:t.status,error:t.error,latencyMs:t.latencyMs}}export{n as toStep};

package/dist/bus/terms.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A string as the words selection compares.
+ *
+ * Split on anything that is not a letter or a number **in any script**, rather
+ * than on `[^a-z0-9]`. That was the whole of the tokenizer, so a query with no
+ * ASCII letters produced no terms at all, nothing scored, and every request
+ * fell through to "the first six tools declared" — the same six for "返金して"
+ * as for "верните деньги", whatever the bus held.
+ *
+ * Diacritics are folded so `réfund` and `refund` are one word. Both sides are
+ * folded, so it holds for a tool named in a language that uses them as much as
+ * for a query typed in one.
+ */
+export declare function fold(text: string): string;
+export declare function termsIn(text: string): string[];
+/**
+ * How many tools to offer, from what the caller asked for.
+ *
+ * `NaN` is refused rather than clamped. `Math.max(1, NaN)` is `NaN`, and
+ * `chosen.length < NaN` is false for every length, so a `NaN` ceiling offered
+ * the model **nothing** — the one outcome this file's own reasoning rules out:
+ * "an agent handed no tools cannot act". `Number(process.env.TOOL_LIMIT)` on an
+ * unset variable is how it arrives without anyone typing it.
+ */
+export declare function ceilingFor(limit: number | undefined, fallback: number): number;

package/dist/bus/terms.js

@@ -0,0 +1 @@
+function f(e){return e.toLowerCase().normalize("NFD").replace(/\p{M}+/gu,"")}const r=typeof Intl<"u"&&"Segmenter"in Intl?new Intl.Segmenter(void 0,{granularity:"word"}):void 0;function i(e){const n=f(e);if(!r)return n.split(/[^\p{L}\p{N}]+/u).filter(Boolean);const o=[];for(const t of r.segment(n))t.isWordLike&&o.push(t.segment);return o}function u(e,n){if(e===void 0)return n;if(Number.isNaN(e))throw new Error(`A tool limit of ${e} is not a limit \u2014 nothing would ever be offered. Pass a count, or leave it out for the bus default.`);return Math.max(1,Math.floor(e))}export{u as ceilingFor,f as fold,i as termsIn};

package/dist/bus/trace.js

@@ -1,22 +1 @@
-import { toAnthropic, toMarkdown, toOpenAI, } from "../wire/index.js";
-import { toStep } from "./step.js";
-export function newTrace(offered, invoke) {
-    const steps = [];
-    return {
-        offered,
-        anthropic: () => toAnthropic(offered),
-        openai: () => toOpenAI(offered),
-        markdown: (heading) => toMarkdown(offered, heading),
-        effectOf: (name) => offered.find((d) => d.name === name)?.effect,
-        invoke: async (name, args) => {
-            const result = await invoke(name, args);
-            steps.push(toStep(result, steps.length));
-            return result;
-        },
-        steps: () => [...steps],
-        record: () => ({
-            offeredTools: offered.map((d) => d.name),
-            steps: [...steps],
-        }),
-    };
-}
+import{toAnthropic as s,toMarkdown as a,toOpenAI as c}from"../wire/index.js";import{toStep as i}from"./step.js";function h(n,r){const o=[];return{offered:n,anthropic:()=>s(n),openai:()=>c(n),markdown:t=>a(n,t),effectOf:t=>n.find(e=>e.name===t)?.effect,invoke:async(t,e)=>{const p=await r(t,e);return o.push(i(p,o.length)),p},steps:()=>[...o],record:()=>({offeredTools:n.map(t=>t.name),steps:[...o]})}}export{h as newTrace};

package/dist/index.d.ts

@@ -1,6 +1,16 @@
-export { type ArtifactFormat, answerOf, type ClockOptions, CommissionAbortedError, type CommissionClient, CommissionTimeoutError, calculate, currentTime, DEFAULT_DESIGN, type DeepRecallOptions, type DesignGuide, dateMath, deepRecall, type EscalateOptions, type EscalationRequest, escalate, type Finished, finish, type HttpOptions, httpRequest, isFinished, type JsonQueryOptions, jsonQuery, mergeDesign, renderDesign, type SearchDepth, think, type WebSearchOptions, type WriteDocumentOptions, webSearch, writeDocument, } from "./builtin/index.js";
-export type { ToolBus, ToolBusOptions, ToolTrace } from "./bus/index.js";
-export { toolbus } from "./bus/index.js";
+/**
+ * What `bus.anthropic()`, `bus.openai()` and `turn.record()` hand back.
+ *
+ * On the main entry because the functions that return them are: naming the
+ * result of a method you called from here should not send you to a second
+ * subpath, or to a second package. `@spendgraph/tools/wire` still holds the
+ * converters themselves, for a caller adapting a declaration by hand.
+ */
+export type { RolloutStep } from "@spendgraph/sdk";
+export { type ArtifactFormat, answerOf, type ClockOptions, type CodeExecOptions, CommissionAbortedError, type CommissionClient, CommissionTimeoutError, calculate, codeExec, currentTime, DEFAULT_DESIGN, type DeepRecallOptions, type DesignGuide, dateMath, deepRecall, type EscalateOptions, type EscalationRequest, escalate, type Finished, finish, type HttpOptions, httpRequest, isFinished, type JsonQueryOptions, jsonQuery, mergeDesign, type RecalledFact, type Recaller, type RecallResult, renderDesign, type Sandbox, type SandboxRequest, type SandboxResult, type SearchDepth, think, type WebSearchOptions, type WriteDocumentOptions, webSearch, writeDocument, } from "./builtin/index.js";
+export type { BusMember, ToolBus, ToolBusOptions, ToolTrace } from "./bus/index.js";
+export { busgroup, toolbus } from "./bus/index.js";
 export type { BoundSpec, ToolSpec } from "./tool/index.js";
 export { bindTool, ToolDriftError, ToolNotStoredError, tool } from "./tool/index.js";
 export type { ArgSpec, ArgsOf, ArgValue, Effect, Tool, ToolDeclaration, ToolResult, } from "./types/index.js";
+export type { AnthropicTool, JsonSchema, JsonSchemaProperty, OpenAITool, } from "./wire/index.js";

package/dist/index.js

@@ -1,3 +1 @@
-export { answerOf, CommissionAbortedError, CommissionTimeoutError, calculate, currentTime, DEFAULT_DESIGN, dateMath, deepRecall, escalate, finish, httpRequest, isFinished, jsonQuery, mergeDesign, renderDesign, think, webSearch, writeDocument, } from "./builtin/index.js";
-export { toolbus } from "./bus/index.js";
-export { bindTool, ToolDriftError, ToolNotStoredError, tool } from "./tool/index.js";
+import{answerOf as r,CommissionAbortedError as t,CommissionTimeoutError as i,calculate as s,codeExec as n,currentTime as m,DEFAULT_DESIGN as l,dateMath as a,deepRecall as c,escalate as u,finish as d,httpRequest as E,isFinished as f,jsonQuery as h,mergeDesign as p,renderDesign as D,think as T,webSearch as b,writeDocument as g}from"./builtin/index.js";import{busgroup as w,toolbus as S}from"./bus/index.js";import{bindTool as C,ToolDriftError as F,ToolNotStoredError as N,tool as R}from"./tool/index.js";export{t as CommissionAbortedError,i as CommissionTimeoutError,l as DEFAULT_DESIGN,F as ToolDriftError,N as ToolNotStoredError,r as answerOf,C as bindTool,w as busgroup,s as calculate,n as codeExec,m as currentTime,a as dateMath,c as deepRecall,u as escalate,d as finish,E as httpRequest,f as isFinished,h as jsonQuery,p as mergeDesign,D as renderDesign,T as think,R as tool,S as toolbus,b as webSearch,g as writeDocument};

package/dist/internals.d.ts

@@ -10,7 +10,7 @@ export { checkUrl } from "./builtin/http/index.js";
 export { readPath } from "./builtin/json/index.js";
 export { invokeTool } from "./bus/invoke.js";
 export { warnOnOverlap } from "./bus/overlap.js";
-export { score } from "./bus/score.js";
+export { type Describable, type Scorer, scorerFor } from "./bus/score.js";
 export { selectTools } from "./bus/select.js";
 export { toStep } from "./bus/step.js";
 export { newTrace } from "./bus/trace.js";

package/dist/internals.js

@@ -1,10 +1 @@
-export { evaluate } from "./builtin/calculate/index.js";
-export { between, parseDate, shift } from "./builtin/date/index.js";
-export { checkUrl } from "./builtin/http/index.js";
-export { readPath } from "./builtin/json/index.js";
-export { invokeTool } from "./bus/invoke.js";
-export { warnOnOverlap } from "./bus/overlap.js";
-export { score } from "./bus/score.js";
-export { selectTools } from "./bus/select.js";
-export { toStep } from "./bus/step.js";
-export { newTrace } from "./bus/trace.js";
+import{evaluate as e}from"./builtin/calculate/index.js";import{between as p,parseDate as f,shift as m}from"./builtin/date/index.js";import{checkUrl as a}from"./builtin/http/index.js";import{readPath as c}from"./builtin/json/index.js";import{invokeTool as s}from"./bus/invoke.js";import{warnOnOverlap as v}from"./bus/overlap.js";import{scorerFor as T}from"./bus/score.js";import{selectTools as k}from"./bus/select.js";import{toStep as b}from"./bus/step.js";import{newTrace as u}from"./bus/trace.js";export{p as between,a as checkUrl,e as evaluate,s as invokeTool,u as newTrace,f as parseDate,c as readPath,T as scorerFor,k as selectTools,m as shift,b as toStep,v as warnOnOverlap};

package/dist/tool/bind.js

@@ -1,64 +1 @@
-import { tool } from "./tool.js";
-export class ToolDriftError extends Error {
-    toolName;
-    differences;
-    constructor(toolName, differences) {
-        super(`Tool "${toolName}" is stored differently from the code binding it: ${differences.join("; ")}.`);
-        this.toolName = toolName;
-        this.differences = differences;
-        this.name = "ToolDriftError";
-    }
-}
-export class ToolNotStoredError extends Error {
-    toolName;
-    constructor(toolName) {
-        super(`No stored tool named "${toolName}".`);
-        this.toolName = toolName;
-        this.name = "ToolNotStoredError";
-    }
-}
-function drift(declared, stored) {
-    const out = [];
-    const byName = new Map(stored.map((a) => [a.name, a]));
-    for (const arg of declared) {
-        const found = byName.get(arg.name);
-        if (!found) {
-            out.push(`"${arg.name}" is declared here but not stored`);
-            continue;
-        }
-        byName.delete(arg.name);
-        if (found.type !== arg.type) {
-            out.push(`"${arg.name}" is ${arg.type} here and ${found.type} stored`);
-        }
-        if (found.required !== arg.required) {
-            out.push(`"${arg.name}" is ${arg.required ? "required" : "optional"} here and the reverse stored`);
-        }
-    }
-    for (const name of byName.keys()) {
-        out.push(`"${name}" is stored but not declared here`);
-    }
-    return out;
-}
-export async function bindTool(sg, spec, query = {}) {
-    let stored;
-    try {
-        ({ tool: stored } = await sg.tools.get(spec.name, query));
-    }
-    catch (err) {
-        if (err && typeof err === "object" && "status" in err && err.status === 404) {
-            throw new ToolNotStoredError(spec.name);
-        }
-        throw err;
-    }
-    const differences = drift(spec.args, stored.args ?? []);
-    if (differences.length)
-        throw new ToolDriftError(spec.name, differences);
-    return tool({
-        name: stored.name,
-        description: stored.description,
-        args: spec.args,
-        effect: stored.effect ?? undefined,
-        pinned: stored.pinned,
-        run: spec.run,
-    });
-}
+import{tool as i}from"./tool.js";class a extends Error{toolName;differences;constructor(r,t){super(`Tool "${r}" is stored differently from the code binding it: ${t.join("; ")}.`),this.toolName=r,this.differences=t,this.name="ToolDriftError"}}class d extends Error{toolName;constructor(r){super(`No stored tool named "${r}".`),this.toolName=r,this.name="ToolNotStoredError"}}function f(s,r){const t=[],o=new Map(r.map(e=>[e.name,e]));for(const e of s){const n=o.get(e.name);if(!n){t.push(`"${e.name}" is declared here but not stored`);continue}o.delete(e.name),n.type!==e.type&&t.push(`"${e.name}" is ${e.type} here and ${n.type} stored`),n.required!==e.required&&t.push(`"${e.name}" is ${e.required?"required":"optional"} here and the reverse stored`)}for(const e of o.keys())t.push(`"${e}" is stored but not declared here`);return t}async function c(s,r,t={}){let o;try{({tool:o}=await s.tools.get(r.name,t))}catch(n){throw n&&typeof n=="object"&&"status"in n&&n.status===404?new d(r.name):n}const e=f(r.args,o.args??[]);if(e.length)throw new a(r.name,e);return i({name:o.name,description:o.description,args:r.args,effect:o.effect??void 0,pinned:o.pinned,run:r.run})}export{a as ToolDriftError,d as ToolNotStoredError,c as bindTool};

package/dist/tool/index.js

@@ -1,2 +1 @@
-export { bindTool, ToolDriftError, ToolNotStoredError } from "./bind.js";
-export { tool } from "./tool.js";
+import{bindTool as t,ToolDriftError as l,ToolNotStoredError as e}from"./bind.js";import{tool as T}from"./tool.js";export{l as ToolDriftError,e as ToolNotStoredError,t as bindTool,T as tool};

package/dist/tool/tool.d.ts

@@ -3,6 +3,7 @@ export interface ToolSpec<T extends readonly ArgSpec[]> {
     name: string;
     description: string;
     args: T;
+    aliases?: readonly string[];
     pinned?: boolean;
     effect?: Effect;
     run(args: ArgsOf<T>): Promise<unknown> | unknown;

package/dist/tool/tool.js

@@ -1,51 +1 @@
-const VALID_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const EFFECTS = ["readonly", "idempotent", "destructive"];
-function checkEnum(toolName, arg) {
-    if (!arg.options?.length) {
-        throw new Error(`Tool "${toolName}" argument "${arg.name}" is an enum with no options, so nothing can satisfy it.`);
-    }
-    const choices = new Set();
-    for (const option of arg.options) {
-        if (!option.trim()) {
-            throw new Error(`Tool "${toolName}" argument "${arg.name}" has a blank option, which the model can pick and you cannot act on.`);
-        }
-        if (choices.has(option)) {
-            throw new Error(`Tool "${toolName}" argument "${arg.name}" lists "${option}" twice.`);
-        }
-        choices.add(option);
-    }
-}
-function checkArgs(toolName, args) {
-    const seen = new Set();
-    for (const arg of args) {
-        if (!VALID_NAME.test(arg.name)) {
-            throw new Error(`Tool "${toolName}" argument "${arg.name}" is not a usable name.`);
-        }
-        if (seen.has(arg.name)) {
-            throw new Error(`Tool "${toolName}" declares "${arg.name}" twice.`);
-        }
-        seen.add(arg.name);
-        if (arg.type === "enum")
-            checkEnum(toolName, arg);
-    }
-}
-export function tool(spec) {
-    if (!VALID_NAME.test(spec.name)) {
-        throw new Error(`Tool name "${spec.name}" must be letters, digits and underscores, starting with a letter.`);
-    }
-    if (!spec.description.trim()) {
-        throw new Error(`Tool "${spec.name}" has no description. It is the only thing the model reads to decide whether to call it.`);
-    }
-    checkArgs(spec.name, spec.args);
-    if (spec.effect !== undefined && !EFFECTS.includes(spec.effect)) {
-        throw new Error(`Tool "${spec.name}" declares effect "${spec.effect}", which is not one of ${EFFECTS.join(", ")}.`);
-    }
-    return {
-        name: spec.name,
-        description: spec.description,
-        args: spec.args.map((a) => ({ ...a, options: a.options ? [...a.options] : undefined })),
-        pinned: spec.pinned,
-        ...(spec.effect ? { effect: spec.effect } : {}),
-        run: spec.run,
-    };
-}
+const r=/^[A-Za-z_][A-Za-z0-9_]*$/,i=["readonly","idempotent","destructive"];function a(n,e){if(!e.options?.length)throw new Error(`Tool "${n}" argument "${e.name}" is an enum with no options, so nothing can satisfy it.`);const t=new Set;for(const o of e.options){if(!o.trim())throw new Error(`Tool "${n}" argument "${e.name}" has a blank option, which the model can pick and you cannot act on.`);if(t.has(o))throw new Error(`Tool "${n}" argument "${e.name}" lists "${o}" twice.`);t.add(o)}}function s(n,e){if(e){for(const t of e)if(!t.trim())throw new Error(`Tool "${n}" has a blank alias, which matches every query or none.`)}}function f(n,e){const t=new Set;for(const o of e){if(!r.test(o.name))throw new Error(`Tool "${n}" argument "${o.name}" is not a usable name.`);if(t.has(o.name))throw new Error(`Tool "${n}" declares "${o.name}" twice.`);t.add(o.name),o.type==="enum"&&a(n,o)}}function h(n){if(!r.test(n.name))throw new Error(`Tool name "${n.name}" must be letters, digits and underscores, starting with a letter.`);if(!n.description.trim())throw new Error(`Tool "${n.name}" has no description. It is the only thing the model reads to decide whether to call it.`);if(f(n.name,n.args),s(n.name,n.aliases),n.effect!==void 0&&!i.includes(n.effect))throw new Error(`Tool "${n.name}" declares effect "${n.effect}", which is not one of ${i.join(", ")}.`);return{name:n.name,description:n.description,args:n.args.map(e=>({...e,options:e.options?[...e.options]:void 0})),...n.aliases?.length?{aliases:[...n.aliases]}:{},pinned:n.pinned,...n.effect?{effect:n.effect}:{},run:n.run}}export{h as tool};

package/dist/types/index.js

@@ -1 +0,0 @@
-export {};

package/dist/types/result.js

@@ -1 +0,0 @@
-export {};

package/dist/types/tool.d.ts

@@ -82,6 +82,14 @@ export interface Tool<Args = Record<string, unknown>> {
      */
     description: string;
     args: FieldSpec[];
+    /**
+     * Extra wording selection matches on, never sent to the model.
+     *
+     * Lexical ranking cannot reach a synonym: a question about money back scores
+     * zero against a tool called `refund`, whatever the description says. This is
+     * where the words a caller actually types are declared.
+     */
+    aliases?: string[];
     /**
      * Offered whatever selection decides — an escalation path, a refusal, where
      * losing a similarity search is not an acceptable outcome.
@@ -96,6 +104,11 @@ export interface ToolDeclaration {
     name: string;
     description: string;
     args: FieldSpec[];
+    /**
+     * Carried so a nested bus can rank on it. Dropped by every provider shape,
+     * exactly as `effect` is.
+     */
+    aliases?: string[];
     /**
      * Carried so a caller can gate on it. Dropped by every provider shape — no
      * API has a field for it, and an unknown key is rejected or ignored.

package/dist/types/tool.js

@@ -1 +0,0 @@
-export {};

package/dist/wire/index.js

@@ -1,3 +1 @@
-export { toJsonSchema, } from "./json-schema.js";
-export { toMarkdown } from "./markdown.js";
-export { toAnthropic, toOpenAI, } from "./providers.js";
+import{toJsonSchema as t}from"./json-schema.js";import{toMarkdown as p}from"./markdown.js";import{toAnthropic as n,toOpenAI as f}from"./providers.js";export{n as toAnthropic,t as toJsonSchema,p as toMarkdown,f as toOpenAI};

package/dist/wire/json-schema.js

@@ -1,65 +1 @@
-export const JSON_TYPE = {
-    string: "string",
-    text: "string",
-    number: "number",
-    boolean: "boolean",
-    enum: "string",
-    list: "array",
-    json: "object",
-};
-function coerceDefault(field) {
-    const raw = field.default;
-    if (raw === undefined)
-        return undefined;
-    switch (field.type) {
-        case "number": {
-            const n = Number(raw);
-            return Number.isFinite(n) ? n : undefined;
-        }
-        case "boolean": {
-            const t = raw.trim().toLowerCase();
-            if (t === "true" || t === field.trueText?.trim().toLowerCase())
-                return true;
-            if (t === "false" || t === field.falseText?.trim().toLowerCase())
-                return false;
-            return undefined;
-        }
-        case "enum":
-            return field.options?.includes(raw) ? raw : undefined;
-        case "list":
-        case "json":
-            return undefined;
-        default:
-            return raw;
-    }
-}
-export function toJsonSchema(args) {
-    const properties = {};
-    for (const field of args) {
-        const property = { type: JSON_TYPE[field.type] };
-        if (field.description)
-            property.description = field.description;
-        if (field.type === "enum" && field.options?.length)
-            property.enum = [...field.options];
-        if (field.type === "list")
-            property.items = { type: "string" };
-        if (field.type === "number") {
-            if (field.min !== undefined)
-                property.minimum = field.min;
-            if (field.max !== undefined)
-                property.maximum = field.max;
-        }
-        if ((field.type === "string" || field.type === "text") && field.maxLength !== undefined) {
-            property.maxLength = field.maxLength;
-        }
-        const fallback = coerceDefault(field);
-        if (fallback !== undefined)
-            property.default = fallback;
-        properties[field.name] = property;
-    }
-    return {
-        type: "object",
-        properties,
-        required: args.filter((a) => a.required).map((a) => a.name),
-    };
-}
+const o={string:"string",text:"string",number:"number",boolean:"boolean",enum:"string",list:"array",json:"object"};function u(t){const n=t.default;if(n!==void 0)switch(t.type){case"number":{const e=Number(n);return Number.isFinite(e)?e:void 0}case"boolean":{const e=n.trim().toLowerCase();return e==="true"||e===t.trueText?.trim().toLowerCase()?!0:e==="false"||e===t.falseText?.trim().toLowerCase()?!1:void 0}case"enum":return t.options?.includes(n)?n:void 0;case"list":case"json":return;default:return n}}function s(t){const n={};for(const e of t){const r={type:o[e.type]};e.description&&(r.description=e.description),e.type==="enum"&&e.options?.length&&(r.enum=[...e.options]),e.type==="list"&&(r.items={type:"string"}),e.type==="number"&&(e.min!==void 0&&(r.minimum=e.min),e.max!==void 0&&(r.maximum=e.max)),(e.type==="string"||e.type==="text")&&e.maxLength!==void 0&&(r.maxLength=e.maxLength);const i=u(e);i!==void 0&&(r.default=i),n[e.name]=r}return{type:"object",properties:n,required:t.filter(e=>e.required).map(e=>e.name)}}export{o as JSON_TYPE,s as toJsonSchema};

package/dist/wire/markdown.d.ts

@@ -2,8 +2,10 @@ import type { ToolDeclaration } from "../types/index.js";
 /**
  * Declarations as markdown, for a model with no tools API.
  *
- * About a quarter cheaper than the JSON, since JSON Schema is mostly
- * scaffolding — but you give up structured tool calls and parse intent out of
- * prose instead. Only worth it where there is no native `tools` array.
+ * A third to two fifths cheaper than the JSON, since JSON Schema is mostly
+ * scaffolding — 31% under the Anthropic shape on a bus of nine tools, 38% on a
+ * bus of three, and more again against OpenAI's extra envelope. But you give up
+ * structured tool calls and parse intent out of prose instead. Only worth it
+ * where there is no native `tools` array.
  */
 export declare function toMarkdown(decls: ToolDeclaration[], heading?: string): string;

package/dist/wire/markdown.js

@@ -1,29 +1,9 @@
-import { JSON_TYPE } from "./json-schema.js";
-function escapeHeadings(text) {
-    return text.replace(/^(\s*)(#{1,6})(\s|$)/gm, "$1\\$2$3");
-}
-function argLine(field) {
-    const type = JSON_TYPE[field.type];
-    const notes = [];
-    if (field.description)
-        notes.push(escapeHeadings(field.description.trim()).replace(/\.$/, ""));
-    if (field.type === "enum" && field.options?.length) {
-        notes.push(`one of ${field.options.join(", ")}`);
-    }
-    if (field.type === "number" && (field.min !== undefined || field.max !== undefined)) {
-        notes.push(`between ${field.min ?? "any"} and ${field.max ?? "any"}`);
-    }
-    if (field.default !== undefined)
-        notes.push(`defaults to ${field.default}`);
-    const head = `- \`${field.name}\` (${type}${field.required ? ", required" : ""})`;
-    return notes.length ? `${head} ${notes.join(". ")}.` : `${head}`;
-}
-export function toMarkdown(decls, heading = "## Tools") {
-    if (decls.length === 0)
-        return "";
-    const sections = decls.map((d) => {
-        const args = d.args.length ? d.args.map(argLine).join("\n") : "_Takes no arguments._";
-        return `### ${d.name}\n${escapeHeadings(d.description)}\n\n${args}`;
-    });
-    return `${heading}\n\n${sections.join("\n\n")}`;
-}
+import{JSON_TYPE as a}from"./json-schema.js";function r(n){return n.replace(/^(\s*)(#{1,6})(\s|$)/gm,"$1\\$2$3")}function u(n){const o=a[n.type],t=[];n.description&&t.push(r(n.description.trim()).replace(/\.$/,"")),n.type==="enum"&&n.options?.length&&t.push(`one of ${n.options.join(", ")}`),n.type==="number"&&(n.min!==void 0||n.max!==void 0)&&t.push(`between ${n.min??"any"} and ${n.max??"any"}`),n.default!==void 0&&t.push(`defaults to ${n.default}`);const e=`- \`${n.name}\` (${o}${n.required?", required":""})`;return t.length?`${e} ${t.join(". ")}.`:`${e}`}function $(n,o="## Tools"){if(n.length===0)return"";const t=n.map(e=>{const s=e.args.length?e.args.map(u).join(`
+`):"_Takes no arguments._";return`### ${e.name}
+${r(e.description)}
+
+${s}`});return`${o}
+
+${t.join(`
+
+`)}`}export{$ as toMarkdown};

package/dist/wire/providers.js

@@ -1,18 +1 @@
-import { toJsonSchema } from "./json-schema.js";
-export function toAnthropic(decls) {
-    return decls.map((d) => ({
-        name: d.name,
-        description: d.description,
-        input_schema: toJsonSchema(d.args),
-    }));
-}
-export function toOpenAI(decls) {
-    return decls.map((d) => ({
-        type: "function",
-        function: {
-            name: d.name,
-            description: d.description,
-            parameters: toJsonSchema(d.args),
-        },
-    }));
-}
+import{toJsonSchema as e}from"./json-schema.js";function r(t){return t.map(n=>({name:n.name,description:n.description,input_schema:e(n.args)}))}function i(t){return t.map(n=>({type:"function",function:{name:n.name,description:n.description,parameters:e(n.args)}}))}export{r as toAnthropic,i as toOpenAI};

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@spendgraph/tools",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Declare a tool once, offer the right few, and record what was called.",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fnLog0/spendgraph.git",
@@ -28,6 +28,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./bogus": {
+      "types": "./dist/bogus/index.d.ts",
+      "import": "./dist/bogus/index.js"
+    },
     "./wire": {
       "types": "./dist/wire/index.d.ts",
       "import": "./dist/wire/index.js"
@@ -43,16 +47,16 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json --emitDeclarationOnly && tsc -p tsconfig.json --declaration false --removeComments",
-    "test": "vitest run",
+    "build": "rm -rf dist && tsc -p tsconfig.json --emitDeclarationOnly && tsc -p tsconfig.json --declaration false --removeComments && node ../../scripts/minify.mjs dist",
+    "test": "npm run build && vitest run",
     "examples": "npm run build && node examples/02-select/01-shortlist.mjs"
   },
   "dependencies": {
-    "@locusgraph/client": "^0.8.1",
-    "@spendgraph/sdk": "^0.5.0"
+    "@spendgraph/sdk": "^0.6.0"
   },
   "devDependencies": {
-    "@spendgraph/prompt": "^0.5.0",
+    "@locusgraph/client": "^0.8.1",
+    "@spendgraph/prompt": "^0.6.0",
     "typescript": "^5"
   },
   "engines": {