@itsoltech/basal-client 0.1.0 → 0.3.0

package/dist/esm/questions.js

@@ -30,19 +30,20 @@ function evidence(options) {
 export class QuestionSpec {
     wire;
     constructor(kind, instructions, fields) {
-        this.wire = structuredClone({ ...fields, type: kind, instructions: text(instructions, 'instructions') });
+        this.wire = structuredClone({ ...fields, type: kind, ...(['classify', 'verify', 'compress', 'extract'].includes(kind) ? (instructions ? { instructions } : {}) : { instructions: text(instructions, 'instructions') }) });
     }
     toJSON() { return structuredClone(this.wire); }
     /** Validate and retrieve an answer with this question's result type. */
     read(response, id) {
         const answer = response.answers?.[id];
-        if (!answer || answer.type !== this.wire.type || !answer.probabilities || typeof answer.probabilities !== 'object' || Array.isArray(answer.probabilities)) {
+        if (!answer || !('probabilities' in answer) || answer.type !== this.wire.type || !answer.probabilities || typeof answer.probabilities !== 'object' || Array.isArray(answer.probabilities)) {
             throw new TypeError('Basal returned a missing or mismatched answer');
         }
         const fields = {
             choice: { choice: 'string', confidence: 'number' }, noul: { noul: 'number', confidence: 'number' },
             score: { score: 'number', legend: 'object', confidence: 'number' },
-            multi: { selected: 'object', threshold: 'number', set_confidence: 'number' },
+            multi: { selected: 'object', set_confidence: 'number' },
+            tool: answer.type === 'tool' && answer.multi ? { tools: 'object', call: 'boolean', set_confidence: 'number' } : { call: 'boolean', confidence: 'number' },
             act: { action: 'string', answer: 'string', expected_costs: 'object', confidence: 'number', calibration: 'string' },
         };
         const data = answer;
@@ -75,21 +76,52 @@ export class QuestionSpec {
         if (answer.type === 'score' && (Array.isArray(answer.legend) || Object.values(answer.legend).some(v => typeof v !== 'string')))
             throw new TypeError('invalid legend');
         if (answer.type === 'act') {
-            if (!['validated', 'unvalidated'].includes(answer.calibration) || !Object.hasOwn(this.wire.costs ?? {}, answer.action) || !expectedKeys.includes(answer.answer))
+            if (!['validated', 'unvalidated', 'text'].includes(answer.calibration) || !Object.hasOwn(this.wire.costs ?? {}, answer.action) || !expectedKeys.includes(answer.answer))
                 throw new TypeError('invalid action');
             if (Array.isArray(answer.expected_costs) || Object.keys(this.wire.costs ?? {}).some(key => !Object.hasOwn(answer.expected_costs, key)))
                 throw new TypeError('invalid expected costs');
             for (const value of Object.values(answer.expected_costs))
                 number(value, 'expected cost');
         }
-        return { ...answer, ...(answer.type === 'multi' ? {} : { evidence: answer.evidence ?? [] }) };
+        if (answer.type === 'multi' || (answer.type === 'tool' && answer.multi)) {
+            validateSelection(answer, this.wire.objective ?? 'threshold');
+        }
+        if (answer.type === 'tool') {
+            if ((answer.multi ?? false) !== (this.wire.multi ?? false))
+                throw new TypeError('mismatched tool mode');
+            if (answer.multi) {
+                if (!Array.isArray(answer.tools) || answer.tools.some(k => typeof k !== 'string' || !Object.hasOwn(answer.probabilities, k)))
+                    throw new TypeError('invalid selected tools');
+            }
+            else {
+                if (answer.tool === null ? answer.deferred !== true : typeof answer.tool !== 'string' || !Object.hasOwn(answer.probabilities, answer.tool))
+                    throw new TypeError('invalid selected tool');
+                if (answer.deferred !== undefined && typeof answer.deferred !== 'boolean')
+                    throw new TypeError('invalid deferred');
+                for (const key of ['refused', 'max_error'])
+                    if (answer[key] !== undefined && typeof answer[key] !== 'string')
+                        throw new TypeError('invalid tool metadata');
+            }
+            if (answer.ranking !== undefined) {
+                if (!Array.isArray(answer.ranking))
+                    throw new TypeError('invalid ranking');
+                for (const entry of answer.ranking) {
+                    if (!entry || typeof entry.tool !== 'string' || !Object.hasOwn(answer.probabilities, entry.tool))
+                        throw new TypeError('invalid ranking entry');
+                    number(entry.probability, 'ranking probability', true);
+                }
+            }
+        }
+        if (answer.type === 'act' && answer.deferred !== undefined && typeof answer.deferred !== 'boolean')
+            throw new TypeError('invalid deferred');
+        return { ...answer, ...(answer.type === 'multi' || answer.type === 'tool' ? {} : { evidence: answer.evidence ?? [] }) };
     }
 }
 export class ChoiceQuestion extends QuestionSpec {
     constructor(instructions, values, options = {}) {
         if (options.option_keys !== undefined && !['show', 'hide'].includes(options.option_keys))
             throw new TypeError('invalid option_keys');
-        super('choice', instructions, { criteria: criteria(values, 2, 10), ...evidence(options), ...(options.option_keys === 'hide' ? { option_keys: 'hide' } : {}) });
+        super('choice', instructions, { criteria: criteria(values, 2, 255), ...evidence(options), ...(options.option_keys === 'hide' ? { option_keys: 'hide' } : {}) });
     }
 }
 export class NoulQuestion extends QuestionSpec {
@@ -97,34 +129,103 @@ export class NoulQuestion extends QuestionSpec {
 }
 export class ScoreQuestion extends QuestionSpec {
     constructor(instructions, levels, options = {}) {
-        if (!Array.isArray(levels) || levels.length < 2 || levels.length > 10)
-            throw new TypeError('score requires 2–10 ordered levels');
+        if (!Array.isArray(levels) || levels.length < 2 || levels.length > 255)
+            throw new TypeError('score requires 2–255 ordered levels');
         super('score', instructions, { criteria: levels.map(v => text(v, 'level')), ...evidence(options) });
     }
 }
+function selectionOptions(options, keys) {
+    const fields = {};
+    const objective = options.objective ?? 'threshold';
+    if (!['threshold', 'exact', 'iou', 'f1'].includes(objective))
+        throw new TypeError('invalid objective');
+    if (objective !== 'threshold')
+        fields.objective = objective;
+    if (options.threshold !== undefined) {
+        if (objective !== 'threshold')
+            throw new TypeError('threshold applies only to objective threshold');
+        fields.threshold = number(options.threshold, 'threshold', true);
+    }
+    for (const key of ['min', 'max']) {
+        const v = options[key];
+        if (v !== undefined) {
+            if (!Number.isSafeInteger(v) || v < 0 || (keys && v > keys.length))
+                throw new TypeError(`invalid ${key}`);
+            fields[key] = v;
+        }
+    }
+    if (options.min !== undefined && options.max !== undefined && options.min > options.max)
+        throw new TypeError('min exceeds max');
+    if (options.exclusive !== undefined) {
+        if (!Array.isArray(options.exclusive))
+            throw new TypeError('exclusive must be an array');
+        fields.exclusive = options.exclusive.map(k => { text(k, 'exclusive key'); if (keys && !keys.includes(k))
+            throw new TypeError('unknown exclusive key'); return k; });
+    }
+    if (options.fallback !== undefined) {
+        fields.fallback = text(options.fallback, 'fallback');
+        if (keys && !keys.includes(options.fallback))
+            throw new TypeError('unknown fallback');
+    }
+    if (options.fallback_threshold !== undefined) {
+        if (options.fallback === undefined)
+            throw new TypeError('fallback_threshold requires fallback');
+        fields.fallback_threshold = number(options.fallback_threshold, 'fallback_threshold', true);
+    }
+    return fields;
+}
+function validateSelection(answer, objective) {
+    number(answer.set_confidence, 'set_confidence', true);
+    if (objective === 'threshold')
+        number(answer.threshold, 'threshold', true);
+    else {
+        if (answer.objective !== objective)
+            throw new TypeError('mismatched objective');
+        if (answer.expected_score !== null && answer.expected_score !== undefined)
+            number(answer.expected_score, 'expected_score', true);
+    }
+}
 export class MultiQuestion extends QuestionSpec {
     constructor(instructions, values, options = {}) {
         if ('evidence' in options)
             throw new TypeError('multi does not support evidence');
-        const fields = { criteria: criteria(values, 1) };
-        if (options.threshold !== undefined)
-            fields.threshold = number(options.threshold, 'threshold', true);
-        for (const key of ['min', 'max']) {
-            const value = options[key];
-            if (value !== undefined) {
-                if (!Number.isInteger(value) || value < 0 || value > Object.keys(values).length)
-                    throw new TypeError(`invalid ${key}`);
-                fields[key] = value;
-            }
+        super('multi', instructions, { criteria: criteria(values, 1), ...selectionOptions(options, Object.keys(values)) });
+    }
+}
+export class ToolQuestion extends QuestionSpec {
+    constructor(instructions, tools, options = {}) {
+        if (!Array.isArray(tools) || tools.some(t => !t || typeof t !== 'object' || Array.isArray(t)))
+            throw new TypeError('tools must contain definition objects');
+        if (options.extra !== undefined && (!Array.isArray(options.extra) || options.extra.some(k => !['answer_directly', 'ask_user', 'none'].includes(k))))
+            throw new TypeError('invalid extra tool option');
+        if (options.multi !== undefined && typeof options.multi !== 'boolean')
+            throw new TypeError('invalid multi');
+        const fields = { tools, ...(options.extra === undefined ? {} : { extra: options.extra }) };
+        if (options.description_chars !== undefined) {
+            if (!Number.isSafeInteger(options.description_chars) || options.description_chars < 0)
+                throw new TypeError('description_chars must be a non-negative safe integer');
+            fields.description_chars = options.description_chars;
+        }
+        if (options.rank !== undefined) {
+            if (!Number.isSafeInteger(options.rank) || options.rank < 1)
+                throw new TypeError('rank must be a positive integer');
+            fields.rank = options.rank;
+        }
+        if (options.max_error !== undefined)
+            fields.max_error = number(options.max_error, 'max_error', true);
+        const selection = selectionOptions(options);
+        if (!options.multi && Object.keys(selection).length)
+            throw new TypeError('selection options require multi');
+        if (options.multi) {
+            fields.multi = true;
+            Object.assign(fields, selection);
         }
-        if (options.min !== undefined && options.max !== undefined && options.min > options.max)
-            throw new TypeError('min exceeds max');
-        super('multi', instructions, fields);
+        super('tool', instructions, fields);
     }
 }
 export class ActQuestion extends QuestionSpec {
     constructor(instructions, costs, options = {}) {
-        const optionsMap = options.criteria === undefined ? undefined : criteria(options.criteria, 2, 10);
+        const optionsMap = options.criteria === undefined ? undefined : criteria(options.criteria, 2, 255);
         const outcomes = Object.keys(optionsMap ?? { 'true': 'Yes', 'false': 'No' });
         if (!costs || typeof costs !== 'object' || Array.isArray(costs) || !Object.keys(costs).length)
             throw new TypeError('act requires a cost matrix');
@@ -147,6 +248,7 @@ export function noul(instructions, options) { return new NoulQuestion(instructio
 export function score(instructions, levels, options) { return new ScoreQuestion(instructions, levels, options); }
 export function multi(instructions, values, options) { return new MultiQuestion(instructions, values, options); }
 export function act(instructions, costs, options) { return new ActQuestion(instructions, costs, options); }
+export function tool(instructions, tools, options) { return new ToolQuestion(instructions, tools, options); }
 export function buildRequest(state, questions, options) {
     if (state === null || state === undefined)
         throw new TypeError('state must not be null/undefined');
@@ -160,5 +262,11 @@ export function buildRequest(state, questions, options) {
         text(options.model, 'model');
     if (options.facts !== undefined && !['off', 'auto'].includes(options.facts))
         throw new TypeError('invalid facts');
-    return { state, questions: Object.fromEntries(entries), ...(options.model === undefined ? {} : { model: options.model }), ...(options.facts === undefined ? {} : { facts: options.facts }) };
+    if (options.lang !== undefined && !['pl', 'en'].includes(options.lang))
+        throw new TypeError('invalid lang');
+    if (options.detail !== undefined && !['default', 'high'].includes(options.detail))
+        throw new TypeError('invalid detail');
+    if (options.media !== undefined && (!Array.isArray(options.media) || options.media.length < 1 || options.media.length > 8 || options.media.some(m => !m || !['image', 'audio'].includes(m.type) || typeof m.data !== 'string' || !m.data.trim())))
+        throw new TypeError('invalid media');
+    return { state, questions: Object.fromEntries(entries), ...(options.lang === undefined ? {} : { lang: options.lang }), ...(options.detail === undefined ? {} : { detail: options.detail }), ...(options.media === undefined ? {} : { media: structuredClone(options.media) }), ...(options.model === undefined ? {} : { model: options.model }), ...(options.facts === undefined ? {} : { facts: options.facts }) };
 }

package/dist/esm/tasks.d.ts

@@ -0,0 +1,108 @@
+import { QuestionSpec } from './questions.js';
+import type { DecisionResponse, JsonValue, Question, MultiObjective } from './index.js';
+/** Task automation is unknown (null) without a threshold certified for that task/error target. */
+export type Automation = Record<string, boolean | null>;
+export interface ClassifyAnswer<K extends string = string> {
+    type: 'classify';
+    experimental: true;
+    scores: Record<K, number>;
+    label?: K;
+    top_label?: K;
+    confidence?: number;
+    automated?: Automation;
+    labels?: K[];
+    set_confidence?: number;
+}
+export interface ClaimResult {
+    verdict: 'supported' | 'contradicted' | 'not_stated' | 'not_supported';
+    probabilities: Record<string, number>;
+    confidence: number;
+    automated: Automation;
+}
+export interface VerifyAnswer {
+    type: 'verify';
+    experimental: true;
+    claims: Record<string, ClaimResult>;
+    all_supported: boolean;
+    not_supported: string[];
+}
+/** Inclusive start/exclusive end count Unicode code points, not JavaScript UTF-16 units. */
+export interface CompressionUnit {
+    start: number;
+    end: number;
+    probability: number;
+}
+export interface CompressAnswer {
+    type: 'compress';
+    experimental: true;
+    compressed: string;
+    kept: number[];
+    units: CompressionUnit[];
+    unit: 'sentence' | 'line' | 'paragraph';
+    original_chars: number;
+    compressed_chars: number;
+    ratio: number;
+}
+export interface ExtractField {
+    value: JsonValue;
+    confidence: number;
+    source: 'choice' | 'span';
+    calibration: 'validated' | 'per decision';
+    probabilities?: Record<string, number>;
+    present_probability?: number;
+    text?: string;
+    start?: number;
+    end?: number;
+    line_probability?: number;
+    span_probability?: number;
+    error?: string;
+}
+export interface ExtractAnswer {
+    type: 'extract';
+    experimental: true;
+    data: Record<string, JsonValue>;
+    fields: Record<string, ExtractField>;
+}
+export type TaskAnswer = ClassifyAnswer | VerifyAnswer | CompressAnswer | ExtractAnswer;
+export interface ClassifyOptions {
+    multi_label?: boolean;
+    none?: boolean;
+    max_error?: number | readonly number[];
+    option_keys?: 'show' | 'hide';
+    threshold?: number;
+    min?: number;
+    max?: number;
+    objective?: MultiObjective;
+}
+export interface VerifyOptions {
+    binary?: boolean;
+    max_error?: number | readonly number[];
+}
+export interface CompressOptions {
+    unit?: 'sentence' | 'line' | 'paragraph';
+    keep_ratio?: number;
+    threshold?: number;
+    min_keep?: number;
+}
+declare abstract class TaskQuestion<A extends TaskAnswer> extends QuestionSpec<A> {
+    protected constructor(kind: A['type'], text: string, fields: Question);
+    read(response: DecisionResponse, id: string): A;
+}
+export declare class ClassifyQuestion<K extends string = string> extends TaskQuestion<ClassifyAnswer<K>> {
+    constructor(text: string, labels: Record<K, JsonValue> | readonly JsonValue[], options?: ClassifyOptions);
+}
+export declare class VerifyQuestion extends TaskQuestion<VerifyAnswer> {
+    constructor(text: string, claims: Record<string, JsonValue> | readonly JsonValue[], options?: VerifyOptions);
+}
+export declare class CompressQuestion extends TaskQuestion<CompressAnswer> {
+    constructor(text?: string, options?: CompressOptions);
+}
+export declare class ExtractQuestion extends TaskQuestion<ExtractAnswer> {
+    constructor(text: string, schema: Record<string, JsonValue>);
+}
+export declare function classify<const K extends string>(text: string, labels: Record<K, JsonValue>, options?: ClassifyOptions): ClassifyQuestion<K>;
+export declare function classify(text: string, labels: readonly JsonValue[], options?: ClassifyOptions): ClassifyQuestion;
+export declare function verify(text: string, claims: Record<string, JsonValue> | readonly JsonValue[], options?: VerifyOptions): VerifyQuestion;
+export declare function compress(text?: string, options?: CompressOptions): CompressQuestion;
+export declare function extract(text: string, schema: Record<string, JsonValue>): ExtractQuestion;
+export {};

package/dist/esm/tasks.js

@@ -0,0 +1,164 @@
+import { QuestionSpec } from './questions.js';
+function object(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        throw new TypeError('expected task object');
+    return v;
+}
+function probability(v) { if (typeof v !== 'number' || !Number.isFinite(v) || v < 0 || v > 1)
+    throw new TypeError('invalid probability'); }
+function probabilities(v) { for (const n of Object.values(object(v)))
+    probability(n); }
+function automation(v) { if (Object.values(object(v)).some(n => n !== null && typeof n !== 'boolean'))
+    throw new TypeError('invalid automation'); }
+function strings(v) { if (!Array.isArray(v) || v.some(k => typeof k !== 'string'))
+    throw new TypeError('expected string list'); }
+function offset(v) { if (!Number.isSafeInteger(v) || v < 0)
+    throw new TypeError('invalid Unicode code point offset/count'); }
+function span(v) { offset(v.start); offset(v.end); if (v.end < v.start)
+    throw new TypeError('reversed source span'); }
+function risks(v) {
+    if (v === undefined)
+        return;
+    const a = Array.isArray(v) ? v : [v];
+    if (a.length > 64 || a.some(n => typeof n !== 'number' || !Number.isFinite(n) || n <= 0 || n >= 1))
+        throw new TypeError('invalid max_error');
+}
+function instructions(v) { if (typeof v !== 'string')
+    throw new TypeError('instructions must be a string'); return v; }
+class TaskQuestion extends QuestionSpec {
+    constructor(kind, text, fields) { super(kind, instructions(text), fields); }
+    read(response, id) {
+        const d = object(response.answers?.[id]);
+        if (d.type !== this.toJSON().type || d.experimental !== true)
+            throw new TypeError('Basal returned a missing or mismatched task');
+        if (d.type === 'classify') {
+            probabilities(d.scores);
+            const scores = object(d.scores);
+            if (this.toJSON().multi_label) {
+                strings(d.labels);
+                if (d.labels.some(k => !Object.hasOwn(scores, k)))
+                    throw new TypeError('unknown label');
+                probability(d.set_confidence);
+            }
+            else {
+                if (typeof d.label !== 'string' || !Object.hasOwn(scores, d.label) || d.top_label !== d.label)
+                    throw new TypeError('invalid label');
+                probability(d.confidence);
+                automation(d.automated);
+            }
+        }
+        else if (d.type === 'verify') {
+            const claims = object(d.claims);
+            for (const raw of Object.values(claims)) {
+                const c = object(raw);
+                const p = object(c.probabilities);
+                probabilities(p);
+                if (typeof c.verdict !== 'string' || !['supported', 'contradicted', 'not_stated', 'not_supported'].includes(c.verdict) || !Object.hasOwn(p, c.verdict))
+                    throw new TypeError('invalid verdict');
+                probability(c.confidence);
+                automation(c.automated);
+            }
+            strings(d.not_supported);
+            if (typeof d.all_supported !== 'boolean' || d.not_supported.some(k => !Object.hasOwn(claims, k)))
+                throw new TypeError('invalid verification summary');
+        }
+        else if (d.type === 'compress') {
+            if (typeof d.compressed !== 'string' || !['sentence', 'line', 'paragraph'].includes(d.unit) || !Array.isArray(d.units) || !Array.isArray(d.kept))
+                throw new TypeError('invalid compression');
+            for (const u of d.units) {
+                const v = object(u);
+                span(v);
+                probability(v.probability);
+            }
+            for (const k of d.kept) {
+                offset(k);
+                if (k >= d.units.length)
+                    throw new TypeError('invalid kept unit');
+            }
+            offset(d.original_chars);
+            offset(d.compressed_chars);
+            if (typeof d.ratio !== 'number' || !Number.isFinite(d.ratio) || d.ratio < 0)
+                throw new TypeError('invalid ratio');
+        }
+        else {
+            object(d.data);
+            for (const raw of Object.values(object(d.fields))) {
+                const f = object(raw);
+                if (!Object.hasOwn(f, 'value') || !['choice', 'span'].includes(f.source) || !['validated', 'per decision'].includes(f.calibration))
+                    throw new TypeError('invalid extraction field');
+                probability(f.confidence);
+                if (f.probabilities !== undefined)
+                    probabilities(f.probabilities);
+                for (const k of ['present_probability', 'line_probability', 'span_probability'])
+                    if (f[k] !== undefined)
+                        probability(f[k]);
+                if (f.text !== undefined) {
+                    if (typeof f.text !== 'string')
+                        throw new TypeError('invalid source text');
+                    span(f);
+                }
+            }
+        }
+        return structuredClone(d);
+    }
+}
+export class ClassifyQuestion extends TaskQuestion {
+    constructor(text, labels, options = {}) {
+        if (!labels || typeof labels !== 'object' || Object.keys(labels).length < 1 || Object.keys(labels).length > 256)
+            throw new TypeError('classify requires 1..256 labels');
+        risks(options.max_error);
+        for (const k of ['multi_label', 'none'])
+            if (options[k] !== undefined && typeof options[k] !== 'boolean')
+                throw new TypeError(`invalid ${k}`);
+        if (options.option_keys !== undefined && !['show', 'hide'].includes(options.option_keys))
+            throw new TypeError('invalid option_keys');
+        if (options.threshold !== undefined) {
+            probability(options.threshold);
+            if (options.objective !== undefined && options.objective !== 'threshold')
+                throw new TypeError('threshold requires threshold objective');
+        }
+        for (const k of ['min', 'max'])
+            if (options[k] !== undefined)
+                offset(options[k]);
+        if (options.min !== undefined && options.max !== undefined && options.min > options.max)
+            throw new TypeError('min exceeds max');
+        if (options.objective !== undefined && !['threshold', 'exact', 'iou', 'f1'].includes(options.objective))
+            throw new TypeError('invalid objective');
+        if (!options.multi_label && ['threshold', 'min', 'max', 'objective'].some(k => Object.hasOwn(options, k)))
+            throw new TypeError('selection options require multi_label');
+        super('classify', text, { labels: structuredClone(labels), ...options });
+    }
+}
+export class VerifyQuestion extends TaskQuestion {
+    constructor(text, claims, options = {}) {
+        if (!claims || typeof claims !== 'object' || !Object.keys(claims).length)
+            throw new TypeError('verify requires claims');
+        risks(options.max_error);
+        if (options.binary !== undefined && typeof options.binary !== 'boolean')
+            throw new TypeError('invalid binary');
+        super('verify', text, { claims: structuredClone(claims), ...options });
+    }
+}
+export class CompressQuestion extends TaskQuestion {
+    constructor(text = '', options = {}) {
+        if (options.unit !== undefined && !['sentence', 'line', 'paragraph'].includes(options.unit))
+            throw new TypeError('invalid unit');
+        if (options.keep_ratio !== undefined) {
+            probability(options.keep_ratio);
+            if (options.keep_ratio === 0)
+                throw new TypeError('keep_ratio must be positive');
+        }
+        if (options.threshold !== undefined)
+            probability(options.threshold);
+        if (options.min_keep !== undefined)
+            offset(options.min_keep);
+        super('compress', text, options);
+    }
+}
+export class ExtractQuestion extends TaskQuestion {
+    constructor(text, schema) { object(schema); super('extract', text, { schema }); }
+}
+export function classify(text, labels, options) { return new ClassifyQuestion(text, labels, options); }
+export function verify(text, claims, options) { return new VerifyQuestion(text, claims, options); }
+export function compress(text = '', options) { return new CompressQuestion(text, options); }
+export function extract(text, schema) { return new ExtractQuestion(text, schema); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itsoltech/basal-client",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "TypeScript and JavaScript client for the native Basal HTTP API",
   "type": "module",
   "main": "./dist/cjs/index.cjs",