@nyte-ai/schema 0.0.0-stage → 0.0.19

package/dist/src/model/index.js

@@ -0,0 +1,61 @@
+import {
+  typed2
+} from "../../chunks/browser-qkxe0fwp.js";
+import {
+  TextSignatureV1Schema2
+} from "../../chunks/browser-7195qf3t.js";
+import {
+  MODEL_THINKING_LEVELS2,
+  MODEL_MODES2,
+  ModelSchema2
+} from "../../chunks/browser-v70eq512.js";
+import {
+  contentText2,
+  getSystemMessageText2,
+  renderSystemMessageUpdate2
+} from "../../chunks/browser-0khex2b1.js";
+import"../../chunks/browser-9ystjh78.js";
+import {
+  createInitialSystemMessage2,
+  normalizeContext2,
+  getInitialSystemMessage2,
+  withoutInitialSystemMessage2,
+  getCurrentTools2,
+  getCurrentSystemMessage2,
+  getCurrentSystemPrompt2,
+  collapseSystemMessages2,
+  resolveTranscript2,
+  toToolDeclaration2,
+  declarationsEqual2,
+  getToolStateChanges2,
+  getDeclaredTools2,
+  hasToolRedefinitions2,
+  hasNonAdditiveToolChanges2,
+  resolveTranscriptTools2
+} from "../../chunks/browser-g5khdcap.js";
+export {
+  MODEL_MODES2 as MODEL_MODES,
+  MODEL_THINKING_LEVELS2 as MODEL_THINKING_LEVELS,
+  ModelSchema2 as ModelSchema,
+  TextSignatureV1Schema2 as TextSignatureV1Schema,
+  collapseSystemMessages2 as collapseSystemMessages,
+  contentText2 as contentText,
+  createInitialSystemMessage2 as createInitialSystemMessage,
+  declarationsEqual2 as declarationsEqual,
+  getCurrentSystemMessage2 as getCurrentSystemMessage,
+  getCurrentSystemPrompt2 as getCurrentSystemPrompt,
+  getCurrentTools2 as getCurrentTools,
+  getDeclaredTools2 as getDeclaredTools,
+  getInitialSystemMessage2 as getInitialSystemMessage,
+  getSystemMessageText2 as getSystemMessageText,
+  getToolStateChanges2 as getToolStateChanges,
+  hasNonAdditiveToolChanges2 as hasNonAdditiveToolChanges,
+  hasToolRedefinitions2 as hasToolRedefinitions,
+  normalizeContext2 as normalizeContext,
+  renderSystemMessageUpdate2 as renderSystemMessageUpdate,
+  resolveTranscript2 as resolveTranscript,
+  resolveTranscriptTools2 as resolveTranscriptTools,
+  toToolDeclaration2 as toToolDeclaration,
+  typed2 as typed,
+  withoutInitialSystemMessage2 as withoutInitialSystemMessage
+};

package/dist/src/model/message.d.ts

@@ -0,0 +1,178 @@
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+import { Type } from "typebox";
+import type { Api, ProviderId } from "./model.ts";
+import type { Tool, ToolReference } from "./tool.ts";
+export interface TextSignatureV1 {
+    v: 1;
+    id: string;
+    phase?: "commentary" | "final_answer";
+}
+export declare const TextSignatureV1Schema: Type.TUnsafe<TextSignatureV1>;
+export interface TextContent {
+    type: "text";
+    text: string;
+    textSignature?: string;
+}
+export interface ThinkingContent {
+    type: "thinking";
+    thinking: string;
+    thinkingSignature?: string;
+    redacted?: boolean;
+}
+export interface ImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+export interface ToolCall {
+    type: "toolCall";
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+    thoughtSignature?: string;
+    namespace?: string;
+    /**
+     * Set when the call's finished arguments text was not a JSON object, for example because the
+     * response hit its output limit mid-call. `arguments` is then `{}`; this describes the problem
+     * and includes the text the model sent. Tool argument validation fails with it.
+     */
+    argumentsError?: string;
+}
+export interface Usage {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cacheWrite1h?: number;
+    reasoning?: number;
+    totalTokens: number;
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+}
+export type StopReason = "pending" | "stop" | "length" | "toolUse" | "error" | "aborted" | "deferred";
+export interface DeferredHandle {
+    provider: string;
+    modelId: string;
+    api: string;
+    id: string;
+    expiresAt?: number;
+    pollAfterMs?: number;
+    data?: JsonValue;
+}
+export interface DiagnosticErrorInfo {
+    name?: string;
+    message: string;
+    stack?: string;
+    code?: string | number;
+}
+export interface AssistantMessageDiagnostic {
+    type: string;
+    timestamp: number;
+    error?: DiagnosticErrorInfo;
+    details?: Record<string, unknown>;
+}
+export interface SystemMessage {
+    role: "system";
+    content: string | TextContent[];
+    sections?: Record<string, string | null>;
+    toolsAdded?: Tool[];
+    toolsRemoved?: ToolReference[];
+    timestamp: number;
+}
+export interface UserMessage {
+    role: "user";
+    content: string | (TextContent | ImageContent)[];
+    timestamp: number;
+}
+export interface AssistantMessage {
+    role: "assistant";
+    content: (TextContent | ThinkingContent | ToolCall)[];
+    api: Api;
+    provider: ProviderId;
+    model: string;
+    responseModel?: string;
+    responseId?: string;
+    diagnostics?: AssistantMessageDiagnostic[];
+    usage: Usage;
+    stopReason: StopReason;
+    deferred?: DeferredHandle;
+    errorMessage?: string;
+    rawStopReason?: string;
+    endTurn?: boolean;
+    timestamp: number;
+}
+export interface ToolResultMessage<TDetails = unknown> {
+    role: "toolResult";
+    toolCallId: string;
+    toolName: string;
+    content: (TextContent | ImageContent)[];
+    details?: TDetails;
+    structuredContent?: JsonValue;
+    title?: string;
+    usage?: Usage;
+    addedToolNames?: string[];
+    isError: boolean;
+    timestamp: number;
+}
+export type Message = SystemMessage | UserMessage | AssistantMessage | ToolResultMessage;
+export type AssistantMessageEvent = {
+    type: "start";
+    partial: AssistantMessage;
+} | {
+    type: "text_start";
+    contentIndex: number;
+    partial: AssistantMessage;
+} | {
+    type: "text_delta";
+    contentIndex: number;
+    delta: string;
+    partial: AssistantMessage;
+} | {
+    type: "text_end";
+    contentIndex: number;
+    content: string;
+    partial: AssistantMessage;
+} | {
+    type: "thinking_start";
+    contentIndex: number;
+    partial: AssistantMessage;
+} | {
+    type: "thinking_delta";
+    contentIndex: number;
+    delta: string;
+    partial: AssistantMessage;
+} | {
+    type: "thinking_end";
+    contentIndex: number;
+    content: string;
+    partial: AssistantMessage;
+} | {
+    type: "toolcall_start";
+    contentIndex: number;
+    partial: AssistantMessage;
+} | {
+    type: "toolcall_delta";
+    contentIndex: number;
+    delta: string;
+    partial: AssistantMessage;
+} | {
+    type: "toolcall_end";
+    contentIndex: number;
+    toolCall: ToolCall;
+    partial: AssistantMessage;
+} | {
+    type: "done";
+    reason: Extract<StopReason, "stop" | "length" | "toolUse" | "deferred">;
+    message: AssistantMessage;
+} | {
+    type: "error";
+    reason: Extract<StopReason, "aborted" | "error">;
+    error: AssistantMessage;
+};

package/dist/src/model/message.js

@@ -0,0 +1,7 @@
+import {
+  TextSignatureV1Schema2
+} from "../../chunks/browser-7195qf3t.js";
+import"../../chunks/browser-qkxe0fwp.js";
+export {
+  TextSignatureV1Schema2 as TextSignatureV1Schema
+};

package/dist/src/model/model.d.ts

@@ -0,0 +1,154 @@
+import { Type } from "typebox";
+export declare const MODEL_THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type ThinkingLevel = Exclude<ModelThinkingLevel, "off">;
+export type ModelThinkingLevel = (typeof MODEL_THINKING_LEVELS)[number];
+export type ThinkingLevelMap = Partial<Record<ModelThinkingLevel, string | null>>;
+export declare const MODEL_MODES: readonly ["fast"];
+export type ModelMode = (typeof MODEL_MODES)[number];
+export type KnownApi = "openai-completions" | "mistral-conversations" | "openai-responses" | "azure-openai-responses" | "openai-codex-responses" | "anthropic-messages" | "bedrock-converse-stream" | "google-generative-ai" | "google-vertex" | "pi-messages";
+export type Api = KnownApi | (string & {});
+export type KnownProvider = "amazon-bedrock" | "ant-ling" | "anthropic" | "google" | "google-vertex" | "openai" | "azure-openai-responses" | "openai-codex" | "radius" | "nvidia" | "deepseek" | "github-copilot" | "xai" | "groq" | "cerebras" | "openrouter" | "vercel-ai-gateway" | "zai" | "zai-coding-cn" | "mistral" | "minimax" | "minimax-cn" | "moonshotai" | "moonshotai-cn" | "huggingface" | "fireworks" | "together" | "baseten" | "opencode" | "opencode-go" | "kimi-coding" | "cloudflare-workers-ai" | "cloudflare-ai-gateway" | "qwen-token-plan" | "qwen-token-plan-cn" | "qwen-token-plan-individual" | "xiaomi" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-sgp";
+export type ProviderId = KnownProvider | string;
+export type ChatTemplateKwargValue = string | number | boolean | null | {
+    $var: "thinking.enabled" | "thinking.effort" | "thinking.budget";
+    omitWhenOff?: boolean;
+};
+export type ThinkingTokenBudgetField = "thinking_token_budget" | "thinking_budget" | "thinking_budget_tokens";
+export type SessionAffinityFormat = "openai" | "openai-nosession" | "openrouter";
+export type CacheRetention = "none" | "short" | "long";
+export type ModelPromptCache = Partial<Record<Exclude<CacheRetention, "none">, number>>;
+export interface AnthropicAllowedFallbackModel {
+    provider: ProviderId;
+    model: string;
+    cost: ModelCost;
+}
+export interface ModelCostRates {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
+export interface ModelCostTier extends ModelCostRates {
+    inputTokensAbove: number;
+}
+export interface ModelCost extends ModelCostRates {
+    tiers?: ModelCostTier[];
+}
+export interface OpenAICompletionsCompat {
+    supportsStore?: boolean;
+    supportsDeveloperRole?: boolean;
+    supportsReasoningEffort?: boolean;
+    supportsUsageInStreaming?: boolean;
+    supportsFinishReason?: boolean;
+    maxTokensField?: "max_completion_tokens" | "max_tokens";
+    requiresToolResultName?: boolean;
+    requiresAssistantAfterToolResult?: boolean;
+    requiresThinkingAsText?: boolean;
+    requiresReasoningContentOnAssistantMessages?: boolean;
+    thinkingFormat?: "openai" | "openrouter" | "deepseek" | "together" | "baseten" | "zai" | "qwen" | "chat-template" | "qwen-chat-template" | "string-thinking" | "ant-ling";
+    chatTemplateKwargs?: Record<string, ChatTemplateKwargValue>;
+    chatTemplateArgs?: Record<string, ChatTemplateKwargValue>;
+    openRouterRouting?: OpenRouterRouting;
+    vercelGatewayRouting?: VercelGatewayRouting;
+    zaiToolStream?: boolean;
+    thinkingTokenBudgetField?: ThinkingTokenBudgetField;
+    supportsThinkingTokenBudget?: boolean;
+    supportsOpenAIGrammarTools?: boolean;
+    supportsMidConvoSystemMessages?: boolean;
+    supportsMidConvoToolAdditions?: boolean;
+    supportsStrictMode?: boolean;
+    cacheControlFormat?: "anthropic";
+    sendSessionAffinityHeaders?: boolean;
+    deferredToolsMode?: "kimi";
+    sessionAffinityFormat?: SessionAffinityFormat;
+    supportsLongCacheRetention?: boolean;
+}
+export interface OpenAIResponsesCompat {
+    supportsDeveloperRole?: boolean;
+    supportsMidConvoSystemMessages?: boolean;
+    sessionAffinityFormat?: SessionAffinityFormat;
+    supportsLongCacheRetention?: boolean;
+    supportsStrictMode?: boolean;
+    supportsOpenAIGrammarTools?: boolean;
+    supportsAdditionalTools?: boolean;
+    supportsToolSearch?: boolean;
+    supportsExplicitPromptCacheMode?: boolean;
+}
+export interface AnthropicMessagesCompat {
+    supportsEagerToolInputStreaming?: boolean;
+    supportsLongCacheRetention?: boolean;
+    sendSessionAffinityHeaders?: boolean;
+    supportsCacheControlOnTools?: boolean;
+    supportsTemperature?: boolean;
+    forceAdaptiveThinking?: boolean;
+    allowEmptySignature?: boolean;
+    supportsStrictTools?: boolean;
+    supportsMidConvoSystemMessages?: boolean;
+    supportsMidConvoToolChanges?: boolean;
+    allowedFallbackModels?: AnthropicAllowedFallbackModel[];
+    supportsToolReferences?: boolean;
+}
+export interface BedrockCompat {
+    supportsStrictMode?: boolean;
+}
+export interface OpenRouterRouting {
+    allow_fallbacks?: boolean;
+    require_parameters?: boolean;
+    data_collection?: "deny" | "allow";
+    zdr?: boolean;
+    enforce_distillable_text?: boolean;
+    order?: string[];
+    only?: string[];
+    ignore?: string[];
+    quantizations?: string[];
+    sort?: string | {
+        by?: string;
+        partition?: string | null;
+    };
+    max_price?: {
+        prompt?: number | string;
+        completion?: number | string;
+        image?: number | string;
+        audio?: number | string;
+        request?: number | string;
+    };
+    preferred_min_throughput?: number | {
+        p50?: number;
+        p75?: number;
+        p90?: number;
+        p99?: number;
+    };
+    preferred_max_latency?: number | {
+        p50?: number;
+        p75?: number;
+        p90?: number;
+        p99?: number;
+    };
+}
+export interface VercelGatewayRouting {
+    only?: string[];
+    order?: string[];
+}
+export interface Model<TApi extends Api> {
+    id: string;
+    name: string;
+    api: TApi;
+    provider: ProviderId;
+    baseUrl: string;
+    reasoning: boolean;
+    modes?: ModelMode[];
+    variant?: {
+        mode: ModelMode;
+        base: string;
+    };
+    thinkingLevelMap?: ThinkingLevelMap;
+    promptCache?: ModelPromptCache;
+    input: ("text" | "image")[];
+    cost: ModelCost;
+    contextWindow: number;
+    maxTokens: number;
+    samplingParams?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    compat?: TApi extends "openai-completions" ? OpenAICompletionsCompat : TApi extends "openai-responses" | "azure-openai-responses" | "openai-codex-responses" ? OpenAIResponsesCompat : TApi extends "anthropic-messages" ? AnthropicMessagesCompat : TApi extends "bedrock-converse-stream" ? BedrockCompat : never;
+}
+export declare const ModelSchema: Type.TUnsafe<Model<Api>>;

package/dist/src/model/model.js

@@ -0,0 +1,11 @@
+import {
+  MODEL_THINKING_LEVELS2,
+  MODEL_MODES2,
+  ModelSchema2
+} from "../../chunks/browser-v70eq512.js";
+import"../../chunks/browser-qkxe0fwp.js";
+export {
+  MODEL_MODES2 as MODEL_MODES,
+  MODEL_THINKING_LEVELS2 as MODEL_THINKING_LEVELS,
+  ModelSchema2 as ModelSchema
+};

package/dist/src/model/text.d.ts

@@ -0,0 +1,6 @@
+import type { ImageContent, SystemMessage, TextContent, ThinkingContent, ToolCall } from "./message.ts";
+type Content = TextContent | ImageContent | ThinkingContent | ToolCall;
+export declare function contentText(content: string | readonly Content[], separator?: string): string;
+export declare function getSystemMessageText(message: SystemMessage): string;
+export declare function renderSystemMessageUpdate(message: SystemMessage): string;
+export {};

package/dist/src/model/text.js

@@ -0,0 +1,10 @@
+import {
+  contentText2,
+  getSystemMessageText2,
+  renderSystemMessageUpdate2
+} from "../../chunks/browser-0khex2b1.js";
+export {
+  contentText2 as contentText,
+  getSystemMessageText2 as getSystemMessageText,
+  renderSystemMessageUpdate2 as renderSystemMessageUpdate
+};

package/dist/src/model/tool.d.ts

@@ -0,0 +1,36 @@
+import type { TSchema } from "typebox";
+import type { JsonValue, Message } from "./message.ts";
+import type { Api, ProviderId } from "./model.ts";
+export type GrammarFormat = "openai_lark" | "openai_regex";
+export type GrammarVariants = Partial<Record<GrammarFormat, string>>;
+export type ConstrainedSamplingConfig = {
+    type: "json_schema";
+    strict: "prefer" | "require";
+} | {
+    type: "grammar";
+    variants: GrammarVariants;
+};
+export type ToolKind = "read" | "edit" | "delete" | "move" | "search" | "execute" | "fetch" | "think" | "other";
+export interface Tool<TParameters extends TSchema = TSchema> {
+    name: string;
+    description: string;
+    parameters: TParameters;
+    kind?: ToolKind;
+    constrainedSampling?: false | ConstrainedSamplingConfig;
+}
+export interface ToolReference {
+    name: string;
+}
+export interface ProviderCheckpointMaterial {
+    type: "provider";
+    provider: ProviderId;
+    api: Api;
+    model: string;
+    data: JsonValue;
+}
+export interface Context {
+    systemPrompt?: string;
+    checkpoint?: ProviderCheckpointMaterial;
+    messages: Message[];
+    tools?: Tool[];
+}

package/dist/src/model/tool.js

@@ -0,0 +1 @@
+import"../../chunks/browser-9ystjh78.js";

package/dist/src/model/transcript.d.ts

@@ -0,0 +1,34 @@
+import type { Message, SystemMessage } from "./message.ts";
+import type { Context, ProviderCheckpointMaterial, Tool, ToolReference } from "./tool.ts";
+declare const transcriptContextBrand: unique symbol;
+export interface TranscriptContext {
+    messages: Message[];
+    checkpoint?: ProviderCheckpointMaterial;
+    readonly [transcriptContextBrand]: true;
+}
+export declare function createInitialSystemMessage(systemPrompt: string | undefined, tools: Tool[] | undefined): SystemMessage | undefined;
+export declare function normalizeContext(context: Context): TranscriptContext;
+export type TranscriptMessages = readonly Message[];
+export declare function getInitialSystemMessage(messages: TranscriptMessages): SystemMessage | undefined;
+export declare function withoutInitialSystemMessage(messages: Message[]): Message[];
+export declare function getCurrentTools(messages: TranscriptMessages): Tool[];
+export declare function getCurrentSystemMessage(messages: TranscriptMessages): SystemMessage | undefined;
+export declare function getCurrentSystemPrompt(messages: TranscriptMessages): string;
+export declare function collapseSystemMessages(context: TranscriptContext): TranscriptContext;
+export declare function resolveTranscript(context: TranscriptContext, supportsMidConvoSystemMessages: boolean | undefined): TranscriptContext;
+export declare function toToolDeclaration(tool: Tool): Tool;
+export declare function declarationsEqual(left: Tool, right: Tool): boolean;
+export interface ToolStateChanges {
+    toolsAdded: Tool[];
+    toolsRemoved: ToolReference[];
+}
+export declare function getToolStateChanges(previous: readonly Tool[], current: readonly Tool[]): ToolStateChanges;
+export declare function getDeclaredTools(messages: TranscriptMessages): Tool[];
+export declare function hasToolRedefinitions(messages: TranscriptMessages): boolean;
+export declare function hasNonAdditiveToolChanges(messages: TranscriptMessages): boolean;
+export interface TranscriptTools {
+    requestTools: Tool[];
+    anchorsAdditions: boolean;
+}
+export declare function resolveTranscriptTools(messages: TranscriptMessages, supportsToolAdditions: boolean): TranscriptTools;
+export {};

package/dist/src/model/transcript.js

@@ -0,0 +1,37 @@
+import {
+  createInitialSystemMessage2,
+  normalizeContext2,
+  getInitialSystemMessage2,
+  withoutInitialSystemMessage2,
+  getCurrentTools2,
+  getCurrentSystemMessage2,
+  getCurrentSystemPrompt2,
+  collapseSystemMessages2,
+  resolveTranscript2,
+  toToolDeclaration2,
+  declarationsEqual2,
+  getToolStateChanges2,
+  getDeclaredTools2,
+  hasToolRedefinitions2,
+  hasNonAdditiveToolChanges2,
+  resolveTranscriptTools2
+} from "../../chunks/browser-g5khdcap.js";
+import"../../chunks/browser-0khex2b1.js";
+export {
+  collapseSystemMessages2 as collapseSystemMessages,
+  createInitialSystemMessage2 as createInitialSystemMessage,
+  declarationsEqual2 as declarationsEqual,
+  getCurrentSystemMessage2 as getCurrentSystemMessage,
+  getCurrentSystemPrompt2 as getCurrentSystemPrompt,
+  getCurrentTools2 as getCurrentTools,
+  getDeclaredTools2 as getDeclaredTools,
+  getInitialSystemMessage2 as getInitialSystemMessage,
+  getToolStateChanges2 as getToolStateChanges,
+  hasNonAdditiveToolChanges2 as hasNonAdditiveToolChanges,
+  hasToolRedefinitions2 as hasToolRedefinitions,
+  normalizeContext2 as normalizeContext,
+  resolveTranscript2 as resolveTranscript,
+  resolveTranscriptTools2 as resolveTranscriptTools,
+  toToolDeclaration2 as toToolDeclaration,
+  withoutInitialSystemMessage2 as withoutInitialSystemMessage
+};

package/dist/src/model/typed.d.ts

@@ -0,0 +1,6 @@
+import { Type } from "typebox";
+import type { Static, TProperties, TSchema, TUnsafe } from "typebox";
+type Proof<S extends TSchema, T> = [Static<S>] extends [T] ? [T] extends [Static<S>] ? S : never : never;
+export declare const typed: <T>() => <S extends TSchema>(schema: Proof<S, T>) => TUnsafe<T>;
+export declare const object: <P extends TProperties>(properties: P) => Type.TObject<P>;
+export {};

package/dist/src/model/typed.js

@@ -0,0 +1,8 @@
+import {
+  typed2,
+  object2
+} from "../../chunks/browser-qkxe0fwp.js";
+export {
+  object2 as object,
+  typed2 as typed
+};