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

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

@@ -81,34 +81,61 @@ function projectNode(node, path, runtimeEnforced) {
         }
         else if (keyword === 'type' && Array.isArray(value)) {
             /**
-             * A union `type` array advertises its CONCRETE member, with the union recorded as
-             * runtime-enforced.
+             * A union `type` array is advertised as `type: 'json'` (unconstrained), NOT
+             * narrowed to one member.
              *
-             * 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.
+             * 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.
              */
-            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)`);
-            }
+            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.
  *
@@ -204,55 +231,42 @@ 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.
+     * Nested array `items` are RETAINED, not stripped.
      *
-     * 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.
+     * 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 };
 }
 /**
- * Remove `items` at every depth in an output projection, recording each removal
- * (DECL-02).
+ * 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 the runtime-enforced list.
- * @param runtimeEnforced - collected keyword paths.
- * @returns the node without `items`.
+ * @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)) {
-        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;

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

@@ -7,11 +7,14 @@
  *
  * @module @try-works/tool-mode-contracts
  */
-export { assertValidContract, assertValidInput, assertValidOutput, ContractError, ContractViolationError, TOOL_META_SCHEMA, type ToolContract, } from './registry.ts';
+export { assertValidContract, assertValidInput, assertValidOutput, assertAgainstSchema, compileSchema, 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';
+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.

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

@@ -1 +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"}
+{"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,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;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;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,YAAY,EAkBrD,CAAA"}

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

@@ -7,18 +7,42 @@
  *
  * @module @try-works/tool-mode-contracts
  */
-export { assertValidContract, assertValidInput, assertValidOutput, ContractError, ContractViolationError, TOOL_META_SCHEMA, } from "./registry.js";
+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";
 /**
  * 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];
+export const STANDARD_CONTRACTS = [
+    sttTranscribe,
+    langDetect,
+    textEmbed,
+    textRerank,
+    textTitle,
+    imageDescribe,
+    multimodalEmbed,
+    semanticSimilarity,
+    semanticRank,
+    semanticClassify,
+    semanticDeduplicate,
+    mediaFindMoments,
+    decisionChoose,
+    decisionTest,
+    decisionScore,
+    structuredExtract,
+    toolsPlan,
+];
 //# sourceMappingURL=index.js.map

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

@@ -43,11 +43,11 @@ export declare class ContractError extends Error {
     readonly violations: readonly string[];
     constructor(subject: string, violations: readonly string[]);
 }
-/** A result that did not satisfy its contract's output schema. */
+/** A value that did not satisfy a declared schema. */
 export declare class ContractViolationError extends Error {
     readonly name = "ContractViolationError";
     readonly violations: readonly string[];
-    constructor(contract: string, violations: readonly string[]);
+    constructor(subject: string, violations: readonly string[]);
 }
 /**
  * Validate a contract definition.
@@ -78,4 +78,30 @@ export declare function assertValidInput(contract: ToolContract, args: unknown):
 export declare function assertValidOutput(contract: ToolContract, value: unknown): void;
 /** The meta envelope's own schema, exported for contract authors. */
 export { TOOL_META_SCHEMA };
+/**
+ * Compile an arbitrary JSON Schema once, for a host that serves manifest-declared
+ * tool schemas rather than registered contracts.
+ *
+ * Compiling at REGISTRATION (in the host's try/catch) means a malformed schema
+ * fails when the tool is registered, not on the first caller's event-loop tick —
+ * and it is never re-compiled per call, which a per-call text-keyed cache could
+ * not guarantee.
+ * @param schema - the JSON Schema to compile.
+ * @throws ContractError when the schema does not compile.
+ * @returns a validator whose violations are rendered by {@link assertAgainstSchema}.
+ */
+export declare function compileSchema(schema: Readonly<Record<string, unknown>>): (value: unknown) => readonly string[];
+/**
+ * Validate an arbitrary value against a compiled declared schema.
+ *
+ * The full-schema counterpart of {@link assertValidInput}/{@link assertValidOutput}:
+ * the projected advertisement the DSH registry validates is deliberately LOOSER
+ * (union members become `json`, unsupported keywords are dropped), so without this
+ * the dropped keywords are enforced nowhere for manifest-declared tools.
+ * @param subject - the tool or schema name used in the violation message.
+ * @param validate - the compiled validator, from {@link compileSchema}.
+ * @param value - the candidate value.
+ * @throws ContractViolationError listing every violation.
+ */
+export declare function assertAgainstSchema(subject: string, validate: (value: unknown) => readonly string[], value: unknown): void;
 //# sourceMappingURL=registry.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,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,sDAAsD;AACtD,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,SAAkB,IAAI,4BAA2B;IACjD,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;gBAC1B,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE;CAI3D;AA0ED;;;;;;;;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;AAE3B;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,SAAS,MAAM,EAAE,CAQ9G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,SAAS,MAAM,EAAE,EAC/C,KAAK,EAAE,OAAO,GACb,IAAI,CAGN"}

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

@@ -14,7 +14,11 @@
  *
  * @module @try-works/tool-mode-contracts/registry
  */
-import { Ajv } from 'ajv';
+// The explicit `.js` suffix is REQUIRED for packed installs: plain Node ESM does
+// not apply extension resolution to package subpaths, and the workspace's tsx
+// loader masks that (the round-67 packed-orchestration run caught exactly this
+// failure). extension-needle's validation.ts uses the same spelling.
+import Ajv2020 from 'ajv/dist/2020.js';
 import { TOOL_META_SCHEMA } from "./meta.js";
 /** A contract that failed validation, with every reason. */
 export class ContractError extends Error {
@@ -26,26 +30,66 @@ export class ContractError extends Error {
         this.violations = violations;
     }
 }
-/** A result that did not satisfy its contract's output schema. */
+/** A value that did not satisfy a declared schema. */
 export class ContractViolationError extends Error {
     name = 'ContractViolationError';
     violations;
-    constructor(contract, violations) {
-        super(`result violates the ${contract} contract: ${violations.join('; ')}`);
+    constructor(subject, violations) {
+        super(`value violates the ${subject} schema: ${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.
+ * The validator, on the 2020-12 dialect.
+ *
+ * 2020-12 rather than draft-07 because extension-declared schemas ship as
+ * 2020-12 documents (`$schema`, `$id`, `$defs` — the extension-needle package's
+ * tools-plan/structured-extract schemas are the concrete case): a draft-07
+ * compiler cannot resolve `#/$defs/...` references, so those real packages
+ * could not be activated in the host. `strict: false` for the same reason as
+ * before — contract schemas annotate keywords Ajv's strict mode rejects when
+ * they are merely descriptive, and a strict-mode THROW on an annotation would
+ * refuse a schema that validates fine. A schema that does not COMPILE (an
+ * unresolvable `$ref`, a structurally broken keyword) still throws at
+ * registration, so a bad schema refuses loudly rather than being accepted.
+ * `allowUnionTypes` admits `type: ["number", "null"]`-style unions, which the
+ * shipped needle schemas use for nullable fields. `allErrors` keeps the
+ * violation report listing every problem rather than the first.
  */
 function createAjv() {
-    return new Ajv({ allErrors: true, strict: false, allowUnionTypes: true });
+    return new Ajv2020({ allErrors: true, strict: false, allowUnionTypes: true });
 }
 const ajv = createAjv();
 const outputValidators = new Map();
 const inputValidators = new Map();
+/**
+ * Validators for $id-bearing schemas, keyed by the id itself.
+ *
+ * Ajv registers a compiled schema under its `$id`, and compiling the same id a
+ * second time THROWS "already exists" — which would make re-activating an
+ * extension (or two tools sharing one declared schema file) fail on the second
+ * compile. Identical content re-compiles to the same validator; DIFFERENT
+ * content under one id is a refusal, because two schemas sharing an id is
+ * exactly the drift a caller must never silently inherit.
+ */
+const compiledById = new Map();
+/** Compile a schema, tolerating a repeat compile of identical $id content. */
+function compileTracked(schema) {
+    const id = typeof schema.$id === 'string' ? schema.$id : undefined;
+    if (id === undefined)
+        return ajv.compile(schema);
+    const serialized = JSON.stringify(schema);
+    const cached = compiledById.get(id);
+    if (cached !== undefined) {
+        if (cached.serialized !== serialized) {
+            throw new ContractError('declared-schema', [`a schema with $id ${JSON.stringify(id)} was already compiled from different content; two different schemas must not share an id`]);
+        }
+        return cached.validate;
+    }
+    const validate = ajv.compile(schema);
+    compiledById.set(id, { serialized, validate });
+    return validate;
+}
 /** Render Ajv errors as stable, deduplicated strings. */
 function renderErrors(errors) {
     const seen = new Set();
@@ -106,13 +150,13 @@ export function assertValidContract(contract) {
         throw new ContractError(contract.contract, violations);
     // Schemas must be compilable, or the contract is unenforceable.
     try {
-        inputValidators.set(contract.contract, ajv.compile(contract.inputSchema));
+        inputValidators.set(contract.contract, compileTracked(contract.inputSchema));
     }
     catch (error) {
         throw new ContractError(contract.contract, [`inputSchema does not compile: ${message(error)}`]);
     }
     try {
-        outputValidators.set(contract.contract, ajv.compile(contract.outputSchema));
+        outputValidators.set(contract.contract, compileTracked(contract.outputSchema));
     }
     catch (error) {
         throw new ContractError(contract.contract, [`outputSchema does not compile: ${message(error)}`]);
@@ -151,6 +195,45 @@ export function assertValidOutput(contract, value) {
 }
 /** The meta envelope's own schema, exported for contract authors. */
 export { TOOL_META_SCHEMA };
+/**
+ * Compile an arbitrary JSON Schema once, for a host that serves manifest-declared
+ * tool schemas rather than registered contracts.
+ *
+ * Compiling at REGISTRATION (in the host's try/catch) means a malformed schema
+ * fails when the tool is registered, not on the first caller's event-loop tick —
+ * and it is never re-compiled per call, which a per-call text-keyed cache could
+ * not guarantee.
+ * @param schema - the JSON Schema to compile.
+ * @throws ContractError when the schema does not compile.
+ * @returns a validator whose violations are rendered by {@link assertAgainstSchema}.
+ */
+export function compileSchema(schema) {
+    let validate;
+    try {
+        validate = compileTracked(schema);
+    }
+    catch (error) {
+        throw new ContractError('declared-schema', [`schema does not compile: ${message(error)}`]);
+    }
+    return value => (validate(value) ? [] : renderErrors(validate.errors));
+}
+/**
+ * Validate an arbitrary value against a compiled declared schema.
+ *
+ * The full-schema counterpart of {@link assertValidInput}/{@link assertValidOutput}:
+ * the projected advertisement the DSH registry validates is deliberately LOOSER
+ * (union members become `json`, unsupported keywords are dropped), so without this
+ * the dropped keywords are enforced nowhere for manifest-declared tools.
+ * @param subject - the tool or schema name used in the violation message.
+ * @param validate - the compiled validator, from {@link compileSchema}.
+ * @param value - the candidate value.
+ * @throws ContractViolationError listing every violation.
+ */
+export function assertAgainstSchema(subject, validate, value) {
+    const violations = validate(value);
+    if (violations.length > 0)
+        throw new ContractViolationError(subject, violations);
+}
 /** Best-effort message from an arbitrary thrown value. */
 function message(error) {
     try {

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

@@ -14,7 +14,6 @@
   "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"],

package/node_modules/@try-works/tool-mode-extension-sdk/bin/dsh-tool-mode.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+/**
+ * The `dsh-tool-mode` executable (EXT-31).
+ *
+ * A thin shim: it wires real process streams into the tested CLI and translates
+ * the returned code into an exit status. All the logic lives in the library, so
+ * every path — including the refusals — is exercised by tests rather than only by
+ * running the binary by hand.
+ */
+
+import { runToolModeCli } from '../lib/cli.js'
+
+const code = await runToolModeCli(
+  process.argv.slice(2),
+  {
+    out: line => process.stdout.write(`${line}\n`),
+    err: line => process.stderr.write(`${line}\n`),
+  },
+)
+process.exitCode = code

package/node_modules/@try-works/tool-mode-extension-sdk/lib/cli.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The operator command family (EXT-31).
+ *
+ * EXT-31 is explicit that these are REQUIRED NEW FUNCTIONALITY, not existing npm
+ * or DSH commands, and that offline edits must hold exclusive store ownership. So
+ * every mutating command takes the store lock, and the CLI refuses rather than
+ * racing a running host.
+ *
+ * The entry point takes argv and an output sink instead of reading `process`
+ * directly. A CLI that can only be exercised by spawning a child process is a CLI
+ * whose failure paths are tested by hand or not at all, and the failure paths here
+ * are the security-relevant ones.
+ *
+ * The management surface is deliberately NOT the inference surface: EXT-31 forbids
+ * exposing the management channel on the MCP tool surface by default, and nothing
+ * in this module registers a tool.
+ *
+ * @module @try-works/tool-mode-extension-sdk/cli
+ */
+import { type ContributionRegistrar } from './install/lifecycle.ts';
+/** Where the CLI writes. Injected so a test can capture output. */
+export interface CliIo {
+    /** Write one line of normal output. */
+    out(line: string): void;
+    /** Write one line of error output. */
+    err(line: string): void;
+}
+/** Options resolved from argv. */
+export interface CliOptions {
+    /** The extension store root. */
+    readonly store: string;
+    /** The profile to act on. */
+    readonly profile: string;
+    /** Positional arguments after the command. */
+    readonly positional: readonly string[];
+    /** `--flag` names and their values. */
+    readonly flags: Readonly<Record<string, string | true>>;
+}
+/** What the CLI needs from the environment to act. */
+export interface CliDependencies {
+    /** A registrar for activation. Without one, activation is refused rather than faked. */
+    readonly registrar?: ContributionRegistrar;
+    /** Parse and install from a specifier; injected so the CLI owns no network stack. */
+    readonly install?: (spec: string, integrity: string | undefined, store: string) => Promise<string>;
+    /**
+     * The recipes authoring runner, forwarded to by the `recipes` namespace
+     * (RCP-08). When absent, the SDK resolves `@try-works/tool-mode-recipes/cli`
+     * lazily at invocation time; when that also fails, the command answers a
+     * PRECISE refusal — the SDK never duplicates recipe semantics and never
+     * depends on the recipes package at import time.
+     */
+    readonly recipeCliRunner?: {
+        runRecipeCli(argv: readonly string[], io: CliIo): Promise<number>;
+    };
+    /** Override the lazy resolver (tests); returns the runner or undefined. */
+    readonly resolveRecipeCli?: () => Promise<{
+        runRecipeCli(argv: readonly string[], io: CliIo): Promise<number>;
+    } | undefined>;
+}
+/**
+ * Parse argv into options.
+ *
+ * Anything unrecognised is REFUSED rather than ignored: a mistyped flag that is
+ * silently dropped turns `--deactivate` into a command the operator did not ask
+ * for, which on `uninstall` is the difference between previewing and removing.
+ * @param argv - arguments after the executable name.
+ * @returns the parsed options.
+ * @throws ManagementError when a flag is unknown or a value is missing.
+ */
+export declare function parseArgs(argv: readonly string[]): CliOptions;
+/**
+ * Run one command.
+ *
+ * @param argv - arguments after the executable name.
+ * @param io - output sinks.
+ * @param dependencies - the registrar and installer to act with.
+ * @returns the process exit code.
+ */
+export declare function runToolModeCli(argv: readonly string[], io: CliIo, dependencies?: CliDependencies): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/node_modules/@try-works/tool-mode-extension-sdk/lib/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,EAAsB,KAAK,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AAIvF,mEAAmE;AACnE,MAAM,WAAW,KAAK;IACpB,uCAAuC;IACvC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,sCAAsC;IACtC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAED,kCAAkC;AAClC,MAAM,WAAW,UAAU;IACzB,gCAAgC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,6BAA6B;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,8CAA8C;IAC9C,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC,uCAAuC;IACvC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAA;CACxD;AAED,sDAAsD;AACtD,MAAM,WAAW,eAAe;IAC9B,wFAAwF;IACxF,QAAQ,CAAC,SAAS,CAAC,EAAE,qBAAqB,CAAA;IAC1C,qFAAqF;IACrF,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAClG;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE;QAAE,YAAY,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;KAAE,CAAA;IAChG,2EAA2E;IAC3E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,OAAO,CAAC;QAAE,YAAY,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;KAAE,GAAG,SAAS,CAAC,CAAA;CAC7H;AA4ED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,UAAU,CA4C7D;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,KAAK,EACT,YAAY,GAAE,eAAoB,GACjC,OAAO,CAAC,MAAM,CAAC,CA8DjB"}