@itsoltech/basal-client 0.1.0 → 0.3.0

package/dist/cjs/tasks.cjs

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractQuestion = exports.CompressQuestion = exports.VerifyQuestion = exports.ClassifyQuestion = void 0;
+exports.classify = classify;
+exports.verify = verify;
+exports.compress = compress;
+exports.extract = extract;
+const questions_cjs_1 = require("./questions.cjs");
+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 questions_cjs_1.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);
+    }
+}
+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 });
+    }
+}
+exports.ClassifyQuestion = ClassifyQuestion;
+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 });
+    }
+}
+exports.VerifyQuestion = VerifyQuestion;
+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);
+    }
+}
+exports.CompressQuestion = CompressQuestion;
+class ExtractQuestion extends TaskQuestion {
+    constructor(text, schema) { object(schema); super('extract', text, { schema }); }
+}
+exports.ExtractQuestion = ExtractQuestion;
+function classify(text, labels, options) { return new ClassifyQuestion(text, labels, options); }
+function verify(text, claims, options) { return new VerifyQuestion(text, claims, options); }
+function compress(text = '', options) { return new CompressQuestion(text, options); }
+function extract(text, schema) { return new ExtractQuestion(text, schema); }

package/dist/cjs/tasks.d.cts

@@ -0,0 +1,108 @@
+import { QuestionSpec } from './questions.cjs';
+import type { DecisionResponse, JsonValue, Question, MultiObjective } from './index.cjs';
+/** 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/index.d.ts

@@ -1,11 +1,31 @@
 import { type QuestionSet, type TypedDecisionResponse, type DecisionOptions } from "./questions.js";
 export * from "./questions.js";
+export * from "./media.js";
+export * from "./tasks.js";
+import type { TaskAnswer } from "./tasks.js";
 /** Native Basal wire types. Criterion order is significant; do not sort keys. */
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
 };
+export type Calibration = "validated" | "unvalidated" | "text";
+export type MultiObjective = "threshold" | "exact" | "iou" | "f1";
+export interface MediaInput {
+    type: "image" | "audio";
+    data: string;
+}
+export interface MediaUsage {
+    images: number;
+    audio: number;
+    media_tokens: number;
+    detail: "default" | "high";
+}
+export interface ToolRanking {
+    tool: string;
+    probability: number;
+}
+export type ToolDefinition = Record<string, JsonValue>;
 export interface Question {
-    type?: "choice" | "noul" | "score" | "multi" | "act";
+    type?: "choice" | "noul" | "score" | "multi" | "act" | "tool" | "classify" | "verify" | "compress" | "extract";
     instructions?: JsonValue;
     criteria?: Record<string, JsonValue> | JsonValue[];
     levels?: Record<string, JsonValue> | JsonValue[];
@@ -17,13 +37,34 @@ export interface Question {
     base?: "noul" | "choice" | "score";
     costs?: Record<string, number> | Record<string, Record<string, number>>;
     defer_action?: string;
-    max_error?: number;
+    max_error?: number | readonly number[];
+    objective?: MultiObjective;
+    exclusive?: readonly string[];
+    fallback?: string;
+    fallback_threshold?: number;
+    tools?: readonly ToolDefinition[];
+    extra?: readonly ("answer_directly" | "ask_user" | "none")[];
+    rank?: number;
+    description_chars?: number;
+    multi?: boolean;
+    labels?: Record<string, JsonValue> | JsonValue[];
+    multi_label?: boolean;
+    none?: boolean;
+    claims?: Record<string, JsonValue> | JsonValue[];
+    binary?: boolean;
+    unit?: 'sentence' | 'line' | 'paragraph';
+    keep_ratio?: number;
+    min_keep?: number;
+    schema?: Record<string, JsonValue>;
 }
 export interface DecisionRequest {
     state: JsonValue;
     questions: Record<string, Question>;
     model?: string;
     facts?: "off" | "auto";
+    lang?: "pl" | "en";
+    media?: readonly MediaInput[];
+    detail?: "default" | "high";
 }
 export interface EvidenceSpan {
     text: string;
@@ -34,6 +75,7 @@ export interface EvidenceSpan {
 interface BaseAnswer<K extends string = string> {
     probabilities: Record<K, number>;
     evidence?: EvidenceSpan[];
+    calibration?: Calibration;
 }
 export interface ChoiceAnswer<K extends string = string> extends BaseAnswer<K> {
     type: "choice";
@@ -51,29 +93,57 @@ export interface ScoreAnswer extends BaseAnswer {
     legend: Record<string, string>;
     confidence: number;
 }
-export interface MultiAnswer<K extends string = string> extends BaseAnswer<K> {
+export interface SelectionResult<K extends string = string> {
+    threshold?: number;
+    objective?: MultiObjective;
+    expected_score?: number | null;
+    constraints_applied?: JsonValue;
+    set_confidence: number;
+}
+export interface MultiAnswer<K extends string = string> extends BaseAnswer<K>, SelectionResult<K> {
     type: "multi";
     selected: K[];
-    threshold: number;
-    set_confidence: number;
 }
+export interface SingleToolAnswer extends BaseAnswer {
+    type: "tool";
+    multi?: false;
+    tool: string | null;
+    call: boolean;
+    confidence: number;
+    ranking?: ToolRanking[];
+    deferred?: boolean;
+    refused?: string;
+    max_error?: string;
+}
+export interface MultiToolAnswer extends BaseAnswer, SelectionResult {
+    type: "tool";
+    multi: true;
+    tools: string[];
+    call: boolean;
+    ranking?: ToolRanking[];
+}
+export type ToolAnswer = SingleToolAnswer | MultiToolAnswer;
 export interface ActAnswer<K extends string = string, A extends string = string> extends BaseAnswer<K> {
     type: "act";
     action: A;
     answer: K;
     expected_costs: Record<A, number>;
     confidence: number;
-    calibration: "validated" | "unvalidated";
+    calibration: Calibration;
     refused?: string;
     max_error?: string;
+    deferred?: boolean;
 }
-export type Answer = ChoiceAnswer | NoulAnswer | ScoreAnswer | MultiAnswer | ActAnswer;
+export type Answer = ChoiceAnswer | NoulAnswer | ScoreAnswer | MultiAnswer | ActAnswer | ToolAnswer | TaskAnswer;
 export interface Usage {
     input_tokens: number;
     output_tokens: number;
     questions?: number;
     branches?: number;
     latency_ms?: number;
+    longest_prompt_tokens?: number;
+    second_order_branches?: number;
+    media?: MediaUsage;
 }
 export interface DecisionResponse {
     model: string;
@@ -86,6 +156,10 @@ export interface ModelMetadata {
     release_date?: string;
     mode?: string;
     early_exit?: JsonValue[];
+    prompt_format?: number;
+    orders?: JsonValue;
+    temperature_per_prim?: Record<string, number>;
+    media?: ("image" | "audio")[];
 }
 export interface ModelsResponse {
     models: ModelMetadata[];

package/dist/esm/index.js

@@ -1,5 +1,7 @@
 import { buildRequest } from "./questions.js";
 export * from "./questions.js";
+export * from "./media.js";
+export * from "./tasks.js";
 export class BasalError extends Error {
 }
 /** Non-2xx response. Server body and Retry-After are available without logging them. */

package/dist/esm/media.d.ts

@@ -0,0 +1,5 @@
+import type { MediaInput } from './index.js';
+/** Inline image; never fetches a URL or reads a file. */
+export declare function image(data: Uint8Array | string): MediaInput;
+/** Inline audio; never fetches a URL or reads a file. */
+export declare function audio(data: Uint8Array | string): MediaInput;

package/dist/esm/media.js

@@ -0,0 +1,16 @@
+function media(type, data) {
+    if (data instanceof Uint8Array) {
+        // Bounded chunks avoid the argument limit of spreading a whole image/audio file.
+        const chunks = [];
+        for (let offset = 0; offset < data.length; offset += 8192)
+            chunks.push(String.fromCharCode(...data.subarray(offset, offset + 8192)));
+        data = btoa(chunks.join(''));
+    }
+    if (typeof data !== 'string' || !data.trim() || /^https?:\/\//i.test(data))
+        throw new TypeError('media data must be bytes, base64 or a data URL');
+    return { type, data };
+}
+/** Inline image; never fetches a URL or reads a file. */
+export function image(data) { return media('image', data); }
+/** Inline audio; never fetches a URL or reads a file. */
+export function audio(data) { return media('audio', data); }

package/dist/esm/questions.d.ts

@@ -1,4 +1,4 @@
-import type { ActAnswer, Answer, ChoiceAnswer, DecisionResponse, EvidenceSpan, JsonValue, MultiAnswer, NoulAnswer, Question, ScoreAnswer } from './index.js';
+import type { ActAnswer, Answer, ChoiceAnswer, DecisionResponse, EvidenceSpan, JsonValue, MultiAnswer, NoulAnswer, Question, ScoreAnswer, ToolAnswer, ToolDefinition, MultiObjective, DecisionRequest } from './index.js';
 /** Required result metadata on the typed path; missing spans become an empty array. */
 export type TypedChoiceAnswer<K extends string = string> = ChoiceAnswer<K> & {
     evidence: EvidenceSpan[];
@@ -19,19 +19,29 @@ export interface EvidenceOptions {
 export interface ChoiceOptions extends EvidenceOptions {
     option_keys?: 'show' | 'hide';
 }
-export interface MultiOptions {
+export interface MultiOptions<K extends string = string> {
     threshold?: number;
     min?: number;
     max?: number;
+    objective?: MultiObjective;
+    exclusive?: readonly K[];
+    fallback?: K;
+    fallback_threshold?: number;
+}
+export interface ToolOptions extends MultiOptions {
+    extra?: readonly ("answer_directly" | "ask_user" | "none")[];
+    rank?: number;
+    multi?: boolean;
+    max_error?: number;
+    /** Tool-description truncation cap; omitted keeps the server default (300), zero disables truncation. */
+    description_chars?: number;
 }
 export interface ActOptions<K extends string = string, A extends string = string> extends EvidenceOptions {
     criteria?: Record<K, string>;
     defer_action?: A;
     max_error?: number;
 }
-export interface DecisionOptions {
-    model?: string;
-    facts?: 'off' | 'auto';
+export interface DecisionOptions extends Pick<DecisionRequest, 'model' | 'facts' | 'lang' | 'media' | 'detail'> {
     signal?: AbortSignal;
 }
 /** Immutable snapshot of a typed question. Use factories or the concrete constructors. */
@@ -52,7 +62,10 @@ export declare class ScoreQuestion extends QuestionSpec<TypedScoreAnswer> {
     constructor(instructions: string, levels: readonly string[], options?: EvidenceOptions);
 }
 export declare class MultiQuestion<K extends string = string> extends QuestionSpec<TypedMultiAnswer<K>> {
-    constructor(instructions: string, values: Record<K, string>, options?: MultiOptions);
+    constructor(instructions: string, values: Record<K, string>, options?: MultiOptions<K>);
+}
+export declare class ToolQuestion extends QuestionSpec<ToolAnswer> {
+    constructor(instructions: string, tools: readonly ToolDefinition[], options?: ToolOptions);
 }
 export declare class ActQuestion<K extends string = 'true' | 'false', A extends string = string> extends QuestionSpec<TypedActAnswer<K, A>> {
     constructor(instructions: string, costs: Record<A, Record<NoInfer<K>, number>>, options?: ActOptions<K, NoInfer<A>>);
@@ -60,8 +73,9 @@ export declare class ActQuestion<K extends string = 'true' | 'false', A extends
 export declare function choice<const K extends string>(instructions: string, values: Record<K, string>, options?: ChoiceOptions): ChoiceQuestion<K>;
 export declare function noul(instructions: string, options?: EvidenceOptions): NoulQuestion;
 export declare function score(instructions: string, levels: readonly string[], options?: EvidenceOptions): ScoreQuestion;
-export declare function multi<const K extends string>(instructions: string, values: Record<K, string>, options?: MultiOptions): MultiQuestion<K>;
+export declare function multi<const K extends string>(instructions: string, values: Record<K, string>, options?: MultiOptions<K>): MultiQuestion<K>;
 export declare function act<const K extends string = 'true' | 'false', const A extends string = string>(instructions: string, costs: Record<A, Record<NoInfer<K>, number>>, options?: ActOptions<K, NoInfer<A>>): ActQuestion<K, A>;
+export declare function tool(instructions: string, tools: readonly ToolDefinition[], options?: ToolOptions): ToolQuestion;
 export type QuestionSet = Record<string, QuestionSpec>;
 export type TypedDecisionResponse<Q extends QuestionSet> = Omit<DecisionResponse, 'answers'> & {
     answers: {
@@ -70,9 +84,4 @@ export type TypedDecisionResponse<Q extends QuestionSet> = Omit<DecisionResponse
     answer<K extends keyof Q & (string | number)>(key: K): Q[K] extends QuestionSpec<infer A> ? A : never;
     raw: DecisionResponse;
 };
-export declare function buildRequest(state: JsonValue, questions: QuestionSet, options: DecisionOptions): {
-    state: JsonValue;
-    questions: Record<string, Question>;
-    model?: string;
-    facts?: 'off' | 'auto';
-};
+export declare function buildRequest(state: JsonValue, questions: QuestionSet, options: DecisionOptions): DecisionRequest;