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

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

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

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/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"}

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