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

package/lib/update-surface.js

@@ -0,0 +1,224 @@
+/**
+ * The host's UpdateHostSurface (EXT-30, slice 3): the operator approval
+ * surface, the two-phase commit with quiesce/rebind hooks, and the standalone
+ * rollback with a bounded rebindRestored.
+ *
+ * The SDK owns the durable mechanics (staging, validation reports, approval
+ * RECORDS, the atomic pointer, the auto-rollback); this module owns the HOST
+ * decisions the SDK refuses to invent (design doc §6):
+ *
+ * - the pending listing + approve/deny over the SDK's approval records;
+ * - the quiesce (stop old-generation admissions) and the rebind (republish the
+ *   new generation) — supplied as closures so the index wiring passes the
+ *   lifecycle/registrar pair and tests can pass recorded fakes;
+ * - the ALL-OR-NOTHING rebind wrapper: the SDK's auto-rollback re-runs NO
+ *   hooks (the REBIND-REVERT contract), so a rebind failure restores the
+ *   previous surface HERE, before the pointer rollback lands;
+ * - the host-side timeout bound on rebindRestored (the SDK awaits it with no
+ *   bound; only the management caller must not hang).
+ *
+ * The management channel stays the ONLY caller of this surface (AT-39).
+ *
+ * @module @dsh-tool-mode/update-surface
+ */
+import { commitUpdate, recordApproval, rollback, ExtensionStore } from '@try-works/tool-mode-extension-sdk';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+/** The current pointer for one extension, read from the profile pointers. */
+function currentPointer(store, profile, extensionId) {
+    const pointers = store.readProfilePointers(profile);
+    if (pointers.corrupt) {
+        throw new Error(`the profile pointers are unreadable: ${pointers.diagnostic ?? 'unknown reason'}`);
+    }
+    return pointers.value.activeVersions[extensionId];
+}
+/** The staged-update metadata file for one staged directory. */
+const stageMetadataPath = (stagedDir) => join(stagedDir, 'update-stage.json');
+/**
+ * A rebind failure whose PREVIOUS surface the wrapper already restored.
+ *
+ * The commit catch would otherwise restore the previous surface a second time
+ * (the REBIND-REVERT contract: the wrapper owns the revert; the catch owns the
+ * post-quiesce-failure restore, which is a different situation).
+ */
+class RebindRestoredFailure extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = 'RebindRestoredFailure';
+    }
+}
+/** Bound one promise host-side: the caller stops waiting, the work may continue. */
+async function withTimeout(promise, timeoutMs, label) {
+    let timer;
+    const bound = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs} ms (host-side bound)`)), timeoutMs);
+        if (typeof timer === 'object' && timer !== null && 'unref' in timer && typeof timer.unref === 'function') {
+            // Kept REFERENCED deliberately: a hanging rebind must not let the process
+            // exit mid-update; the timeout is what bounds it.
+        }
+    });
+    try {
+        return await Promise.race([promise, bound]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+/**
+ * Create the host update surface.
+ * @param options - the store location, profile, lifecycle hooks and the timeout bound.
+ * @returns the surface.
+ */
+export function createUpdateHostSurface(options) {
+    const store = new ExtensionStore(options.storeDir);
+    const timeoutMs = options.rebindTimeoutMs ?? 30_000;
+    const { profile, hooks } = options;
+    /**
+     * The surfaces the rebind wrapper ALREADY restored. The SDK wraps a failed
+     * rebind into its own ManagementError, so the commit catch cannot see the
+     * marker on the error itself; this in-surface set carries it instead (the
+     * REBIND-REVERT contract: the wrapper's revert is never duplicated).
+     */
+    const wrapperRestored = new Set();
+    return {
+        listPendingUpdates() {
+            const staging = join(options.storeDir, 'staging');
+            if (!existsSync(staging))
+                return [];
+            const entries = [];
+            for (const name of readdirSync(staging)) {
+                if (!name.endsWith('.staged'))
+                    continue;
+                const stagedDir = join(staging, name);
+                const metadataPath = stageMetadataPath(stagedDir);
+                if (!existsSync(metadataPath))
+                    continue; // an aborted stage attempt; never listed
+                let metadata;
+                try {
+                    metadata = JSON.parse(readFileSync(metadataPath, 'utf8'));
+                }
+                catch {
+                    continue; // a corrupt metadata record fails closed: not listed, never committed
+                }
+                if (typeof metadata.extensionId !== 'string' || typeof metadata.stagedVersion !== 'string'
+                    || typeof metadata.report !== 'object' || metadata.report === null) {
+                    continue;
+                }
+                const approval = store.readApproval(metadata.extensionId, metadata.stagedVersion);
+                if (approval.corrupt) {
+                    entries.push({ ...metadata, approval: { approved: false, reason: `the approval record is unreadable: ${approval.diagnostic ?? 'unknown reason'}` } });
+                    continue;
+                }
+                entries.push({
+                    extensionId: metadata.extensionId,
+                    stagedVersion: metadata.stagedVersion,
+                    currentVersion: metadata.currentVersion,
+                    stagedAt: metadata.stagedAt,
+                    report: metadata.report,
+                    ...approval.value === undefined ? {} : {
+                        approval: {
+                            approved: approval.value.approved,
+                            ...('reason' in approval.value && typeof approval.value.reason === 'string'
+                                ? { reason: approval.value.reason }
+                                : {}),
+                        },
+                    },
+                });
+            }
+            return entries;
+        },
+        decide(extensionId, stagedVersion, decision) {
+            recordApproval({ storeDir: options.storeDir, extensionId, stagedVersion, decision });
+        },
+        async commit(extensionId, stagedVersion) {
+            // The pointer BEFORE the commit: the restore target when a post-quiesce
+            // failure withdraws the old surface.
+            const previous = currentPointer(store, profile, extensionId);
+            /** True once the quiesce hook was INVOKED: after that a failure owes a restore. */
+            let quiesced = false;
+            const quiescePrevious = async () => {
+                // Set BEFORE the hook runs: a quiesce that threw may have withdrawn the
+                // surface partially, and the restore is the safe recovery either way.
+                quiesced = true;
+                await hooks.quiesce(extensionId);
+            };
+            /**
+             * ALL-OR-NOTHING with the revert INSIDE the wrapper (the REBIND-REVERT
+             * contract): the SDK's auto-rollback re-runs no hooks, so a rebind that
+             * partially published must restore the previous surface itself before
+             * rethrowing. The previous pointer is still recorded under the rolled-back
+             * value after the SDK's auto-rollback, so re-activating it lands on the
+             * version the pointer will name.
+             */
+            const rebindNext = async (nextVersion) => {
+                try {
+                    await withTimeout(hooks.rebind(extensionId, nextVersion), timeoutMs, `rebind ${extensionId}@${nextVersion}`);
+                }
+                catch (error) {
+                    if (previous !== undefined) {
+                        try {
+                            await withTimeout(hooks.rebind(extensionId, previous), timeoutMs, `rebind-restore ${extensionId}@${previous}`);
+                            wrapperRestored.add(`${extensionId}@${previous}`);
+                        }
+                        catch (restoreError) {
+                            // The restore failure rides along: the primary rebind error is the
+                            // named reason; the restore failure is recorded in the message.
+                            throw new Error(`${error instanceof Error ? error.message : String(error)} (and restoring ${extensionId}@${previous} also failed: `
+                                + `${restoreError instanceof Error ? restoreError.message : String(restoreError)})`);
+                        }
+                    }
+                    // The previous surface is restored; the commit catch must NOT restore
+                    // it again — the marker distinguishes this path.
+                    throw new RebindRestoredFailure(error instanceof Error ? error.message : String(error), error);
+                }
+            };
+            try {
+                return await commitUpdate({
+                    storeDir: options.storeDir,
+                    profile,
+                    extensionId,
+                    stagedVersion,
+                    hooks: { quiescePrevious, rebindNext },
+                });
+            }
+            catch (error) {
+                /**
+                 * A failure AFTER the quiesce (pointer write failure, an integrity
+                 * refusal after the quiesce, or the auto-rollback after a rebind the
+                 * wrapper could NOT restore) left the old surface withdrawn while the
+                 * pointer names a version nothing republished. Restore the recorded
+                 * pointer's surface here; when the restore itself fails, name BOTH
+                 * failures. A rebind the wrapper ALREADY restored is skipped — it was
+                 * the wrapper's own revert (the REBIND-REVERT contract).
+                 */
+                if (quiesced && !(error instanceof RebindRestoredFailure)) {
+                    const restored = currentPointer(store, profile, extensionId);
+                    if (restored !== undefined && !wrapperRestored.delete(`${extensionId}@${restored}`)) {
+                        try {
+                            await withTimeout(hooks.rebind(extensionId, restored), timeoutMs, `commit-restore ${extensionId}@${restored}`);
+                        }
+                        catch (restoreError) {
+                            throw new Error(`${error instanceof Error ? error.message : String(error)} (and restoring ${extensionId}@${restored} also failed: `
+                                + `${restoreError instanceof Error ? restoreError.message : String(restoreError)})`);
+                        }
+                    }
+                }
+                throw error;
+            }
+        },
+        async rollback(extensionId) {
+            // rebindRestored is bound HOST-side (the SDK awaits it unbounded after the
+            // restore is durable); a timeout surfaces as the SDK's hookFailure.
+            return await rollback({
+                storeDir: options.storeDir,
+                profile,
+                extensionId,
+                rebindRestored: async (restoredVersion) => {
+                    await withTimeout(hooks.rebind(extensionId, restoredVersion), timeoutMs, `rebind-restored ${extensionId}@${restoredVersion}`);
+                },
+            });
+        },
+    };
+}
+//# sourceMappingURL=update-surface.js.map

package/lib/version.d.ts

@@ -0,0 +1,3 @@
+/** The version this build reports. */
+export declare const PACKAGE_VERSION: string;
+//# sourceMappingURL=version.d.ts.map

package/lib/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAaA,sCAAsC;AACtC,eAAO,MAAM,eAAe,EAAE,MAa1B,CAAA"}

package/lib/version.js

@@ -0,0 +1,27 @@
+/**
+ * The package version, read from the shipped `package.json`.
+ *
+ * The host identity and the confinement evidence both need the REAL version. The host
+ * previously carried a hard-coded `'0.1.1'` while the package shipped 0.5.x, so every
+ * receipt and MCP `serverInfo` reported a version nobody could match to a release, and
+ * evidence validation had no trustworthy version to bind to.
+ *
+ * The read is relative to this module, so it works from `src/` (tests, tsx) and from
+ * `lib/` (the published package): both are one directory below `package.json`.
+ */
+import { readFileSync } from 'node:fs';
+/** The version this build reports. */
+export const PACKAGE_VERSION = (() => {
+    try {
+        const manifest = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+        return typeof manifest.version === 'string' && manifest.version.length > 0
+            ? manifest.version
+            : '0.0.0';
+    }
+    catch {
+        // A build whose manifest cannot be read still runs; an unidentifiable version is
+        // reported as such rather than guessed.
+        return '0.0.0';
+    }
+})();
+//# sourceMappingURL=version.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Contract examples and policy metadata (DECL-01).
+ *
+ * One source for every standard descriptor's worked example and explicit policy.
+ * The examples are documentation: the authoritative validation remains each
+ * contract's input/output schema.
+ */
+import type { ContractExample, ContractPolicy } from './registry.ts';
+/** One example per standard contract identity. */
+export declare const CONTRACT_EXAMPLES: Readonly<Record<string, readonly ContractExample[]>>;
+/** Policy metadata; recording is required by default in every standard contract. */
+export declare const CONTRACT_POLICIES: Readonly<Record<string, ContractPolicy>>;
+//# sourceMappingURL=contract-metadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract-metadata.d.ts","sourceRoot":"","sources":["../src/contract-metadata.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAEpE,kDAAkD;AAClD,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC,CAyElF,CAAA;AAED,oFAAoF;AACpF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAEtE,CAAA"}

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

@@ -0,0 +1,85 @@
+/**
+ * Contract examples and policy metadata (DECL-01).
+ *
+ * One source for every standard descriptor's worked example and explicit policy.
+ * The examples are documentation: the authoritative validation remains each
+ * contract's input/output schema.
+ */
+/** One example per standard contract identity. */
+export const CONTRACT_EXAMPLES = {
+    'stt.transcribe': [{
+            input: { audio: { path: 'recording.wav' }, timestamps: 'none' },
+            output: {
+                text: 'Hello from the recording.',
+                coverage: { complete: true, processedSeconds: 1.2, samplingInstruction: null },
+                meta: {},
+            },
+        }],
+    'text.language_detect': [{
+            input: { text: 'Hello, how are you?' },
+            output: { language: 'en', reliability: 'confident', candidates: [{ language: 'en', probability: 0.99 }], meta: {} },
+        }],
+    'text.embed': [{
+            input: { text: 'A short passage.' },
+            output: { embedding: [0.01, 0.02], dimensions: 2, meta: {} },
+        }],
+    'text.rerank': [{
+            input: { query: 'deployment', documents: ['Deploy the service.', 'Unrelated.'] },
+            output: { scores: [1.2, -0.4], meta: {} },
+        }],
+    'text.title': [{
+            input: { text: 'How to configure the deployment pipeline for staging and production.' },
+            output: { title: 'Deployment pipeline configuration', description: 'How to configure staging and production.', meta: {} },
+        }],
+    'image.describe': [{
+            input: { image: { mediaType: 'image/png', bytes: [137, 80, 78, 71] }, prompt: 'Describe the interface.' },
+            output: { description: 'A settings panel with a save button.', meta: {} },
+        }],
+    'embed.multimodal': [{
+            input: { items: [{ id: 'a', parts: [{ kind: 'text', text: 'Hello' }] }], purpose: 'retrieval', role: 'query', dimensions: 2 },
+            output: { embeddings: [{ id: 'a', vector: [0.1, 0.2] }], meta: {} },
+        }],
+    'semantic.similarity': [{
+            input: { left: 'Deploy the service.', right: 'Ship the service.', dimensions: 2 },
+            output: { similarity: 0.92, meta: {} },
+        }],
+    'semantic.rank': [{
+            input: { query: 'deploy', candidates: ['ship it', 'unrelated'], topK: 1 },
+            output: { ranking: [{ id: '0', score: 0.9 }], meta: {} },
+        }],
+    'semantic.classify': [{
+            input: { item: 'The server is down.', labels: [{ id: 'outage', description: 'An outage.' }] },
+            output: { label: 'outage', scores: [{ id: 'outage', score: 0.96 }], meta: {} },
+        }],
+    'semantic.deduplicate': [{
+            input: { items: ['Deploy the service.', 'Ship the service.'], threshold: 0.9 },
+            output: { groups: [{ representative: 0, members: [1] }], meta: {} },
+        }],
+    'media.find_moments': [{
+            input: { query: 'a dog barking', media: { mediaType: 'audio/wav', bytes: [] }, windowSeconds: 2, strideSeconds: 1, topK: 1 },
+            output: { moments: [{ startSeconds: 1, endSeconds: 3, score: 0.9 }], meta: {} },
+        }],
+    'decision.choose': [{
+            input: { decision: 'Choose a deployment strategy.', options: ['blue-green', 'rolling'] },
+            output: { chosen: 1, reason: 'Lower risk.', confidence: 0.7, calibrated: false, probabilities: { '0': 0.3, '1': 0.7 }, abstained: false, meta: {} },
+        }],
+    'decision.test': [{
+            input: { claim: 'The service is healthy.', evidence: 'All probes pass.' },
+            output: { verdict: 'true', confidence: 0.8, calibrated: false, meta: {} },
+        }],
+    'decision.score': [{
+            input: { text: 'The deployment is stable.', levels: ['low', 'medium', 'high'] },
+            output: { level: 'high', confidence: 0.75, calibrated: false, scores: [0.1, 0.15, 0.75], meta: {} },
+        }],
+    'structured.extract': [{
+            input: { text: 'Ada Lovelace was born in 1815.', instruction: 'Extract the person name and year.', schema: { type: 'object', properties: { name: { type: 'string' }, year: { type: 'integer' } } } },
+            output: { record: { name: 'Ada Lovelace', year: 1815 }, meta: {} },
+        }],
+    'plan.tools': [{
+            input: { request: 'Find the language of this text.', tools: [{ name: 'lang_detect', description: 'Detect language.', parameters: { type: 'object' } }] },
+            output: { proposals: [{ name: 'lang_detect', arguments: { text: 'hello' }, reasoning: 'Language detection is requested.', confidence: 0.9 }], meta: {} },
+        }],
+};
+/** Policy metadata; recording is required by default in every standard contract. */
+export const CONTRACT_POLICIES = Object.fromEntries(Object.keys(CONTRACT_EXAMPLES).map(contract => [contract, { recording: 'required', remote: 'allowed' }]));
+//# sourceMappingURL=contract-metadata.js.map

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,YAgFxB,CAAA"}

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

@@ -0,0 +1,87 @@
+/**
+ * `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. The '
+        + 'reliability is vendor-reported, not a calibrated probability, and this reads written text '
+        + 'only: it is not evidence about the language spoken in audio it has not processed.',
+    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/standard.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 type { ToolContract } from '../registry.ts';
+/** The `text.title` contract at version 1.0.0 (RCP-12). */
+export declare const textTitle: ToolContract;
+/** The `image.describe` contract at version 1.0.0 (HLM-12). */
+export declare const imageDescribe: ToolContract;
+/** The `embed.multimodal` contract at version 1.0.0 (EmbeddingGemma family). */
+export declare const multimodalEmbed: ToolContract;
+/** The `semantic.similarity` contract at version 1.0.0. */
+export declare const semanticSimilarity: ToolContract;
+/** The `semantic.rank` contract at version 1.0.0. */
+export declare const semanticRank: ToolContract;
+/** The `semantic.classify` contract at version 1.0.0. */
+export declare const semanticClassify: ToolContract;
+/** The `semantic.deduplicate` contract at version 1.0.0. */
+export declare const semanticDeduplicate: ToolContract;
+/** The `media.find_moments` contract at version 1.0.0. */
+export declare const mediaFindMoments: ToolContract;
+/** The `decision.choose` contract at version 1.0.0 (Laya family). */
+export declare const decisionChoose: ToolContract;
+/** The `decision.test` contract at version 1.0.0. */
+export declare const decisionTest: ToolContract;
+/** The `decision.score` contract at version 1.0.0. */
+export declare const decisionScore: ToolContract;
+/** The `structured.extract` contract at version 1.0.0 (Needle family). */
+export declare const structuredExtract: ToolContract;
+/** The `plan.tools` contract at version 1.0.0 (Needle family). */
+export declare const toolsPlan: ToolContract;
+//# sourceMappingURL=standard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standard.d.ts","sourceRoot":"","sources":["../../src/contracts/standard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,2DAA2D;AAC3D,eAAO,MAAM,SAAS,EAAE,YAuCvB,CAAA;AAED,+DAA+D;AAC/D,eAAO,MAAM,aAAa,EAAE,YAmC3B,CAAA;AAGD,gFAAgF;AAChF,eAAO,MAAM,eAAe,EAAE,YAwC7B,CAAA;AAED,2DAA2D;AAC3D,eAAO,MAAM,kBAAkB,EAAE,YA0BhC,CAAA;AAED,qDAAqD;AACrD,eAAO,MAAM,YAAY,EAAE,YAuC1B,CAAA;AAED,yDAAyD;AACzD,eAAO,MAAM,gBAAgB,EAAE,YA8B9B,CAAA;AAED,4DAA4D;AAC5D,eAAO,MAAM,mBAAmB,EAAE,YAmCjC,CAAA;AAED,0DAA0D;AAC1D,eAAO,MAAM,gBAAgB,EAAE,YAwC9B,CAAA;AAED,qEAAqE;AACrE,eAAO,MAAM,cAAc,EAAE,YA8B5B,CAAA;AAED,qDAAqD;AACrD,eAAO,MAAM,YAAY,EAAE,YA8B1B,CAAA;AAED,sDAAsD;AACtD,eAAO,MAAM,aAAa,EAAE,YAoC3B,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB,EAAE,YA4B/B,CAAA;AAED,kEAAkE;AAClE,eAAO,MAAM,SAAS,EAAE,YAwCvB,CAAA"}