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

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"}