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

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

@@ -0,0 +1,445 @@
+/**
+ * The remaining standard tool contracts (EXT-21, task-69).
+ *
+ * These descriptors are SCHEMAS AND SEMANTICS ONLY — no model bindings, no
+ * weights, no host code (EXT-17). Each is a closed schema with honest
+ * `semantics`, `limits` and `unsupported` records, matching the vocabulary the
+ * host registers and the extension packages implement against.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/standard
+ */
+import { withMeta } from "../meta.js";
+/** The `text.title` contract at version 1.0.0 (RCP-12). */
+export const textTitle = {
+    contract: 'text.title',
+    version: '1.0.0',
+    toolName: 'text_title',
+    description: 'Propose a bounded title and one-sentence description for supplied text through an authorized harness model.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['text'],
+        properties: {
+            text: { type: 'string', minLength: 1, maxLength: 32768 },
+            kind: { type: 'string', enum: ['section', 'page', 'document'], default: 'section' },
+            repairFeedback: { type: 'string', minLength: 1, maxLength: 512 },
+        },
+    },
+    outputSchema: withMeta({
+        title: { type: 'string', minLength: 1, maxLength: 80 },
+        description: { type: 'string', minLength: 1, maxLength: 240 },
+    }, ['title', 'description']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: {
+        maxInputCharacters: 32768,
+        maxTitleCharacters: 80,
+        maxDescriptionCharacters: 240,
+        maxRepairs: 1,
+    },
+    unsupported: [
+        'Invented facts: the title must state only what the text supports.',
+        'Empty titles and descriptions.',
+    ],
+};
+/** The `image.describe` contract at version 1.0.0 (HLM-12). */
+export const imageDescribe = {
+    contract: 'image.describe',
+    version: '1.0.0',
+    toolName: 'describe_image',
+    description: 'Describe the visible content of an approved image through an authorized harness model, with honest uncertainty.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['image_path'],
+        properties: {
+            image_path: { type: 'string', minLength: 1, description: 'An approved image resolved by the host.' },
+            focus: { type: 'string', minLength: 1, maxLength: 500 },
+        },
+    },
+    outputSchema: withMeta({
+        description: { type: 'string', minLength: 1 },
+    }, ['description']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'visible-image-content',
+    },
+    limits: {
+        maxImages: 1,
+        maxFocusCharacters: 500,
+    },
+    unsupported: [
+        'Invented hidden facts, exact OCR or full transcription claims.',
+        'Treating text drawn in the image as instructions.',
+    ],
+};
+/** The `embed.multimodal` contract at version 1.0.0 (EmbeddingGemma family). */
+export const multimodalEmbed = {
+    contract: 'embed.multimodal',
+    version: '1.0.0',
+    toolName: 'multimodal_embed',
+    description: 'Embed a text, image or audio input into a shared vector space.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['input'],
+        properties: {
+            input: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['kind'],
+                properties: {
+                    kind: { type: 'string', enum: ['text', 'image', 'audio'] },
+                    text: { type: 'string', minLength: 1, maxLength: 32768 },
+                    media: { type: 'string', description: 'An approved media reference resolved by the host.' },
+                },
+            },
+        },
+    },
+    outputSchema: withMeta({
+        embedding: { type: 'array', items: { type: 'number' }, minItems: 1 },
+        dimensions: { type: 'integer', minimum: 1 },
+    }, ['embedding', 'dimensions']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'text-image-audio',
+    },
+    limits: {
+        maxInputCharacters: 32768,
+        maxMediaBytes: 8388608,
+    },
+    unsupported: ['Video frames beyond the declared sampler.'],
+};
+/** The `semantic.similarity` contract at version 1.0.0. */
+export const semanticSimilarity = {
+    contract: 'semantic.similarity',
+    version: '1.0.0',
+    toolName: 'semantic_similarity',
+    description: 'Score the similarity of two bounded texts.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['left', 'right'],
+        properties: {
+            left: { type: 'string', minLength: 1, maxLength: 32768 },
+            right: { type: 'string', minLength: 1, maxLength: 32768 },
+        },
+    },
+    outputSchema: withMeta({ score: { type: 'number' } }, ['score']),
+    semantics: {
+        scoreKind: 'cosine-similarity',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxInputCharacters: 32768 },
+    unsupported: ['Calibrated probabilities.'],
+};
+/** The `semantic.rank` contract at version 1.0.0. */
+export const semanticRank = {
+    contract: 'semantic.rank',
+    version: '1.0.0',
+    toolName: 'semantic_rank',
+    description: 'Rank candidates by semantic distance to a query.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['query', 'candidates'],
+        properties: {
+            query: { type: 'string', minLength: 1, maxLength: 4096 },
+            candidates: {
+                type: 'array', minItems: 1, maxItems: 100,
+                items: { type: 'string', minLength: 1, maxLength: 8192 },
+            },
+        },
+    },
+    outputSchema: withMeta({
+        ranked: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['index', 'score'],
+                properties: { index: { type: 'integer', minimum: 0 }, score: { type: 'number' } },
+            },
+        },
+    }, ['ranked']),
+    semantics: {
+        scoreKind: 'cosine-similarity',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxCandidates: 100 },
+    unsupported: ['Calibrated probabilities.'],
+};
+/** The `semantic.classify` contract at version 1.0.0. */
+export const semanticClassify = {
+    contract: 'semantic.classify',
+    version: '1.0.0',
+    toolName: 'semantic_classify',
+    description: 'Classify a text into the closest of the supplied labels, with the ability to abstain.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['text', 'labels'],
+        properties: {
+            text: { type: 'string', minLength: 1, maxLength: 32768 },
+            labels: { type: 'array', minItems: 1, maxItems: 64, items: { type: 'string', minLength: 1, maxLength: 200 } },
+        },
+    },
+    outputSchema: withMeta({
+        label: { type: ['string', 'null'] },
+        abstained: { type: 'boolean' },
+        scores: { type: 'array', items: { type: 'number' } },
+    }, ['label', 'abstained', 'scores']),
+    semantics: {
+        scoreKind: 'cosine-similarity',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxLabels: 64 },
+    unsupported: ['Forcing a label when every score is below the abstain margin.'],
+};
+/** The `semantic.deduplicate` contract at version 1.0.0. */
+export const semanticDeduplicate = {
+    contract: 'semantic.deduplicate',
+    version: '1.0.0',
+    toolName: 'semantic_deduplicate',
+    description: 'Group near-duplicate texts into greedy clusters around their representatives.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['texts'],
+        properties: {
+            texts: { type: 'array', minItems: 1, maxItems: 1000, items: { type: 'string', minLength: 1, maxLength: 8192 } },
+        },
+    },
+    outputSchema: withMeta({
+        groups: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['members'],
+                properties: { members: { type: 'array', items: { type: 'integer', minimum: 0 } } },
+            },
+        },
+    }, ['groups']),
+    semantics: {
+        scoreKind: 'cosine-similarity',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxTexts: 1000 },
+    unsupported: ['Transitive-closure equivalence: clustering is greedy, not global.'],
+};
+/** The `media.find_moments` contract at version 1.0.0. */
+export const mediaFindMoments = {
+    contract: 'media.find_moments',
+    version: '1.0.0',
+    toolName: 'media_find_moments',
+    description: 'Find the media windows most relevant to a query within approved media.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['media', 'query'],
+        properties: {
+            media: { type: 'string', description: 'An approved media reference resolved by the host.' },
+            query: { type: 'string', minLength: 1, maxLength: 4096 },
+        },
+    },
+    outputSchema: withMeta({
+        windows: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['startMs', 'endMs', 'score'],
+                properties: {
+                    startMs: { type: 'number', minimum: 0 },
+                    endMs: { type: 'number', minimum: 0 },
+                    score: { type: 'number' },
+                },
+            },
+        },
+    }, ['windows']),
+    semantics: {
+        scoreKind: 'cosine-similarity',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'approved-media',
+    },
+    limits: { maxWindows: 32, maxQueryCharacters: 4096 },
+    unsupported: ['Windows outside the approved media bounds.'],
+};
+/** The `decision.choose` contract at version 1.0.0 (Laya family). */
+export const decisionChoose = {
+    contract: 'decision.choose',
+    version: '1.0.0',
+    toolName: 'decision_choose',
+    description: 'Choose one option from a bounded set for a stated decision, with a confidence verdict.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['decision', 'options'],
+        properties: {
+            decision: { type: 'string', minLength: 1, maxLength: 4096 },
+            options: { type: 'array', minItems: 2, maxItems: 16, items: { type: 'string', minLength: 1, maxLength: 400 } },
+        },
+    },
+    outputSchema: withMeta({
+        chosen: { type: 'integer', minimum: 0 },
+        confidence: { type: 'string', enum: ['confident', 'likely', 'tentative'] },
+        reason: { type: 'string', minLength: 1 },
+    }, ['chosen', 'confidence', 'reason']),
+    semantics: {
+        scoreKind: 'vendor-reported-confidence',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'stated-decision',
+    },
+    limits: { maxOptions: 16 },
+    unsupported: ['Open-ended generation: this contract chooses, it does not compose.'],
+};
+/** The `decision.test` contract at version 1.0.0. */
+export const decisionTest = {
+    contract: 'decision.test',
+    version: '1.0.0',
+    toolName: 'decision_test',
+    description: 'Test a binary predicate against supplied text and report the verdict with evidence.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['text', 'predicate'],
+        properties: {
+            text: { type: 'string', minLength: 1, maxLength: 32768 },
+            predicate: { type: 'string', minLength: 1, maxLength: 1000 },
+        },
+    },
+    outputSchema: withMeta({
+        verdict: { type: 'boolean' },
+        confidence: { type: 'string', enum: ['confident', 'likely', 'tentative'] },
+        evidence: { type: 'string', minLength: 1 },
+    }, ['verdict', 'confidence', 'evidence']),
+    semantics: {
+        scoreKind: 'vendor-reported-confidence',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxInputCharacters: 32768 },
+    unsupported: ['Testing predicates about content outside the supplied text.'],
+};
+/** The `decision.score` contract at version 1.0.0. */
+export const decisionScore = {
+    contract: 'decision.score',
+    version: '1.0.0',
+    toolName: 'decision_score',
+    description: 'Score supplied options against one criterion on a declared bounded scale.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['criterion', 'options'],
+        properties: {
+            criterion: { type: 'string', minLength: 1, maxLength: 2000 },
+            options: { type: 'array', minItems: 1, maxItems: 16, items: { type: 'string', minLength: 1, maxLength: 400 } },
+        },
+    },
+    outputSchema: withMeta({
+        scores: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['index', 'score'],
+                properties: { index: { type: 'integer', minimum: 0 }, score: { type: 'number', minimum: 0, maximum: 10 } },
+            },
+        },
+    }, ['scores']),
+    semantics: {
+        scoreKind: 'bounded-scale-0-10',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'stated-criterion',
+    },
+    limits: { maxOptions: 16 },
+    unsupported: ['Scores outside the declared 0-10 scale.'],
+};
+/** The `structured.extract` contract at version 1.0.0 (Needle family). */
+export const structuredExtract = {
+    contract: 'structured.extract',
+    version: '1.0.0',
+    toolName: 'structured_extract',
+    description: 'Extract typed fields from supplied text against the caller-declared, host-approved schema snapshot.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['text', 'schema'],
+        properties: {
+            text: { type: 'string', minLength: 1, maxLength: 32768 },
+            schema: { type: 'object', description: 'The host-approved extraction schema snapshot (NDL-02).' },
+        },
+    },
+    outputSchema: withMeta({
+        extracted: { type: 'object', description: 'The typed extraction payload.' },
+    }, ['extracted']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: { maxInputCharacters: 32768 },
+    unsupported: ['Executing a caller-supplied schema that the host has not approved.'],
+};
+/** The `plan.tools` contract at version 1.0.0 (Needle family). */
+export const toolsPlan = {
+    contract: 'plan.tools',
+    version: '1.0.0',
+    toolName: 'tools_plan',
+    description: 'Propose a read-only tool plan against the host-frozen authorized tool snapshot (NDL-02).',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['objective'],
+        properties: {
+            objective: { type: 'string', minLength: 1, maxLength: 4096 },
+        },
+    },
+    outputSchema: withMeta({
+        proposal: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['tool', 'arguments'],
+                properties: {
+                    tool: { type: 'string', minLength: 1 },
+                    arguments: { type: 'object' },
+                },
+            },
+        },
+    }, ['proposal']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'proposal-only',
+    },
+    limits: { maxObjectiveCharacters: 4096 },
+    unsupported: [
+        'Executing the proposal: this contract proposes; the host re-checks authorization before any dispatch (NDL-03).',
+    ],
+};
+//# sourceMappingURL=standard.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/contracts/text-embed.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `text.embed` — the legacy MiniLM text-embedding contract (TOOL-04, BASE-12).
+ *
+ * Model-free: any conforming implementation binds to it. This is the 384-
+ * dimensional MiniLM space, PRESERVED separately from the EmbeddingGemma 2
+ * 768-dimensional space — the two must never be mixed, and a stored 384-d
+ * index must never be quietly fed 768-wide vectors.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-embed
+ */
+import type { ToolContract } from '../registry.ts';
+/** The `text.embed` contract at version 1.0.0. */
+export declare const textEmbed: ToolContract;
+//# sourceMappingURL=text-embed.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-embed.d.ts","sourceRoot":"","sources":["../../src/contracts/text-embed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,kDAAkD;AAClD,eAAO,MAAM,SAAS,EAAE,YA0DvB,CAAA"}

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

@@ -0,0 +1,63 @@
+/**
+ * `text.embed` — the legacy MiniLM text-embedding contract (TOOL-04, BASE-12).
+ *
+ * Model-free: any conforming implementation binds to it. This is the 384-
+ * dimensional MiniLM space, PRESERVED separately from the EmbeddingGemma 2
+ * 768-dimensional space — the two must never be mixed, and a stored 384-d
+ * index must never be quietly fed 768-wide vectors.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-embed
+ */
+import { withMeta } from "../meta.js";
+/** The `text.embed` contract at version 1.0.0. */
+export const textEmbed = {
+    contract: 'text.embed',
+    version: '1.0.0',
+    toolName: 'text_embed',
+    description: 'Embed a batch of texts into the legacy 384-dimensional MiniLM embedding space (mean pooling, '
+        + 'L2-normalized, input order preserved). This is a compatibility space: stored 384-d vectors and '
+        + 'indexes remain pinned to it, and switching to another model requires explicit re-embedding. '
+        + 'All values are finite; an empty or overlong batch is refused, never silently truncated.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['texts'],
+        properties: {
+            texts: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 32,
+                items: { type: 'string', minLength: 1, maxLength: 32768 },
+                description: 'The texts in the caller\'s order; that order is the embedding order (TOOL-04).',
+            },
+        },
+    },
+    outputSchema: withMeta({
+        embeddings: {
+            type: 'array',
+            items: {
+                type: 'array',
+                items: { type: 'number' },
+                description: 'One 384-dimensional L2-normalized vector per input text, in input order.',
+            },
+        },
+        dimensions: { const: 384 },
+        normalized: { const: true },
+    }, ['embeddings', 'dimensions', 'normalized']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: {
+        maxTexts: 32,
+        maxInputCharacters: 32768,
+        dimensions: 384,
+    },
+    unsupported: [
+        'Mixing 384-dimensional and 768-dimensional vectors in one index.',
+        'Silently truncating an overlong batch.',
+    ],
+};
+//# sourceMappingURL=text-embed.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * `text.rerank` — the cross-encoder reranking contract (TOOL-05).
+ *
+ * Model-free: any conforming implementation binds to it. The scores are
+ * RANKING LOGITS from a cross-encoder — not embedding cosines, and the two
+ * score kinds are never interchangeable (the semantic_rank tool's
+ * cosine_similarity is a different quantity).
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-rerank
+ */
+import type { ToolContract } from '../registry.ts';
+/** The `text.rerank` contract at version 1.0.0. */
+export declare const textRerank: ToolContract;
+//# sourceMappingURL=text-rerank.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text-rerank.d.ts","sourceRoot":"","sources":["../../src/contracts/text-rerank.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,mDAAmD;AACnD,eAAO,MAAM,UAAU,EAAE,YAuExB,CAAA"}