@try-works/dsh-model-as-tool 0.1.2 → 0.1.3

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

@@ -0,0 +1,16 @@
+/**
+ * `text.language_detect` — the language-identification contract (TOOL-03).
+ *
+ * TOOL-03 requires three things a naive wrapper loses: ambiguity must survive to
+ * the caller, empty input has a defined answer rather than an exception, and the
+ * score's MEANING is declared. It also forbids a specific mistake worth naming in
+ * the schema: a text language detector is not evidence about the language spoken
+ * in audio it never processed, so the contract says so instead of leaving a
+ * caller to infer capability from a similar-looking tool.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/lang-detect
+ */
+import type { ToolContract } from '../registry.ts';
+/** The `text.language_detect` contract at version 1.0.0. */
+export declare const langDetect: ToolContract;
+//# sourceMappingURL=lang-detect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lang-detect.d.ts","sourceRoot":"","sources":["../../src/contracts/lang-detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,4DAA4D;AAC5D,eAAO,MAAM,UAAU,EAAE,YA8ExB,CAAA"}

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

@@ -0,0 +1,85 @@
+/**
+ * `text.language_detect` — the language-identification contract (TOOL-03).
+ *
+ * TOOL-03 requires three things a naive wrapper loses: ambiguity must survive to
+ * the caller, empty input has a defined answer rather than an exception, and the
+ * score's MEANING is declared. It also forbids a specific mistake worth naming in
+ * the schema: a text language detector is not evidence about the language spoken
+ * in audio it never processed, so the contract says so instead of leaving a
+ * caller to infer capability from a similar-looking tool.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/lang-detect
+ */
+import { withMeta } from "../meta.js";
+/** The `text.language_detect` contract at version 1.0.0. */
+export const langDetect = {
+    contract: 'text.language_detect',
+    version: '1.0.0',
+    toolName: 'lang_detect',
+    description: 'Identify the language of a short piece of text. Returns the best language, a reliability '
+        + 'verdict and ranked alternatives, because short text is often genuinely ambiguous between '
+        + 'related languages and collapsing that to one answer would overstate the result.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['text'],
+        properties: {
+            text: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 4096,
+                description: 'The text to identify. Only the leading portion is examined.',
+            },
+            top: {
+                type: 'integer',
+                minimum: 1,
+                maximum: 20,
+                default: 3,
+                description: 'How many ranked alternatives to return.',
+            },
+        },
+    },
+    outputSchema: withMeta({
+        language: { type: ['string', 'null'], description: 'Best candidate, or null when input had no language signal.' },
+        reliability: {
+            type: 'string',
+            enum: ['confident', 'likely', 'tentative', 'unknown'],
+            description: 'Vendor-reported verdict. Not a calibrated probability.',
+        },
+        tooCloseToCall: {
+            type: 'boolean',
+            description: 'True when the leading candidates are within the implementation\'s declared tie margin.',
+        },
+        candidates: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['language', 'probability'],
+                properties: {
+                    language: { type: 'string' },
+                    probability: { type: 'number', minimum: 0, maximum: 1 },
+                },
+            },
+        },
+    }, ['reliability', 'tooCloseToCall', 'candidates']),
+    semantics: {
+        scoreKind: 'vendor-reported-probability',
+        calibrated: false,
+        ambiguityPreserved: true,
+        emptyInputMeaning: 'null-language-with-empty-candidates',
+        appliesTo: 'written-text-only',
+    },
+    limits: {
+        maxInputCharacters: 4096,
+        examinedCharacters: 512,
+        maxCandidates: 20,
+    },
+    unsupported: [
+        'Spoken language: this reads written text only. It is not evidence about the language spoken in audio it has not processed (TOOL-03).',
+        'Translation or transliteration.',
+        'Confident single answers for one or two words: those are frequently ambiguous and are reported as such.',
+        'Documents beyond the examined prefix: only the leading characters are considered.',
+    ],
+};
+//# sourceMappingURL=lang-detect.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * `stt.transcribe` — the canonical transcription contract (TOOL-01).
+ *
+ * This contract is model-free on purpose. Any conforming implementation binds to
+ * it, so a caller addresses `stt_transcribe` once and the host decides which
+ * model runs (BASE-02). Adding a second transcription model must not add a
+ * second tool.
+ *
+ * The semantics block is the part a schema cannot express and the part the spec
+ * insists on (DECL-01, TOOL-01): whether this transcribes or translates, what
+ * the timestamps mean, and what an empty result means.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/stt-transcribe
+ */
+import type { ToolContract } from '../registry.ts';
+/** Accepted audio container/codec combinations for the bounded decoder. */
+export declare const STT_ADMITTED_FORMATS: readonly ["wav-pcm16"];
+/** The `stt.transcribe` contract at version 1.0.0. */
+export declare const sttTranscribe: ToolContract;
+//# sourceMappingURL=stt-transcribe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stt-transcribe.d.ts","sourceRoot":"","sources":["../../src/contracts/stt-transcribe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB,wBAAyB,CAAA;AAE1D,sDAAsD;AACtD,eAAO,MAAM,aAAa,EAAE,YAqG3B,CAAA"}

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

@@ -0,0 +1,112 @@
+/**
+ * `stt.transcribe` — the canonical transcription contract (TOOL-01).
+ *
+ * This contract is model-free on purpose. Any conforming implementation binds to
+ * it, so a caller addresses `stt_transcribe` once and the host decides which
+ * model runs (BASE-02). Adding a second transcription model must not add a
+ * second tool.
+ *
+ * The semantics block is the part a schema cannot express and the part the spec
+ * insists on (DECL-01, TOOL-01): whether this transcribes or translates, what
+ * the timestamps mean, and what an empty result means.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/stt-transcribe
+ */
+import { withMeta } from "../meta.js";
+/** Accepted audio container/codec combinations for the bounded decoder. */
+export const STT_ADMITTED_FORMATS = ['wav-pcm16'];
+/** The `stt.transcribe` contract at version 1.0.0. */
+export const sttTranscribe = {
+    contract: 'stt.transcribe',
+    version: '1.0.0',
+    toolName: 'stt_transcribe',
+    description: 'Transcribe a local audio recording into text with optional word timestamps. '
+        + 'Runs on device by default; the caller selects no model. Accepts 16 kHz mono PCM16 WAV '
+        + 'directly, and other encodings only through a tested decoder. Reports partial coverage '
+        + 'rather than presenting an incomplete clip as fully transcribed.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['audio'],
+        properties: {
+            audio: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['path'],
+                properties: {
+                    path: { type: 'string', minLength: 1, description: 'Absolute path to the recording.' },
+                    sampleRateHz: {
+                        type: 'integer',
+                        minimum: 8000,
+                        maximum: 48000,
+                        description: 'Declared sample rate; inspected against the file header, not trusted.',
+                    },
+                    channels: { type: 'integer', minimum: 1, maximum: 2 },
+                },
+            },
+            language: {
+                type: 'string',
+                minLength: 2,
+                description: 'Requested language as a BCP-47/ISO 639 code. An unsupported request is an error, never a silent fallback.',
+            },
+            timestamps: {
+                type: 'string',
+                enum: ['none', 'word'],
+                default: 'none',
+                description: 'Word timestamps when requested; an implementation that cannot supply them must error rather than omit them.',
+            },
+        },
+    },
+    outputSchema: withMeta({
+        text: { type: 'string' },
+        coverage: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['complete', 'transcribedSeconds'],
+            properties: {
+                complete: { type: 'boolean' },
+                transcribedSeconds: { type: 'number', minimum: 0 },
+                totalSeconds: { type: ['number', 'null'], minimum: 0 },
+                reason: { type: ['string', 'null'] },
+            },
+        },
+        words: {
+            type: ['array', 'null'],
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['text', 'start', 'end'],
+                properties: {
+                    text: { type: 'string' },
+                    start: { type: 'number', minimum: 0, description: 'Seconds from the start of the audio.' },
+                    end: { type: 'number', minimum: 0 },
+                },
+            },
+        },
+        language: { type: ['string', 'null'], description: 'The language actually recognized, when the implementation reports it.' },
+    }, ['text', 'coverage']),
+    semantics: {
+        operation: 'transcription',
+        translation: false,
+        timestampUnit: 'seconds',
+        timestampReference: 'start-of-audio',
+        emptyResultMeaning: 'valid-empty-transcript',
+        partialResultMeaning: 'coverage.complete is false; the transcript is incomplete, not wrong',
+        languageMismatch: 'error',
+        unsupportedTimestampRequest: 'error',
+    },
+    limits: {
+        maxAudioSeconds: 3600,
+        maxAudioBytes: 512 * 1024 * 1024,
+        admittedSampleRateHz: 16000,
+        admittedChannels: 1,
+    },
+    unsupported: [
+        'Encoding without a tested decoder: only wav-pcm16 is admitted directly; assume nothing from the file extension.',
+        'Translation: this contract transcribes, it does not translate.',
+        'Diarization or speaker attribution: separate capability.',
+        'Timestamps when the selected implementation cannot produce them: reported as an error.',
+        'Live/streaming audio: the input is a completed local file.',
+    ],
+};
+//# sourceMappingURL=stt-transcribe.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;AAyFD;;;;;;;;;;;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,CAsB3F"}

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

@@ -0,0 +1,260 @@
+/**
+ * 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 advertises its CONCRETE member, with the union recorded as
+             * runtime-enforced.
+             *
+             * Three attempts got here. `{ type: ['string', 'null'] }` is valid JSON Schema but
+             * the DSL rejected the array with "type must be string/number/... or use oneOf",
+             * and converting it to `oneOf` was rejected too, with "oneOf must be an array of at
+             * least two value schemas" - `{ type: 'null' }` does not count as one. So the
+             * non-null member is advertised, which is the case a client actually handles, and
+             * the nullability is reported in runtimeEnforced rather than dropped silently,
+             * which is what BASE-04 forbids.
+             */
+            const members = value;
+            const concrete = members.find(member => member !== 'null');
+            if (concrete === undefined) {
+                runtimeEnforced.push(`${path}.type`);
+            }
+            else {
+                out.type = concrete;
+                if (members.length > 1)
+                    runtimeEnforced.push(`${path}.type(non-nullable projection)`);
+            }
+        }
+        else {
+            out[keyword] = value;
+        }
+    }
+    return out;
+}
+/**
+ * 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);
+    /**
+     * `items` is stripped from an OUTPUT projection, and this is a real DSL limit found
+     * the hard way rather than a precaution.
+     *
+     * `items` is in the supported set and works for a top-level input parameter, but the
+     * registry rejected `schema.properties.words.items` with "items is not supported by
+     * the value schema DSL" - so its support does not extend to an array nested inside an
+     * object, which is exactly what an output schema contains. Keeping it would make the
+     * tool fail to register at all.
+     *
+     * The result is still a genuine declaration: property names, types and requiredness
+     * are advertised, and `words` is declared an array. Only the ELEMENT schema is left to
+     * runtime enforcement, which the contract's assertValidOutput performs against the
+     * untouched schema. That is a long way from the
+     * `{type: "object", additionalProperties: true}` this replaced, which declared nothing
+     * about any field.
+     */
+    const parameters = stripItems(projected.properties ?? {}, '', runtimeEnforced);
+    return { parameters: parameters, runtimeEnforced };
+}
+/**
+ * Remove `items` at every depth in an output projection, recording each removal
+ * (DECL-02).
+ * @param node - the projected node.
+ * @param path - the path, for the runtime-enforced list.
+ * @param runtimeEnforced - collected keyword paths.
+ * @returns the node without `items`.
+ */
+function stripItems(node, path, runtimeEnforced) {
+    if (typeof node !== 'object' || node === null)
+        return node;
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'items') {
+            runtimeEnforced.push(`${path}.items`);
+            continue;
+        }
+        /**
+         * A non-scalar `enum` is dropped, for the same reason `items` is.
+         *
+         * 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.
+         */
+        const scalar = (member) => typeof member === 'string' || typeof member === 'number' || typeof member === 'boolean';
+        if (key === 'enum' && Array.isArray(value) && (value.length === 0 || !value.every(scalar))) {
+            runtimeEnforced.push(`${path}.enum`);
+            continue;
+        }
+        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,23 @@
+/**
+ * `@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, ContractError, ContractViolationError, TOOL_META_SCHEMA, type ToolContract, } from './registry.ts';
+export { withMeta, 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';
+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,aAAa,EACb,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,YAAY,GAClB,MAAM,eAAe,CAAA;AAEtB,OAAO,EAAE,QAAQ,EAAE,KAAK,iBAAiB,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAA;AAE3E,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;AAIvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,YAAY,EAAgC,CAAA"}

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

@@ -0,0 +1,24 @@
+/**
+ * `@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, 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";
+import { sttTranscribe } from "./contracts/stt-transcribe.js";
+import { langDetect } from "./contracts/lang-detect.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];
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,104 @@
+/**
+ * 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';
+/** 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[];
+}
+/** 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";
+            };
+        };
+    };
+};
+/**
+ * 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,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;CACrC;AAED,2EAA2E;AAC3E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBnB,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"}

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

@@ -0,0 +1,55 @@
+/**
+ * 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
+ */
+/** The JSON Schema for {@link ToolMeta}, used to validate every result. */
+export const TOOL_META_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: [
+        'contract', 'contractVersion', 'implementationId', 'extension',
+        'extensionVersion', 'activationGeneration', 'executionLocation',
+        'receiptId', 'warnings',
+    ],
+    properties: {
+        contract: { type: 'string', minLength: 1 },
+        contractVersion: { type: 'string', pattern: '^\\d+\\.\\d+\\.\\d+$' },
+        implementationId: { type: 'string', minLength: 1 },
+        extension: { type: 'string', minLength: 1 },
+        extensionVersion: { type: 'string', pattern: '^\\d+\\.\\d+\\.\\d+' },
+        activationGeneration: { type: 'integer', minimum: 0 },
+        executionLocation: { type: 'string', enum: ['host', 'device', 'team-server', 'remote'] },
+        receiptId: { type: 'string', minLength: 1 },
+        warnings: { type: 'array', items: { type: 'string' } },
+    },
+};
+/**
+ * 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 function withMeta(payload, requiredPayload = []) {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: [...requiredPayload, 'meta'],
+        properties: { ...payload, meta: TOOL_META_SCHEMA },
+    };
+}
+//# sourceMappingURL=meta.js.map

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

@@ -0,0 +1,81 @@
+/**
+ * Contract definitions and their runtime validation.
+ *
+ * A contract is the tool's public identity: stable name, version, input and
+ * output schema, semantics, limits and policy metadata (DECL-01). It is
+ * deliberately model-free — implementations bind to it, it does not know about
+ * them — which is what lets two models serve one `stt_transcribe` instead of
+ * producing a duplicate tool each (BASE-02).
+ *
+ * Milestone A is explicit that "a copied schema with no runtime validation is not
+ * completion", so this module validates both directions: the contract DEFINITION
+ * is checked when registered, and every RESULT is checked against the declared
+ * output schema before it reaches a caller.
+ *
+ * @module @try-works/tool-mode-contracts/registry
+ */
+import { TOOL_META_SCHEMA } from './meta.ts';
+/** One tool contract: the authored-once public identity (DECL-01). */
+export interface ToolContract {
+    /** Contract identity, e.g. `stt.transcribe`. Never a model name. */
+    readonly contract: string;
+    /** Semantic version, independent of any host release number. */
+    readonly version: string;
+    /** The tool name callers see, e.g. `stt_transcribe`. */
+    readonly toolName: string;
+    /** Concise description, used verbatim for DSH registration. */
+    readonly description: string;
+    /** Input schema as JSON Schema. The object root is closed. */
+    readonly inputSchema: Record<string, unknown>;
+    /** Output schema as JSON Schema, including the `meta` envelope. */
+    readonly outputSchema: Record<string, unknown>;
+    /** Declared semantics a caller must be able to rely on. */
+    readonly semantics: Readonly<Record<string, string | number | boolean>>;
+    /** Admitted resource limits, in the units the schema declares. */
+    readonly limits: Readonly<Record<string, number>>;
+    /** Unsupported cases the caller should be told about. */
+    readonly unsupported: readonly string[];
+}
+/** A contract that failed validation, with every reason. */
+export declare class ContractError extends Error {
+    readonly name = "ContractError";
+    /** The individual violations, in declaration order. */
+    readonly violations: readonly string[];
+    constructor(subject: string, violations: readonly string[]);
+}
+/** A result that did not satisfy its contract's output schema. */
+export declare class ContractViolationError extends Error {
+    readonly name = "ContractViolationError";
+    readonly violations: readonly string[];
+    constructor(contract: string, violations: readonly string[]);
+}
+/**
+ * Validate a contract definition.
+ *
+ * This is deliberately strict about the identity fields: a contract whose
+ * `toolName` is not a legal tool name, or whose version is not semver, would
+ * register a tool that callers cannot address consistently.
+ * @param contract - the definition to check.
+ * @throws ContractError listing every violation.
+ */
+export declare function assertValidContract(contract: ToolContract): void;
+/**
+ * Validate caller arguments against the contract's input schema.
+ * @param contract - the contract to check against.
+ * @param args - the candidate arguments.
+ * @throws ContractViolationError listing every violation.
+ */
+export declare function assertValidInput(contract: ToolContract, args: unknown): void;
+/**
+ * Validate a result against the contract's output schema.
+ *
+ * This runs before the value reaches a caller, so a violation surfaces as a
+ * tool failure rather than as malformed data downstream (AT-11).
+ * @param contract - the contract to check against.
+ * @param value - the candidate result.
+ * @throws ContractViolationError listing every violation.
+ */
+export declare function assertValidOutput(contract: ToolContract, value: unknown): void;
+/** The meta envelope's own schema, exported for contract authors. */
+export { TOOL_META_SCHEMA };
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAE5C,sEAAsE;AACtE,MAAM,WAAW,YAAY;IAC3B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,8DAA8D;IAC9D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7C,mEAAmE;IACnE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9C,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,CAAA;IACvE,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACjD,yDAAyD;IACzD,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;CACxC;AAED,4DAA4D;AAC5D,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAkB,IAAI,mBAAkB;IACxC,uDAAuD;IACvD,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;gBAC1B,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE;CAI3D;AAED,kEAAkE;AAClE,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,SAAkB,IAAI,4BAA2B;IACjD,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;gBAC1B,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE;CAI5D;AA8BD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAmDhE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAM5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAM9E;AAED,qEAAqE;AACrE,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

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

@@ -0,0 +1,163 @@
+/**
+ * Contract definitions and their runtime validation.
+ *
+ * A contract is the tool's public identity: stable name, version, input and
+ * output schema, semantics, limits and policy metadata (DECL-01). It is
+ * deliberately model-free — implementations bind to it, it does not know about
+ * them — which is what lets two models serve one `stt_transcribe` instead of
+ * producing a duplicate tool each (BASE-02).
+ *
+ * Milestone A is explicit that "a copied schema with no runtime validation is not
+ * completion", so this module validates both directions: the contract DEFINITION
+ * is checked when registered, and every RESULT is checked against the declared
+ * output schema before it reaches a caller.
+ *
+ * @module @try-works/tool-mode-contracts/registry
+ */
+import { Ajv } from 'ajv';
+import { TOOL_META_SCHEMA } from "./meta.js";
+/** A contract that failed validation, with every reason. */
+export class ContractError extends Error {
+    name = 'ContractError';
+    /** The individual violations, in declaration order. */
+    violations;
+    constructor(subject, violations) {
+        super(`${subject} is not a valid contract: ${violations.join('; ')}`);
+        this.violations = violations;
+    }
+}
+/** A result that did not satisfy its contract's output schema. */
+export class ContractViolationError extends Error {
+    name = 'ContractViolationError';
+    violations;
+    constructor(contract, violations) {
+        super(`result violates the ${contract} contract: ${violations.join('; ')}`);
+        this.violations = violations;
+    }
+}
+/**
+ * The validator. `strict: false` because contract schemas use JSON Schema
+ * keywords that Ajv's strict mode rejects when they are merely annotated, and
+ * `allErrors` so a violation report lists every problem rather than the first.
+ */
+function createAjv() {
+    return new Ajv({ allErrors: true, strict: false, allowUnionTypes: true });
+}
+const ajv = createAjv();
+const outputValidators = new Map();
+const inputValidators = new Map();
+/** Render Ajv errors as stable, deduplicated strings. */
+function renderErrors(errors) {
+    const seen = new Set();
+    const out = [];
+    for (const error of errors ?? []) {
+        const path = error.instancePath === '' ? '(root)' : error.instancePath;
+        const line = `${path} ${error.message ?? 'is invalid'}`;
+        if (!seen.has(line)) {
+            seen.add(line);
+            out.push(line);
+        }
+    }
+    return out;
+}
+/**
+ * Validate a contract definition.
+ *
+ * This is deliberately strict about the identity fields: a contract whose
+ * `toolName` is not a legal tool name, or whose version is not semver, would
+ * register a tool that callers cannot address consistently.
+ * @param contract - the definition to check.
+ * @throws ContractError listing every violation.
+ */
+export function assertValidContract(contract) {
+    const violations = [];
+    if (!/^[a-z][a-z0-9_]*$/.test(contract.toolName)) {
+        violations.push(`toolName ${JSON.stringify(contract.toolName)} must be lower snake_case`);
+    }
+    if (!/^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$/.test(contract.contract)) {
+        violations.push(`contract ${JSON.stringify(contract.contract)} must be a dotted lower-case identity `
+            + '(for example "stt.transcribe" or "text.language_detect")');
+    }
+    if (!/^\d+\.\d+\.\d+$/.test(contract.version)) {
+        violations.push(`version ${JSON.stringify(contract.version)} must be semantic (x.y.z)`);
+    }
+    if (contract.description.trim().length < 10) {
+        violations.push('description must be a real sentence, not a placeholder');
+    }
+    const input = contract.inputSchema;
+    if (input.type !== 'object') {
+        violations.push('inputSchema root must be an object (clients require an object argument)');
+    }
+    const output = contract.outputSchema;
+    if (output.type !== 'object') {
+        violations.push('outputSchema root must be an object for broad client compatibility (DECL-02)');
+    }
+    else if (output.properties?.meta === undefined) {
+        violations.push('outputSchema must include the shared `meta` envelope (DECL-03)');
+    }
+    // DECL-02: an unconstrained open object is not an adequate leaf-tool contract.
+    if (output.additionalProperties !== false) {
+        violations.push('outputSchema must be closed (additionalProperties: false), not a generic open object (DECL-02)');
+    }
+    if (contract.unsupported.length === 0) {
+        violations.push('unsupported must name at least one case; an empty list claims universal support');
+    }
+    if (violations.length > 0)
+        throw new ContractError(contract.contract, violations);
+    // Schemas must be compilable, or the contract is unenforceable.
+    try {
+        inputValidators.set(contract.contract, ajv.compile(contract.inputSchema));
+    }
+    catch (error) {
+        throw new ContractError(contract.contract, [`inputSchema does not compile: ${message(error)}`]);
+    }
+    try {
+        outputValidators.set(contract.contract, ajv.compile(contract.outputSchema));
+    }
+    catch (error) {
+        throw new ContractError(contract.contract, [`outputSchema does not compile: ${message(error)}`]);
+    }
+}
+/**
+ * Validate caller arguments against the contract's input schema.
+ * @param contract - the contract to check against.
+ * @param args - the candidate arguments.
+ * @throws ContractViolationError listing every violation.
+ */
+export function assertValidInput(contract, args) {
+    const validate = inputValidators.get(contract.contract);
+    if (validate === undefined) {
+        throw new ContractError(contract.contract, ['input was validated before the contract was registered']);
+    }
+    if (!validate(args))
+        throw new ContractViolationError(contract.contract, renderErrors(validate.errors));
+}
+/**
+ * Validate a result against the contract's output schema.
+ *
+ * This runs before the value reaches a caller, so a violation surfaces as a
+ * tool failure rather than as malformed data downstream (AT-11).
+ * @param contract - the contract to check against.
+ * @param value - the candidate result.
+ * @throws ContractViolationError listing every violation.
+ */
+export function assertValidOutput(contract, value) {
+    const validate = outputValidators.get(contract.contract);
+    if (validate === undefined) {
+        throw new ContractError(contract.contract, ['result was validated before the contract was registered']);
+    }
+    if (!validate(value))
+        throw new ContractViolationError(contract.contract, renderErrors(validate.errors));
+}
+/** The meta envelope's own schema, exported for contract authors. */
+export { TOOL_META_SCHEMA };
+/** Best-effort message from an arbitrary thrown value. */
+function message(error) {
+    try {
+        return error instanceof Error ? error.message : String(error);
+    }
+    catch {
+        return '<unrenderable>';
+    }
+}
+//# sourceMappingURL=registry.js.map

package/node_modules/@try-works/tool-mode-contracts/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@try-works/tool-mode-contracts",
+  "version": "0.1.0",
+  "description": "Model-free standard tool contracts for Tool Mode: identities, schemas, semantics and runtime validation",
+  "license": "MIT",
+  "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/try-works/dsh-model-as-tool.git",
+    "directory": "packages/tool-mode-contracts"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": { "types": "./lib/index.d.ts", "default": "./lib/index.js" },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": ["lib/**/*.js", "lib/**/*.d.ts", "lib/**/*.d.ts.map", "README.md"],
+  "dependencies": {
+    "ajv": "^8.20.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "tsx --test tests/*.test.ts",
+    "prepack": "tsc -p tsconfig.build.json",
+    "prepare": "tsc -p tsconfig.build.json"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@try-works/dsh-model-as-tool",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Install Desert Ant Labs on-device models as DSH tools and skills, with per-platform capability gating",
   "keywords": [
     "dsh",
@@ -76,17 +76,22 @@
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "test": "tsx --test tests/*.test.ts",
-    "prepack": "tsc -p tsconfig.build.json",
-    "prepare": "tsc -p tsconfig.build.json"
+    "prepack": "node scripts/stage-bundle.mjs && npm run build",
+    "prepare": "tsc -p tsconfig.build.json",
+    "postpack": "node scripts/stage-bundle.mjs --clean"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
     "typescript": "^5.9.0"
   },
   "dependencies": {
-    "@try-works/tool-mode-contracts": "^0.1.0"
+    "@try-works/tool-mode-contracts": "^0.1.0",
+    "ajv": "^8.20.0"
   },
   "bin": {
     "dsh-tool-mode-mcp-stdio": "./bin/dsh-tool-mode-mcp-stdio.mjs"
-  }
+  },
+  "bundledDependencies": [
+    "@try-works/tool-mode-contracts"
+  ]
 }