@try-works/dsh-tool-mode 0.0.0-stage → 0.5.44

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-rerank.js

@@ -0,0 +1,76 @@
+/**
+ * `text.rerank` — the cross-encoder reranking contract (TOOL-05).
+ *
+ * Model-free: any conforming implementation binds to it. The scores are
+ * RANKING LOGITS from a cross-encoder — not embedding cosines, and the two
+ * score kinds are never interchangeable (the semantic_rank tool's
+ * cosine_similarity is a different quantity).
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-rerank
+ */
+import { withMeta } from "../meta.js";
+/** The `text.rerank` contract at version 1.0.0. */
+export const textRerank = {
+    contract: 'text.rerank',
+    version: '1.0.0',
+    toolName: 'text_rerank',
+    description: 'Score query/document pairs with a cross-encoder and return the caller\'s own ids in descending '
+        + 'ranking-logit order with exact ties broken by input order. The scores are cross-encoder '
+        + 'logits (scoreKind "ranking_logit"), NOT embedding cosines: the two are not interchangeable. '
+        + 'A positive top_k within the candidate count is required when supplied.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['query', 'documents'],
+        properties: {
+            query: { type: 'string', minLength: 1, maxLength: 32768 },
+            documents: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 256,
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['id', 'text'],
+                    properties: {
+                        id: { type: 'string', minLength: 1, maxLength: 128 },
+                        text: { type: 'string', minLength: 1, maxLength: 32768 },
+                    },
+                },
+                description: 'The documents in the caller\'s order; that order breaks exact score ties (TOOL-05).',
+            },
+            top_k: { type: 'integer', minimum: 1, maximum: 256 },
+        },
+    },
+    outputSchema: withMeta({
+        results: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['id', 'score'],
+                properties: {
+                    id: { type: 'string' },
+                    score: { type: 'number' },
+                },
+            },
+        },
+        scoreKind: { const: 'ranking_logit' },
+    }, ['results', 'scoreKind']),
+    semantics: {
+        scoreKind: 'ranking-logit',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: {
+        maxDocuments: 256,
+        maxInputCharacters: 32768,
+        maxTopK: 256,
+    },
+    unsupported: [
+        'Treating ranking logits as embedding cosines.',
+        'Negative or zero top_k when supplied.',
+    ],
+};
+//# sourceMappingURL=text-rerank.js.map

package/node_modules/@try-works/tool-mode-contracts/lib/dsh.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Projection of a contract into DSH's parameter DSL (DECL-01).
+ *
+ * DECL-01 requires that DSH registration, MCP projection and Code Mode types all
+ * come from one source. The contract's JSON Schema is that source; this module is
+ * the DSH-specific projection of it.
+ *
+ * It replaces the old registrar behaviour that inferred the required input from
+ * parameter ORDER (BASE-04). Requiredness now comes from the schema's `required`
+ * array, so a contract cannot silently change meaning when a property is
+ * reordered.
+ *
+ * @module @try-works/tool-mode-contracts/dsh
+ */
+import type { ToolContract } from './registry.ts';
+/** One DSH parameter property: a JSON-Schema subset plus `required`. */
+type DshProperty = Record<string, unknown> & {
+    required?: true;
+};
+/** The implicit-open-object parameter map DSH expects. */
+export type DshParameters = Record<string, DshProperty>;
+/** The result of projecting a contract into DSH's narrower DSL. */
+export interface DshProjection {
+    /** What the model-facing parameter schema advertises. */
+    readonly parameters: DshParameters;
+    /**
+     * Contract keywords the parameter schema cannot advertise, in `path.keyword`
+     * form. They remain enforced at runtime against the full contract schema.
+     */
+    readonly runtimeEnforced: readonly string[];
+}
+/** Raised when a contract uses a schema shape the DSH DSL cannot express. */
+export declare class ProjectionError extends Error {
+    readonly name = "ProjectionError";
+    readonly unsupported: readonly string[];
+    constructor(contract: string, unsupported: readonly string[]);
+}
+/**
+ * Project a contract's input schema into DSH parameters.
+ *
+ * DSH's DSL is narrower than JSON Schema — it has no `minLength`, `minimum` or
+ * `pattern` at any nesting level — so the projection is deliberately lossy in what
+ * it ADVERTISES while remaining complete in what it ENFORCES. BASE-04 forbids
+ * silently discarding a constraint, so every keyword left out is returned in
+ * {@link DshProjection.runtimeEnforced} and is checked by `assertValidInput`
+ * against the untouched contract.
+ * @param contract - the contract to project.
+ * @returns the parameter map plus the keywords enforced only at runtime.
+ */
+export declare function projectToDsh(contract: ToolContract): DshProjection;
+/**
+ * Project a contract's input schema into DSH parameters.
+ * @param contract - the contract to project.
+ * @returns the parameter map.
+ * @throws ProjectionError when the schema is internally inconsistent.
+ */
+export declare function toDshParameters(contract: ToolContract): DshParameters;
+/**
+ * Cross-field constraints the DSH parameter DSL cannot express (BASE-04).
+ *
+ * Each returns a violation message, or undefined when the arguments are
+ * acceptable. They run after schema validation, so each may assume its fields
+ * are present and correctly typed.
+ */
+export type CrossFieldRule = (args: Record<string, unknown>) => string | undefined;
+/** The cross-field rules that apply to a given contract. */
+export declare function crossFieldRules(contract: ToolContract): CrossFieldRule[];
+/**
+ * Project an arbitrary JSON Schema into the subset DSH can advertise (DECL-02).
+ *
+ * Written for the OUTPUT schema, which needs the same treatment the input schema
+ * already gets. Using the contract's raw output schema would crash registration on the
+ * first keyword the DSL cannot express — the failure that produced `runtimeEnforced` in
+ * the first place — and using an unconstrained `{type: "object", additionalProperties:
+ * true}` instead, which is what this replaced, publishes a tool whose result shape is
+ * declared to be anything at all.
+ * @param schema - the schema to project.
+ * @returns the projected schema plus the keywords left to runtime enforcement.
+ */
+export declare function projectSchemaToDsh(schema: Readonly<Record<string, unknown>>): DshProjection;
+export {};
+//# sourceMappingURL=dsh.d.ts.map

package/node_modules/@try-works/tool-mode-contracts/lib/dsh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsh.d.ts","sourceRoot":"","sources":["../src/dsh.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,wEAAwE;AACxE,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,IAAI,CAAA;CAAE,CAAA;AAEhE,0DAA0D;AAC1D,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;AAEvD,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAA;IAClC;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAA;CAC5C;AAED,6EAA6E;AAC7E,qBAAa,eAAgB,SAAQ,KAAK;IACxC,SAAkB,IAAI,qBAAoB;IAC1C,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;gBAC3B,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,MAAM,EAAE;CAO7D;AAuHD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,CAuBlE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,CAErE;AAED;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,GAAG,SAAS,CAAA;AAElF,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,cAAc,EAAE,CAqCxE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,aAAa,CAiB3F"}

package/node_modules/@try-works/tool-mode-contracts/lib/dsh.js

@@ -0,0 +1,274 @@
+/**
+ * Projection of a contract into DSH's parameter DSL (DECL-01).
+ *
+ * DECL-01 requires that DSH registration, MCP projection and Code Mode types all
+ * come from one source. The contract's JSON Schema is that source; this module is
+ * the DSH-specific projection of it.
+ *
+ * It replaces the old registrar behaviour that inferred the required input from
+ * parameter ORDER (BASE-04). Requiredness now comes from the schema's `required`
+ * array, so a contract cannot silently change meaning when a property is
+ * reordered.
+ *
+ * @module @try-works/tool-mode-contracts/dsh
+ */
+/** Raised when a contract uses a schema shape the DSH DSL cannot express. */
+export class ProjectionError extends Error {
+    name = 'ProjectionError';
+    unsupported;
+    constructor(contract, unsupported) {
+        super(`${contract} cannot be projected into the DSH parameter DSL: ${unsupported.join('; ')}. `
+            + 'Weakening the schema silently is not permitted (BASE-04), so the contract must be reshaped.');
+        this.unsupported = unsupported;
+    }
+}
+/**
+ * JSON-Schema keywords the DSH value-schema DSL can carry.
+ *
+ * Anything outside this set is not DISCARDED: it stays in the contract and is
+ * enforced at runtime by {@link assertValidInput}, which validates arguments
+ * against the full contract schema before the implementation runs. This module
+ * only decides what the model-facing parameter schema advertises.
+ */
+const DSH_SUPPORTED = new Set([
+    'type', 'enum', 'const', 'description', 'default', 'examples',
+    'items', 'properties', 'additionalProperties', 'required',
+]);
+/**
+ * Project one JSON-Schema node into the subset DSH can carry.
+ *
+ * Recursive because DSH validates nested object properties too, so a constraint
+ * on `audio.path` reaches the same DSL limit as one on a top-level property.
+ * @param node - the schema node to project.
+ * @param path - dotted path for reporting what was left out.
+ * @param runtimeEnforced - accumulates `path.keyword` entries.
+ * @returns the projected node.
+ */
+function projectNode(node, path, runtimeEnforced) {
+    const out = {};
+    /**
+     * Requiredness is expressed PER PROPERTY, at every nesting level.
+     *
+     * DSH's value schema DSL does not admit a `required` array anywhere — it rejected
+     * `schema.required` at the root and `items.required` inside an array — so the list is
+     * folded into `required: true` on each named property, which the DSL does understand.
+     * Doing it here rather than at the root is what makes it work at depth: an output
+     * schema's array items have required fields of their own.
+     */
+    const requiredNames = new Set(node.required ?? []);
+    for (const [keyword, value] of Object.entries(node)) {
+        if (!DSH_SUPPORTED.has(keyword)) {
+            runtimeEnforced.push(`${path}.${keyword}`);
+            continue;
+        }
+        // Handled through `properties` above; the DSL has no array form.
+        if (keyword === 'required')
+            continue;
+        if (keyword === 'properties' && typeof value === 'object' && value !== null) {
+            const nested = {};
+            for (const [name, child] of Object.entries(value)) {
+                const projected = typeof child === 'object' && child !== null
+                    ? projectNode(child, `${path}.${name}`, runtimeEnforced)
+                    : child;
+                nested[name] = requiredNames.has(name) && typeof projected === 'object' && projected !== null
+                    ? { ...projected, required: true }
+                    : projected;
+            }
+            out[keyword] = nested;
+        }
+        else if (keyword === 'items' && typeof value === 'object' && value !== null) {
+            out[keyword] = projectNode(value, `${path}[]`, runtimeEnforced);
+        }
+        else if (keyword === 'type' && Array.isArray(value)) {
+            /**
+             * A union `type` array is advertised as `type: 'json'` (unconstrained), NOT
+             * narrowed to one member.
+             *
+             * An earlier version advertised the concrete non-null member, which made the
+             * advertised schema STRICTER than the contract: `{ type: ['string','null'] }`
+             * was projected to `type: 'string'`, and the registry VALIDATES success values
+             * against the advertised schema, so a legitimate null result was rejected.
+             * Dropping the type entirely also fails: the DSL requires every property to
+             * have a type or oneOf. `type: 'json'` is the loosest the DSL accepts, it is
+             * strictly looser than any union, and the runtime contract check still enforces
+             * the union itself.
+             */
+            runtimeEnforced.push(`${path}.type(union -> json)`);
+            out.type = 'json';
+        }
+        else {
+            out[keyword] = value;
+        }
+    }
+    /**
+     * Post-pass the DSL rejects but projectNode would otherwise emit:
+     *
+     * - `type: 'json'` cannot carry `items`/`enum`/`const` siblings, so a union-typed
+     *   array whose element schema (or scalar constraints) survived the pass is
+     *   stripped HERE, with the keyword recorded rather than silently lost.
+     * - A NON-SCALAR `enum` is dropped everywhere: the DSL requires "a non-empty array
+     *   of scalar values", and the confidence contract (DECL-04) enumerates OBJECT
+     *   members to distinguish vendor-reported from calibrated from unavailable.
+     *   Membership is still enforced at runtime against the untouched contract.
+     * - An annotation-only node (every keyword dropped to runtimeEnforced) has no
+     *   `type`/`oneOf`, which the DSL rejects; advertising `type: 'json'` keeps it
+     *   strictly looser than the original instead of crashing registration.
+     */
+    if (out.type === undefined && out.oneOf === undefined) {
+        runtimeEnforced.push(`${path}.type(annotation-only -> json)`);
+        out.type = 'json';
+    }
+    if (out.type === 'json') {
+        for (const sibling of ['items', 'enum', 'const']) {
+            if (sibling in out) {
+                runtimeEnforced.push(`${path}.${sibling}`);
+                delete out[sibling];
+            }
+        }
+    }
+    if (out.type !== 'json' && Array.isArray(out.enum) && !out.enum.every(member => isScalar(member))) {
+        runtimeEnforced.push(`${path}.enum`);
+        delete out.enum;
+    }
+    return out;
+}
+/** A scalar the DSL's `enum` admits. */
+function isScalar(member) {
+    return typeof member === 'string' || typeof member === 'number' || typeof member === 'boolean';
+}
+/**
+ * Project a contract's input schema into DSH parameters.
+ *
+ * DSH's DSL is narrower than JSON Schema — it has no `minLength`, `minimum` or
+ * `pattern` at any nesting level — so the projection is deliberately lossy in what
+ * it ADVERTISES while remaining complete in what it ENFORCES. BASE-04 forbids
+ * silently discarding a constraint, so every keyword left out is returned in
+ * {@link DshProjection.runtimeEnforced} and is checked by `assertValidInput`
+ * against the untouched contract.
+ * @param contract - the contract to project.
+ * @returns the parameter map plus the keywords enforced only at runtime.
+ */
+export function projectToDsh(contract) {
+    const schema = contract.inputSchema;
+    const properties = schema.properties ?? {};
+    const required = new Set(schema.required ?? []);
+    const runtimeEnforced = [];
+    const out = {};
+    for (const [name, property] of Object.entries(properties)) {
+        const projected = projectNode(property, name, runtimeEnforced);
+        if (required.has(name))
+            projected.required = true;
+        out[name] = projected;
+    }
+    // A required property that is not declared cannot be satisfied by any caller.
+    const undeclared = [...required].filter(name => !(name in properties));
+    if (undeclared.length > 0) {
+        throw new ProjectionError(contract.contract, undeclared.map(name => `required property "${name}" is not declared`));
+    }
+    return { parameters: out, runtimeEnforced };
+}
+/**
+ * Project a contract's input schema into DSH parameters.
+ * @param contract - the contract to project.
+ * @returns the parameter map.
+ * @throws ProjectionError when the schema is internally inconsistent.
+ */
+export function toDshParameters(contract) {
+    return projectToDsh(contract).parameters;
+}
+/** The cross-field rules that apply to a given contract. */
+export function crossFieldRules(contract) {
+    switch (contract.contract) {
+        case 'stt.transcribe':
+            return [
+                (args) => {
+                    const timestamps = args.timestamps;
+                    if (timestamps === 'word' && args.language === undefined) {
+                        // Not a hard error, but a caller asking for word timing without
+                        // declaring a language gets worse results on code-switched audio.
+                        return undefined;
+                    }
+                    return undefined;
+                },
+                (args) => {
+                    const audio = args.audio;
+                    if (audio?.channels !== undefined && audio.channels !== 1) {
+                        return 'audio.channels must be 1: the admitted input is 16 kHz mono';
+                    }
+                    if (audio?.sampleRateHz !== undefined && audio.sampleRateHz !== 16000) {
+                        return 'audio.sampleRateHz must be 16000: resampling is not part of this contract';
+                    }
+                    return undefined;
+                },
+            ];
+        case 'text.language_detect':
+            return [
+                (args) => {
+                    const text = args.text;
+                    if (typeof text === 'string' && text.trim().length === 0) {
+                        return 'text must contain at least one non-whitespace character';
+                    }
+                    return undefined;
+                },
+            ];
+        default:
+            return [];
+    }
+}
+/**
+ * Project an arbitrary JSON Schema into the subset DSH can advertise (DECL-02).
+ *
+ * Written for the OUTPUT schema, which needs the same treatment the input schema
+ * already gets. Using the contract's raw output schema would crash registration on the
+ * first keyword the DSL cannot express — the failure that produced `runtimeEnforced` in
+ * the first place — and using an unconstrained `{type: "object", additionalProperties:
+ * true}` instead, which is what this replaced, publishes a tool whose result shape is
+ * declared to be anything at all.
+ * @param schema - the schema to project.
+ * @returns the projected schema plus the keywords left to runtime enforcement.
+ */
+export function projectSchemaToDsh(schema) {
+    const runtimeEnforced = [];
+    const projected = projectNode(schema, '', runtimeEnforced);
+    /**
+     * Nested array `items` are RETAINED, not stripped.
+     *
+     * An earlier version stripped every `items` at depth, on evidence that the registry
+     * rejected `schema.properties.words.items`. That evidence is stale against the pinned
+     * `dsh-tools@0.2.0-rc.2`, which compiles nested array items (probed: a `words` schema
+     * with a full item schema registers and validates). Stripping by key name was also a
+     * stricter-than-contract bug in waiting: a payload field legitimately NAMED `items`
+     * would lose its advertisement. Union-typed arrays (`type: ['array','null']`) become
+     * `type: 'json'` in projectNode, which already removes the `items` sibling with the
+     * keyword recorded, so nothing here needs to strip it again.
+     */
+    const parameters = stripItems(projected.properties ?? {}, '', runtimeEnforced);
+    return { parameters: parameters, runtimeEnforced };
+}
+/**
+ * Deep-clone a projected schema while preserving ARRAYS as arrays (DECL-02).
+ *
+ * The post-pass in projectNode removed every keyword the DSL rejects, so this
+ * function no longer edits keywords — it exists so no recursion turns a scalar
+ * `enum` array like ['host','device'] into a record {0:'host',1:'device'}, which
+ * is an invalid schema the registry rejects.
+ * @param node - the projected node.
+ * @param path - the path, for diagnostics.
+ * @param runtimeEnforced - collected keyword paths (unused; kept for the signature).
+ * @returns the node, arrays intact.
+ */
+function stripItems(node, path, runtimeEnforced) {
+    void path;
+    void runtimeEnforced;
+    if (typeof node !== 'object' || node === null)
+        return node;
+    if (Array.isArray(node)) {
+        return node.map((child, index) => stripItems(child, `${path}[${index}]`, runtimeEnforced));
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+        out[key] = stripItems(value, `${path}.${key}`, runtimeEnforced);
+    }
+    return out;
+}
+//# sourceMappingURL=dsh.js.map

package/node_modules/@try-works/tool-mode-contracts/lib/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `@try-works/tool-mode-contracts` — model-free standard tool contracts.
+ *
+ * This package contains no model bindings, no weights and no host code. It is the
+ * shared vocabulary that the Tool Mode host registers, that MCP clients read, and
+ * that extension packages implement against (DECL-01).
+ *
+ * @module @try-works/tool-mode-contracts
+ */
+export { assertValidContract, assertValidInput, assertValidOutput, assertAgainstSchema, compileSchema, ContractError, ContractViolationError, TOOL_META_SCHEMA, type ToolContract, } from './registry.ts';
+export { withMeta, type ConfidenceKind, type ConfidenceMetadata, type ExecutionLocation, type ToolMeta, } from './meta.ts';
+export { crossFieldRules, ProjectionError, projectSchemaToDsh, projectToDsh, toDshParameters, type CrossFieldRule, type DshParameters, type DshProjection, } from './dsh.ts';
+export { sttTranscribe, STT_ADMITTED_FORMATS } from './contracts/stt-transcribe.ts';
+export { langDetect } from './contracts/lang-detect.ts';
+export { textEmbed } from './contracts/text-embed.ts';
+export { textRerank } from './contracts/text-rerank.ts';
+export { textTitle, imageDescribe, multimodalEmbed, semanticSimilarity, semanticRank, semanticClassify, semanticDeduplicate, mediaFindMoments, decisionChoose, decisionTest, decisionScore, structuredExtract, toolsPlan, } from './contracts/standard.ts';
+import type { ToolContract } from './registry.ts';
+/**
+ * The standard contracts every Tool Mode host knows how to register.
+ *
+ * A host iterates this list; it does not switch on model names, which is what
+ * ARCH-02 and EXT-01 require of model-independent code.
+ */
+export declare const STANDARD_CONTRACTS: readonly ToolContract[];
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@try-works/tool-mode-contracts/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACb,aAAa,EACb,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,YAAY,GAClB,MAAM,eAAe,CAAA;AAEtB,OAAO,EACL,QAAQ,EACR,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,QAAQ,GACd,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,UAAU,CAAA;AAEjB,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvD,OAAO,EACL,SAAS,EACT,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,SAAS,GACV,MAAM,yBAAyB,CAAA;AAqBhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAGjD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,YAAY,EAsBnD,CAAA"}

package/node_modules/@try-works/tool-mode-contracts/lib/index.js

@@ -0,0 +1,53 @@
+/**
+ * `@try-works/tool-mode-contracts` — model-free standard tool contracts.
+ *
+ * This package contains no model bindings, no weights and no host code. It is the
+ * shared vocabulary that the Tool Mode host registers, that MCP clients read, and
+ * that extension packages implement against (DECL-01).
+ *
+ * @module @try-works/tool-mode-contracts
+ */
+export { assertValidContract, assertValidInput, assertValidOutput, assertAgainstSchema, compileSchema, ContractError, ContractViolationError, TOOL_META_SCHEMA, } from "./registry.js";
+export { withMeta, } from "./meta.js";
+export { crossFieldRules, ProjectionError, projectSchemaToDsh, projectToDsh, toDshParameters, } from "./dsh.js";
+export { sttTranscribe, STT_ADMITTED_FORMATS } from "./contracts/stt-transcribe.js";
+export { langDetect } from "./contracts/lang-detect.js";
+export { textEmbed } from "./contracts/text-embed.js";
+export { textRerank } from "./contracts/text-rerank.js";
+export { textTitle, imageDescribe, multimodalEmbed, semanticSimilarity, semanticRank, semanticClassify, semanticDeduplicate, mediaFindMoments, decisionChoose, decisionTest, decisionScore, structuredExtract, toolsPlan, } from "./contracts/standard.js";
+import { sttTranscribe } from "./contracts/stt-transcribe.js";
+import { langDetect } from "./contracts/lang-detect.js";
+import { textEmbed } from "./contracts/text-embed.js";
+import { textRerank } from "./contracts/text-rerank.js";
+import { textTitle, imageDescribe, multimodalEmbed, semanticSimilarity, semanticRank, semanticClassify, semanticDeduplicate, mediaFindMoments, decisionChoose, decisionTest, decisionScore, structuredExtract, toolsPlan, } from "./contracts/standard.js";
+import { CONTRACT_EXAMPLES, CONTRACT_POLICIES } from "./contract-metadata.js";
+/**
+ * The standard contracts every Tool Mode host knows how to register.
+ *
+ * A host iterates this list; it does not switch on model names, which is what
+ * ARCH-02 and EXT-01 require of model-independent code.
+ */
+export const STANDARD_CONTRACTS = [
+    sttTranscribe,
+    langDetect,
+    textEmbed,
+    textRerank,
+    textTitle,
+    imageDescribe,
+    multimodalEmbed,
+    semanticSimilarity,
+    semanticRank,
+    semanticClassify,
+    semanticDeduplicate,
+    mediaFindMoments,
+    decisionChoose,
+    decisionTest,
+    decisionScore,
+    structuredExtract,
+    toolsPlan,
+].map(contract => ({
+    ...contract,
+    examples: CONTRACT_EXAMPLES[contract.contract] ?? [],
+    policy: CONTRACT_POLICIES[contract.contract] ?? { recording: 'required', remote: 'allowed' },
+}));
+//# sourceMappingURL=index.js.map

package/node_modules/@try-works/tool-mode-contracts/lib/meta.d.ts

@@ -0,0 +1,133 @@
+/**
+ * The shared result envelope every Tool Mode tool returns (DECL-03).
+ *
+ * The envelope is what makes a result self-describing: a caller can tell which
+ * contract and version produced it, which implementation actually ran, where it
+ * ran, and whether the host attached any warnings. The host stamps the
+ * authoritative provenance fields; an implementation cannot forge another
+ * package's identity.
+ *
+ * DECL-04 is the reason `warnings` exists but a universal `confidence` does not:
+ * a successful call means a valid result was produced, not that it is correct,
+ * and a fabricated confidence number would claim more than the model supplied.
+ *
+ * @module @try-works/tool-mode-contracts/meta
+ */
+/** Where an implementation executed, relative to the caller (SPEC §6). */
+export type ExecutionLocation = 
+/** The harness host process itself. */
+'host'
+/** The user's own device. */
+ | 'device'
+/** A user-controlled server on the local network. */
+ | 'team-server'
+/** A remote service outside the user's control. */
+ | 'remote';
+/** The four confidence categories a result may honestly claim (DECL-04). */
+export type ConfidenceKind = 'vendor-reported' | 'calibrated' | 'ranking-logits' | 'unavailable';
+/** Confidence metadata carried in the envelope; never a fabricated universal number. */
+export interface ConfidenceMetadata {
+    readonly kind: ConfidenceKind;
+    /** Where the claim comes from (the vendor field, calibration report, or host). */
+    readonly source: string;
+}
+/** Provenance and status metadata shared by every tool result. */
+export interface ToolMeta {
+    /** Contract identity, e.g. `stt.transcribe`. */
+    readonly contract: string;
+    /** Semantic version of the CONTRACT, independent of the host release. */
+    readonly contractVersion: string;
+    /** The implementation that actually executed, e.g. `voz-onnx`. */
+    readonly implementationId: string;
+    /** Owning extension package identity. */
+    readonly extension: string;
+    /** Extension version, stamped by the host. */
+    readonly extensionVersion: string;
+    /** Which activation generation produced this result (DECL-08). */
+    readonly activationGeneration: number;
+    /** Where the work happened. */
+    readonly executionLocation: ExecutionLocation;
+    /** Host-issued receipt identity, for correlation and audit. */
+    readonly receiptId: string;
+    /** Non-fatal conditions the caller should know about. */
+    readonly warnings: readonly string[];
+    /**
+     * Optional confidence descriptor. Its presence names the CATEGORY and source;
+     * absence means no confidence claim was made. A calibrated value is only
+     * reported here when a calibration report exists (DECL-04).
+     */
+    readonly confidence?: ConfidenceMetadata;
+}
+/** The JSON Schema for {@link ToolMeta}, used to validate every result. */
+export declare const TOOL_META_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["contract", "contractVersion", "implementationId", "extension", "extensionVersion", "activationGeneration", "executionLocation", "receiptId", "warnings"];
+    readonly properties: {
+        readonly contract: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly contractVersion: {
+            readonly type: "string";
+            readonly pattern: "^\\d+\\.\\d+\\.\\d+$";
+        };
+        readonly implementationId: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly extension: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly extensionVersion: {
+            readonly type: "string";
+            readonly pattern: "^\\d+\\.\\d+\\.\\d+";
+        };
+        readonly activationGeneration: {
+            readonly type: "integer";
+            readonly minimum: 0;
+        };
+        readonly executionLocation: {
+            readonly type: "string";
+            readonly enum: readonly ["host", "device", "team-server", "remote"];
+        };
+        readonly receiptId: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly warnings: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly confidence: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["kind", "source"];
+            readonly properties: {
+                readonly kind: {
+                    readonly type: "string";
+                    readonly enum: readonly ["vendor-reported", "calibrated", "ranking-logits", "unavailable"];
+                };
+                readonly source: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+        };
+    };
+};
+/**
+ * Attach a `meta` property to a result schema.
+ *
+ * Contracts declare their own payload; the envelope is identical everywhere, so
+ * it is composed here rather than retyped in each contract — retyping it is how
+ * the shapes drift apart.
+ * @param payload - the contract's payload schema properties.
+ * @param requiredPayload - payload property names that are required.
+ * @returns a closed object schema containing the payload plus `meta`.
+ */
+export declare function withMeta(payload: Record<string, unknown>, requiredPayload?: readonly string[]): Record<string, unknown>;
+//# sourceMappingURL=meta.d.ts.map

package/node_modules/@try-works/tool-mode-contracts/lib/meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../src/meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,0EAA0E;AAC1E,MAAM,MAAM,iBAAiB;AAC3B,uCAAuC;AACrC,MAAM;AACR,6BAA6B;GAC3B,QAAQ;AACV,qDAAqD;GACnD,aAAa;AACf,mDAAmD;GACjD,QAAQ,CAAA;AAEZ,4EAA4E;AAC5E,MAAM,MAAM,cAAc,GAAG,iBAAiB,GAAG,YAAY,GAAG,gBAAgB,GAAG,aAAa,CAAA;AAEhG,wFAAwF;AACxF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;IAC7B,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,kEAAkE;AAClE,MAAM,WAAW,QAAQ;IACvB,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,yEAAyE;IACzE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,kEAAkE;IAClE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,yCAAyC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,kEAAkE;IAClE,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;IACrC,+BAA+B;IAC/B,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAA;IAC7C,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAA;CACzC;AAED,2EAA2E;AAC3E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BnB,CAAA;AAEV;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,eAAe,GAAE,SAAS,MAAM,EAAO,GACtC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOzB"}