@corbits/system-one 0.1.0

package/dist/schemas.d.ts

@@ -0,0 +1,444 @@
+export declare const JsonRecord: import("arktype/internal/variants/object.ts").ObjectType<{
+    [x: string]: unknown;
+}, {}>;
+export type JsonRecord = typeof JsonRecord.infer;
+export declare const Description: import("arktype").BaseType<string | {
+    [x: string]: unknown;
+} | unknown[], {}>;
+export type Description = typeof Description.infer;
+export declare const State: import("arktype").BaseType<string | {
+    [x: string]: unknown;
+} | unknown[], {}>;
+export type State = typeof State.infer;
+export declare const ChoiceQuestion: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: string;
+    type: "choice";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria: {
+        [x: string]: string | {
+            [x: string]: unknown;
+        } | unknown[] | null;
+    };
+}, {}>;
+export type ChoiceQuestion = typeof ChoiceQuestion.infer;
+export declare const ScoreQuestion: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: string;
+    type: "score";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria: (string | {
+        [x: string]: unknown;
+    } | unknown[])[];
+}, {}>;
+export type ScoreQuestion = typeof ScoreQuestion.infer;
+export declare const NoulQuestion: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: string;
+    type: "noul";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria?: {
+        true?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+        false?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+    };
+}, {}>;
+export type NoulQuestion = typeof NoulQuestion.infer;
+export declare const BooleanQuestion: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: string;
+    type: "boolean";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria?: {
+        true?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+        false?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+    };
+}, {}>;
+export type BooleanQuestion = typeof BooleanQuestion.infer;
+export declare const Question: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: string;
+    type: "choice";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria: {
+        [x: string]: string | {
+            [x: string]: unknown;
+        } | unknown[] | null;
+    };
+} | {
+    id: string;
+    type: "score";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria: (string | {
+        [x: string]: unknown;
+    } | unknown[])[];
+} | {
+    id: string;
+    type: "noul";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria?: {
+        true?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+        false?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+    };
+} | {
+    id: string;
+    type: "boolean";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria?: {
+        true?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+        false?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+    };
+}, {}>;
+export type Question = typeof Question.infer;
+export declare const QuestionList: import("arktype/internal/variants/array.ts").ArrayType<({
+    id: string;
+    type: "choice";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria: {
+        [x: string]: string | {
+            [x: string]: unknown;
+        } | unknown[] | null;
+    };
+} | {
+    id: string;
+    type: "score";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria: (string | {
+        [x: string]: unknown;
+    } | unknown[])[];
+} | {
+    id: string;
+    type: "noul";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria?: {
+        true?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+        false?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+    };
+} | {
+    id: string;
+    type: "boolean";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria?: {
+        true?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+        false?: string | {
+            [x: string]: unknown;
+        } | unknown[];
+    };
+})[], {}>;
+export type QuestionList = typeof QuestionList.infer;
+export declare const EndpointConfig: import("arktype/internal/variants/object.ts").ObjectType<{
+    kind: "custom";
+    url: string;
+    model?: string;
+} | {
+    kind: "official" | "gateway";
+    model?: string;
+}, {}>;
+export type EndpointConfig = typeof EndpointConfig.infer;
+export declare const EvaluateConfig: import("arktype/internal/variants/object.ts").ObjectType<{
+    endpoint?: {
+        kind: "custom";
+        url: string;
+        model?: string;
+    } | {
+        kind: "official" | "gateway";
+        model?: string;
+    };
+    timeoutMs?: unknown;
+    apiKey?: string;
+}, {}>;
+export type EvaluateConfig = typeof EvaluateConfig.infer;
+export declare const EvaluateInput: import("arktype/internal/variants/object.ts").ObjectType<{
+    state: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    questions: ({
+        id: string;
+        type: "choice";
+        instructions: string | {
+            [x: string]: unknown;
+        } | unknown[];
+        criteria: {
+            [x: string]: string | {
+                [x: string]: unknown;
+            } | unknown[] | null;
+        };
+    } | {
+        id: string;
+        type: "score";
+        instructions: string | {
+            [x: string]: unknown;
+        } | unknown[];
+        criteria: (string | {
+            [x: string]: unknown;
+        } | unknown[])[];
+    } | {
+        id: string;
+        type: "noul";
+        instructions: string | {
+            [x: string]: unknown;
+        } | unknown[];
+        criteria?: {
+            true?: string | {
+                [x: string]: unknown;
+            } | unknown[];
+            false?: string | {
+                [x: string]: unknown;
+            } | unknown[];
+        };
+    } | {
+        id: string;
+        type: "boolean";
+        instructions: string | {
+            [x: string]: unknown;
+        } | unknown[];
+        criteria?: {
+            true?: string | {
+                [x: string]: unknown;
+            } | unknown[];
+            false?: string | {
+                [x: string]: unknown;
+            } | unknown[];
+        };
+    })[];
+    config?: {
+        endpoint?: {
+            kind: "custom";
+            url: string;
+            model?: string;
+        } | {
+            kind: "official" | "gateway";
+            model?: string;
+        };
+        timeoutMs?: unknown;
+        apiKey?: string;
+    };
+}, {}>;
+export type EvaluateInput = typeof EvaluateInput.infer;
+/** One question in wire form: no id (the map key carries it). */
+export declare const WireQuestion: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "choice" | "score" | "noul";
+    instructions: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    criteria?: unknown;
+}, {}>;
+export type WireQuestion = typeof WireQuestion.infer;
+/** The exact POST body: model + state + id-keyed questions. */
+export declare const WireRequest: import("arktype/internal/variants/object.ts").ObjectType<{
+    model: string;
+    state: string | {
+        [x: string]: unknown;
+    } | unknown[];
+    questions: {
+        [x: string]: {
+            type: "choice" | "score" | "noul";
+            instructions: string | {
+                [x: string]: unknown;
+            } | unknown[];
+            criteria?: unknown;
+        };
+    };
+}, {}>;
+export type WireRequest = typeof WireRequest.infer;
+/**
+ * Maps caller-facing questions to the wire map. The `boolean` alias becomes
+ * native `noul`; everything else passes through with its id as the key.
+ */
+export declare function toWireQuestions(questions: Question[]): Record<string, WireQuestion>;
+export declare const Confidence: import("arktype/internal/variants/number.ts").NumberType<number, {}>;
+export type Confidence = typeof Confidence.infer;
+export declare const ProbabilityMap: import("arktype/internal/variants/object.ts").ObjectType<{
+    [x: string]: number;
+}, {}>;
+export type ProbabilityMap = typeof ProbabilityMap.infer;
+/** Tolerance for probability-sum checks (backend rounds to 2 decimals). */
+export declare const APPROXIMATE_SUM_TOLERANCE = 0.02;
+export declare const WireAnswer: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "choice" | "score" | "noul";
+    choice?: string;
+    score?: number;
+    noul?: number;
+    probabilities?: {
+        [x: string]: number;
+    };
+    confidence?: number;
+    legend?: {
+        [x: string]: string;
+    };
+}, {}>;
+export type WireAnswer = typeof WireAnswer.infer;
+export declare const WireUsage: import("arktype/internal/variants/object.ts").ObjectType<{
+    input_tokens: number;
+    output_tokens: number;
+}, {}>;
+export type WireUsage = typeof WireUsage.infer;
+export declare const WireResponseBody: import("arktype/internal/variants/object.ts").ObjectType<{
+    answers: {
+        [x: string]: {
+            type: "choice" | "score" | "noul";
+            choice?: string;
+            score?: number;
+            noul?: number;
+            probabilities?: {
+                [x: string]: number;
+            };
+            confidence?: number;
+            legend?: {
+                [x: string]: string;
+            };
+        };
+    };
+    model?: string;
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}, {}>;
+export type WireResponseBody = typeof WireResponseBody.infer;
+export declare const Decision: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: string;
+    type: "noul";
+    noul: number;
+} | {
+    id: string;
+    type: "choice";
+    choice: string;
+    probabilities: {
+        [x: string]: number;
+    };
+    confidence: number;
+} | {
+    id: string;
+    type: "score";
+    score: number;
+    legend: {
+        [x: string]: string;
+    };
+    probabilities: {
+        [x: string]: number;
+    };
+    confidence: number;
+}, {}>;
+export type Decision = typeof Decision.infer;
+/**
+ * Builds a caller-facing decision from a wire answer: the kind's contract
+ * fields only, so cross-kind extras are dropped and a malformed answer
+ * (e.g. a choice answer missing `choice`) throws a typed `SystemOneError`
+ * instead of producing a half-empty decision.
+ */
+export declare function toDecision(id: string, answer: WireAnswer): Decision;
+export declare const Usage: import("arktype/internal/variants/object.ts").ObjectType<{
+    inputTokens: number;
+    outputTokens: number;
+}, {}>;
+export type Usage = typeof Usage.infer;
+export declare const EvaluateResponseBody: import("arktype/internal/variants/object.ts").ObjectType<{
+    answers: {
+        [x: string]: {
+            type: "choice" | "score" | "noul";
+            choice?: string;
+            score?: number;
+            noul?: number;
+            probabilities?: {
+                [x: string]: number;
+            };
+            confidence?: number;
+            legend?: {
+                [x: string]: string;
+            };
+        };
+    };
+    model?: string;
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}, {}>;
+export type EvaluateResponseBody = typeof EvaluateResponseBody.infer;
+export declare const EvaluateResult: import("arktype/internal/variants/object.ts").ObjectType<{
+    decisions: ({
+        id: string;
+        type: "noul";
+        noul: number;
+    } | {
+        id: string;
+        type: "choice";
+        choice: string;
+        probabilities: {
+            [x: string]: number;
+        };
+        confidence: number;
+    } | {
+        id: string;
+        type: "score";
+        score: number;
+        legend: {
+            [x: string]: string;
+        };
+        probabilities: {
+            [x: string]: number;
+        };
+        confidence: number;
+    })[];
+    modelId: string;
+    backend: "custom" | "gateway" | "corbits-system-one";
+    latencyMs: number;
+    fallback: false;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}, {}>;
+export type EvaluateResult = typeof EvaluateResult.infer;
+export declare const FallbackReason: import("arktype/internal/variants/string.ts").StringType<"no-key" | "timeout" | "network" | "http-error" | "parse-error" | "backend-unreachable", {}>;
+export type FallbackReason = typeof FallbackReason.infer;
+export declare const FallbackResult: import("arktype/internal/variants/object.ts").ObjectType<{
+    fallback: true;
+    reason: "no-key" | "timeout" | "network" | "http-error" | "parse-error" | "backend-unreachable";
+    latencyMs: number;
+    backendAttempted: string;
+    httpStatus?: number;
+    detail?: string;
+}, {}>;
+export type FallbackResult = typeof FallbackResult.infer;