indusagi 0.13.7 → 0.13.8

package/dist/types/facade/ml/kit/event-stream.d.ts

@@ -0,0 +1,63 @@
+import type { AssistantMessage, AssistantMessageEvent, ToolCall } from "../types.js";
+export interface EventStreamOptions {
+    historyLimit?: number;
+}
+/**
+ * Generic producer/consumer channel: callers shove events in via `push` while
+ * downstream code reads them with `for await`. Whichever event matches
+ * `isComplete` flips the channel into a terminal state and settles a
+ * dedicated result promise (typed as `R`) using `extractResult`.
+ *
+ * Implementation-wise, every event lands in a single FIFO array. After each
+ * push (or when the channel is closed) we fire the optional "wake" callback
+ * that an idle iterator is parked on. The iterator itself maintains a private
+ * read cursor, flushes any backlog already sitting in the buffer, and only
+ * suspends on a freshly-armed wake promise once it has caught up to head and
+ * the channel hasn't been closed yet.
+ */
+export declare class EventStream<T, R = T> implements AsyncIterable<T> {
+    private isComplete;
+    private extractResult;
+    private options;
+    private buffer;
+    private closed;
+    private notify;
+    private finalResultPromise;
+    private resolveFinalResult;
+    private rejectFinalResult;
+    private history;
+    constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R, options?: EventStreamOptions);
+    /** Resume the iterator that is waiting on `notify`, when one exists. */
+    private wake;
+    push(event: T): void;
+    end(result?: R): void;
+    error(error: unknown): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    result(): Promise<R>;
+    resultWithTimeout(timeoutMs: number): Promise<R>;
+    filter(predicate: (event: T) => boolean): AsyncIterable<T>;
+    map<U>(mapper: (event: T) => U): AsyncIterable<U>;
+    getHistory(): readonly T[];
+    private pushHistory;
+}
+export declare class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
+    constructor(options?: EventStreamOptions);
+    pushStart(partial: AssistantMessage): void;
+    pushTextStart(contentIndex: number, partial: AssistantMessage): void;
+    pushTextDelta(contentIndex: number, delta: string, partial: AssistantMessage): void;
+    pushTextEnd(contentIndex: number, content: string, partial: AssistantMessage): void;
+    pushThinkingStart(contentIndex: number, partial: AssistantMessage): void;
+    pushThinkingDelta(contentIndex: number, delta: string, partial: AssistantMessage): void;
+    pushThinkingEnd(contentIndex: number, content: string, partial: AssistantMessage): void;
+    pushToolCallStart(contentIndex: number, partial: AssistantMessage): void;
+    pushToolCallDelta(contentIndex: number, delta: string, partial: AssistantMessage): void;
+    pushToolCallEnd(contentIndex: number, toolCall: ToolCall, partial: AssistantMessage): void;
+    pushDone(reason: "stop" | "length" | "toolUse", message: AssistantMessage): void;
+    pushError(reason: "aborted" | "error", error: AssistantMessage): void;
+}
+/**
+ * Factory that hands back a fresh {@link AssistantMessageEventStream}
+ * instance. Using it (instead of `new`-ing the class yourself) keeps
+ * consumer code free of a direct dependency on the concrete constructor.
+ */
+export declare function createAssistantMessageEventStream(options?: EventStreamOptions): AssistantMessageEventStream;

package/dist/types/facade/ml/kit/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./base-stream-handler.js";
+export * from "./event-stream.js";
+export * from "./json-parse.js";
+export * from "./message-transform.js";
+export * from "./output-factory.js";
+export * from "./provider-adapter.js";
+export * from "./provider-client-builder.js";
+export * from "./provider-constants.js";
+export * from "./provider-consolidation.js";
+export * from "./provider-errors.js";
+export * from "./stream-event-helper.js";
+export * from "./stream-handler-types.js";
+export * from "./streaming-state-manager.js";
+export * from "./tool-converter.js";

package/dist/types/facade/ml/kit/json-parse.d.ts

@@ -0,0 +1,23 @@
+export interface StreamingJsonParseOptions {
+    fallbackValue?: unknown;
+    fallback?: unknown;
+    allowPartial?: boolean;
+    strict?: boolean;
+    trimInput?: boolean;
+}
+export interface StreamingJsonParseResult<T> {
+    value: T;
+    parsed: boolean;
+    ok?: boolean;
+    usedPartialParser: boolean;
+    error?: string;
+}
+export declare function parseStreamingJsonWithDiagnostics<T = any>(partialJson: string | undefined, options?: StreamingJsonParseOptions): StreamingJsonParseResult<T>;
+/**
+ * Convenience wrapper that returns just the decoded value from a possibly
+ * mid-stream JSON snippet. Internally it leans on the diagnostic variant —
+ * trying a strict `JSON.parse`, then a lenient partial-JSON pass, and finally
+ * yielding the configured fallback — so callers always get something usable
+ * back even when the input is still being streamed.
+ */
+export declare function parseStreamingJson<T = any>(partialJson: string | undefined, options?: StreamingJsonParseOptions): T;

package/dist/types/facade/ml/kit/message-transform.d.ts

@@ -0,0 +1,32 @@
+import type { TextContent, ImageContent } from "../types.js";
+/**
+ * Utility functions for converting message content back and forth between a
+ * flat string and an array of content blocks.
+ */
+/**
+ * Reduce content to plain text. Strings pass through unchanged; for a block
+ * array, the text blocks are concatenated with newline separators and any
+ * image blocks are discarded.
+ */
+export declare function messageContentToString(content: string | (TextContent | ImageContent)[]): string;
+/**
+ * Tell whether the content contains at least one image block.
+ */
+export declare function messageHasImages(content: string | (TextContent | ImageContent)[]): boolean;
+/**
+ * Return just the text blocks. A bare string is promoted to one text block.
+ */
+export declare function extractTextBlocks(content: string | (TextContent | ImageContent)[]): TextContent[];
+/**
+ * Return just the image blocks; a plain string produces an empty list.
+ */
+export declare function extractImageBlocks(content: string | (TextContent | ImageContent)[]): ImageContent[];
+/**
+ * Remove control characters so the text is wire-safe. NUL bytes are dropped
+ * first, followed by the rest of the C0 control range together with DEL.
+ */
+export declare function sanitizeContentString(text: string): string;
+/**
+ * Normalize newlines: turn every CRLF or standalone CR into a single LF.
+ */
+export declare function normalizeLineEndings(text: string): string;

package/dist/types/facade/ml/kit/output-factory.d.ts

@@ -0,0 +1,8 @@
+import type { Api, AssistantMessage, Model } from "../types.js";
+/**
+ * Create the initial empty assistant message that a streaming response builds
+ * upon: no content yet, the model's api/provider/id copied across, zeroed
+ * usage counters, a placeholder `stop` reason, and a timestamp of now. Each
+ * provider fills it in as events come through.
+ */
+export declare function createAssistantMessageOutput<TApi extends Api>(model: Model<TApi>): AssistantMessage;

package/dist/types/facade/ml/kit/overflow.d.ts

@@ -0,0 +1,9 @@
+import type { AssistantMessage } from "../types.js";
+export interface OverflowPatternConfig {
+    pattern: RegExp;
+    suggestion: string;
+}
+export declare const OVERFLOW_PATTERN_CONFIG: OverflowPatternConfig[];
+export declare function isContextOverflow(message: AssistantMessage, contextWindow?: number): boolean;
+export declare function getOverflowPatterns(): RegExp[];
+export declare function getOverflowSuggestion(errorMessage: string | undefined): string | undefined;

package/dist/types/facade/ml/kit/provider-adapter.d.ts

@@ -0,0 +1,56 @@
+import type { Api, Context, Model, StreamOptions } from "../types.js";
+import type { AssistantMessageEventStream } from "./event-stream.js";
+import type { StreamingStateManager } from "./streaming-state-manager.js";
+/**
+ * Generic adapter interface for streaming providers.
+ * Encapsulates provider-specific client, request building, and stream processing.
+ */
+export interface ProviderAdapter<TOptions extends StreamOptions = StreamOptions> {
+    /** API identifier (e.g., "anthropic-messages"). */
+    readonly api: Api;
+    /** Provider name (e.g., "anthropic"). */
+    readonly provider: string;
+    /** Model identifier. */
+    readonly model: Model<Api>;
+    /** Optional provider-specific options. */
+    readonly options?: TOptions;
+    /** Context (system prompt, messages, tools). */
+    readonly context: Context;
+    /** Stream to push events to. */
+    readonly stream: AssistantMessageEventStream;
+    /** Optional abort signal. */
+    readonly signal?: AbortSignal;
+    /** Streaming state manager (tracks output, usage, stop reason). */
+    state: StreamingStateManager;
+    /** Initialize the adapter (e.g., create client). */
+    initialize(): Promise<void> | void;
+    /** Build provider-specific request parameters. */
+    buildRequest(): unknown;
+    /** Execute the request and stream events. */
+    executeStream(): Promise<void>;
+    /** Cleanup resources after streaming completes. */
+    cleanup(): Promise<void> | void;
+}
+/**
+ * Base adapter with shared lifecycle and helper methods.
+ */
+export declare abstract class BaseProviderAdapter<TOptions extends StreamOptions = StreamOptions> implements ProviderAdapter<TOptions> {
+    readonly model: Model<Api>;
+    readonly context: Context;
+    readonly stream: AssistantMessageEventStream;
+    readonly options?: TOptions | undefined;
+    readonly signal?: AbortSignal | undefined;
+    readonly api: Api;
+    readonly provider: string;
+    constructor(model: Model<Api>, context: Context, stream: AssistantMessageEventStream, options?: TOptions | undefined, signal?: AbortSignal | undefined);
+    /** To be set by subclasses during initialization. */
+    state: StreamingStateManager;
+    abstract initialize(): Promise<void> | void;
+    abstract buildRequest(): unknown;
+    abstract executeStream(): Promise<void>;
+    cleanup(): Promise<void> | void;
+    /** Check if aborted. */
+    protected isAborted(): boolean;
+    /** Emit error if aborted. */
+    protected throwIfAborted(): void;
+}

package/dist/types/facade/ml/kit/provider-client-builder.d.ts

@@ -0,0 +1,36 @@
+import type { Api } from "../types.js";
+/**
+ * Generic client configuration for provider HTTP clients.
+ */
+export interface ClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+    defaultHeaders?: Record<string, string>;
+    timeout?: number;
+}
+/**
+ * Builder interface for creating provider clients.
+ */
+export interface ClientBuilder<TClient> {
+    build(config: ClientConfig): TClient;
+}
+/**
+ * Anthropic client builder.
+ */
+export declare class AnthropicClientBuilder implements ClientBuilder<any> {
+    build(config: ClientConfig): any;
+}
+/**
+ * OpenAI client builder.
+ */
+export declare class OpenAIClientBuilder implements ClientBuilder<any> {
+    build(config: ClientConfig): any;
+}
+/**
+ * Shared client factory that resolves builders by API.
+ */
+export declare class ProviderClientFactory {
+    private static builders;
+    static register<TClient>(api: Api, builder: ClientBuilder<TClient>): void;
+    static create<TClient>(api: Api, config: ClientConfig): TClient;
+}

package/dist/types/facade/ml/kit/provider-consolidation.d.ts

@@ -0,0 +1,3 @@
+import type { StopReason } from "../types.js";
+export declare function normalizeToolCallId(id: string, maxLengthOrModel?: number | unknown, ..._rest: unknown[]): string;
+export declare function mapStopReason(reason: string | null | undefined, provider?: string): StopReason;

package/dist/types/facade/ml/kit/provider-constants.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared constants for AI streaming providers.
+ */
+/** Default timeout for provider HTTP requests (milliseconds). */
+export declare const DEFAULT_PROVIDER_TIMEOUT = 30000;
+/** Default maximum number of retry attempts. */
+export declare const DEFAULT_MAX_RETRIES = 3;
+/** Base delay for exponential backoff (milliseconds). */
+export declare const DEFAULT_RETRY_DELAY_MS = 250;
+/** Maximum tokens in text content before truncation warnings. */
+export declare const DEFAULT_MAX_TEXT_TOKENS = 50000;
+/** Maximum size of thinking blocks before truncation (bytes). */
+export declare const DEFAULT_MAX_THINKING_BYTES = 100000;
+/** Standard system prompt for tool-use scenarios. */
+export declare const DEFAULT_TOOL_SYSTEM_PROMPT = "You are a helpful assistant with access to tools.";
+/** Anthropic-specific defaults. */
+export declare const ANTHROPIC_DEFAULT_MAX_TOKENS = 4096;
+export declare const ANTHROPIC_DEFAULT_THINKING_BUDGET = 10000;
+/** OpenAI-specific defaults. */
+export declare const OPENAI_DEFAULT_MAX_TOKENS = 4096;
+export declare const OPENAI_DEFAULT_TEMPERATURE = 0.7;
+/** Google-specific defaults. */
+export declare const GOOGLE_DEFAULT_MAX_TOKENS = 8192;
+export declare const GOOGLE_DEFAULT_TEMPERATURE = 0.8;
+/** Bedrock-specific defaults. */
+export declare const BEDROCK_DEFAULT_MAX_TOKENS = 4096;
+export declare const BEDROCK_DEFAULT_TEMPERATURE = 0.7;
+/** Tool-related defaults. */
+export declare const DEFAULT_TOOL_CALL_TIMEOUT = 60000;
+export declare const DEFAULT_MAX_TOOLS_PER_REQUEST = 128;
+/** Streaming batch sizes. */
+export declare const STREAMING_BATCH_SIZE_TEXT = 100;
+export declare const STREAMING_BATCH_SIZE_THINKING = 50;
+export declare const STREAMING_BATCH_SIZE_TOOL_CALL = 20;

package/dist/types/facade/ml/kit/provider-errors.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Common helpers used across streaming adapters when surfacing failures
+ * out of provider-specific error shapes into our unified domain types.
+ */
+import type { StopReason } from "../types.js";
+/**
+ * Canonical, provider-agnostic identifiers used to tag failure modes coming
+ * back from upstream LLM endpoints.
+ */
+export declare enum ProviderErrorCode {
+    /** Authentication failed (invalid API key). */
+    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED",
+    /** Rate limit exceeded. */
+    RATE_LIMITED = "RATE_LIMITED",
+    /** Request timed out. */
+    TIMEOUT = "TIMEOUT",
+    /** Network connection error. */
+    NETWORK_ERROR = "NETWORK_ERROR",
+    /** Invalid request parameters. */
+    INVALID_REQUEST = "INVALID_REQUEST",
+    /** Provider service unavailable. */
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
+    /** Content policy violation. */
+    CONTENT_FILTERED = "CONTENT_FILTERED",
+    /** Unknown or unexpected error. */
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Error type emitted by adapters once a raw provider error has been
+ * normalised; carries a coded reason plus the original payload for callers
+ * that want to drill deeper.
+ */
+export declare class ProviderError extends Error {
+    readonly code: ProviderErrorCode;
+    readonly originalError?: unknown | undefined;
+    constructor(message: string, code: ProviderErrorCode, originalError?: unknown | undefined);
+}
+/**
+ * Translates the assorted stop-reason strings different providers emit into
+ * the small closed StopReason enum the rest of the stack relies on.
+ */
+export declare function mapProviderStopReason(reason: string | null | undefined, provider: string): StopReason;
+/**
+ * Renders a human-readable string for any error value, tagging it with the
+ * provider name and embedding the error code when one is available.
+ */
+export declare function formatProviderError(error: unknown, providerName: string): string;
+/**
+ * Heuristic for whether a failure is worth another attempt: classified codes
+ * map directly, while generic errors are sniffed by message text.
+ */
+export declare function isRetryableError(error: unknown): boolean;

package/dist/types/facade/ml/kit/sanitize-unicode.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeSurrogates(text: string): string;
+export declare function sanitizeUnknownUnicode<T>(value: T): T;

package/dist/types/facade/ml/kit/stream-event-helper.d.ts

@@ -0,0 +1,38 @@
+import type { AssistantMessage, TextContent, ThinkingContent, ToolCall } from "../types.js";
+import type { AssistantMessageEventStream } from "./event-stream.js";
+/** The content-block kinds that may appear while a response is being streamed. */
+export type StreamBlock = TextContent | ThinkingContent | ToolCall;
+/**
+ * Resolves which content block a streaming delta targets. Providers tag each
+ * block with an `index`; this tracker uses that tag to find the matching block
+ * (or its position) within a partially built assistant message.
+ */
+export declare class BlockTracker<TBlock extends StreamBlock = StreamBlock> {
+    private readonly blocks;
+    constructor(output: AssistantMessage);
+    findByIndex(index: number): (TBlock & {
+        index?: number;
+    }) | undefined;
+    findPositionByIndex(index: number): number;
+}
+/**
+ * Convenience facade over an {@link AssistantMessageEventStream}. Each method
+ * relays one lifecycle call and automatically tacks on the latest partial
+ * output, so provider handlers don't have to thread that argument through by
+ * hand every time.
+ */
+export declare class StreamEventHelper {
+    private readonly stream;
+    private readonly output;
+    constructor(stream: AssistantMessageEventStream, output: AssistantMessage);
+    start(): void;
+    textStart(contentIndex: number): void;
+    textDelta(contentIndex: number, delta: string): void;
+    textEnd(contentIndex: number, content: string): void;
+    thinkingStart(contentIndex: number): void;
+    thinkingDelta(contentIndex: number, delta: string): void;
+    thinkingEnd(contentIndex: number, content: string): void;
+    toolCallStart(contentIndex: number): void;
+    toolCallDelta(contentIndex: number, delta: string): void;
+    toolCallEnd(contentIndex: number, toolCall: ToolCall): void;
+}

package/dist/types/facade/ml/kit/stream-handler-types.d.ts

@@ -0,0 +1,46 @@
+import type { Api, AssistantMessage, Context, Model, StreamOptions } from "../types.js";
+import type { AssistantMessageEventStream } from "./event-stream.js";
+import type { StreamingStateManager } from "./streaming-state-manager.js";
+/**
+ * Type definitions reused across the various provider stream-handler classes.
+ */
+/**
+ * The full working set a handler operates with for one run: which model to
+ * call, the request context, the event stream to emit on, caller-supplied
+ * options, an optional abort signal, and the mutable state tracker.
+ */
+export interface StreamHandlerExecutionContext {
+    model: Model<Api>;
+    context: Context;
+    stream: AssistantMessageEventStream;
+    options?: StreamOptions;
+    signal?: AbortSignal;
+    state: StreamingStateManager;
+}
+/**
+ * A loosely typed request bag; individual providers refine it to their shape.
+ */
+export interface ProviderRequest {
+    [key: string]: unknown;
+}
+/**
+ * A loosely typed response bag; individual providers refine it to their shape.
+ */
+export interface ProviderResponse {
+    [key: string]: unknown;
+}
+/**
+ * Strongly typed scaffold for provider handlers. The model, context, stream,
+ * options, and abort signal are stored on construction, leaving subclasses to
+ * supply only {@link execute}.
+ */
+export declare abstract class TypedStreamHandler<TOptions extends StreamOptions = StreamOptions> {
+    protected readonly model: Model<Api>;
+    protected readonly context: Context;
+    protected readonly stream: AssistantMessageEventStream;
+    protected readonly options?: TOptions | undefined;
+    protected readonly signal?: AbortSignal | undefined;
+    constructor(model: Model<Api>, context: Context, stream: AssistantMessageEventStream, options?: TOptions | undefined, signal?: AbortSignal | undefined);
+    protected createStateManager(initialOutput: AssistantMessage): StreamingStateManager;
+    abstract execute(): AssistantMessageEventStream;
+}

package/dist/types/facade/ml/kit/streaming-state-manager.d.ts

@@ -0,0 +1,42 @@
+import type { AssistantMessage, StopReason, Usage } from "../types.js";
+/**
+ * Centralizes the mutable bits of an in-flight stream — the output message as
+ * it accumulates, usage counters, the stop reason, and a completion flag.
+ * Provider handlers lean on this single holder rather than tracking those
+ * pieces independently.
+ */
+export declare class StreamingStateManager {
+    /** The assistant message that grows in place as events arrive. */
+    readonly output: AssistantMessage;
+    private _stopReason;
+    private _isComplete;
+    /**
+     * @param initialOutput - Starting assistant message; this instance edits it directly.
+     */
+    constructor(initialOutput: AssistantMessage);
+    /**
+     * Fold the supplied usage values into the output's running totals.
+     *
+     * @param update - Partial set of usage counters to apply.
+     */
+    setUsage(update: Partial<Usage>): void;
+    /**
+     * Note why streaming stopped and reflect that choice onto the output.
+     *
+     * @param reason - The stop reason to remember.
+     */
+    setStopReason(reason: StopReason): void;
+    /** The most recently set stop reason. */
+    get stopReason(): StopReason;
+    /** Mark the stream as done. */
+    complete(): void;
+    /** True once the stream has been marked done. */
+    get isComplete(): boolean;
+    /**
+     * Mark the stream as failed: completes it, switches the stop reason to
+     * `error`, and records the failure text on the output.
+     *
+     * @param errorMessage - Human-readable description of the failure.
+     */
+    error(errorMessage: string): void;
+}

package/dist/types/facade/ml/kit/tool-converter.d.ts

@@ -0,0 +1,49 @@
+import type { Tool } from "../types.js";
+/**
+ * Shared conversion helpers for tool schemas across providers.
+ *
+ * This module provides utilities for converting between generic tool definitions
+ * and provider-specific tool schemas.
+ */
+/**
+ * Normalize tool name to provider-specific format.
+ *
+ * @param name - Original tool name.
+ * @param maxLength - Maximum length for the normalized name (default: 64).
+ * @returns Normalized tool name.
+ *
+ * Default implementation removes special characters and truncates to maxLength.
+ */
+export declare function normalizeToolName(name: string, maxLength?: number): string;
+/**
+ * Provider-agnostic tool schema shape.
+ */
+export interface ProviderToolSchema {
+    /** Tool name. */
+    name: string;
+    /** Tool description. */
+    description: string;
+    /** Tool parameters (JSON Schema). */
+    parameters: unknown;
+}
+/**
+ * Convert a generic tool to provider tool schema.
+ *
+ * @param tool - Generic tool definition.
+ * @returns Provider-specific tool schema.
+ */
+export declare function toProviderTool(tool: Tool): ProviderToolSchema;
+/**
+ * Convert a provider tool schema back to generic tool.
+ *
+ * @param schema - Provider-specific tool schema.
+ * @returns Generic tool definition.
+ */
+export declare function fromProviderTool(schema: ProviderToolSchema): Tool;
+/**
+ * Convert an array of generic tools to provider format.
+ *
+ * @param tools - Array of generic tool definitions.
+ * @returns Array of provider-specific tool schemas.
+ */
+export declare function convertTools(tools: Tool[]): ProviderToolSchema[];

package/dist/types/facade/ml/kit/typebox-helpers.d.ts

@@ -0,0 +1,24 @@
+import { type TSchema, type TUnsafe } from "@sinclair/typebox";
+type StringEnumOptions<T extends readonly string[]> = {
+    description?: string;
+    default?: T[number];
+};
+/**
+ * Constructs a TypeBox schema describing a fixed list of allowed string values,
+ * serialised in the plain `{ type: "string", enum: [...] }` shape. Several
+ * backends (notably Google's generative APIs) reject the richer `anyOf` /
+ * `const` JSON-Schema output that TypeBox would otherwise generate from
+ * `Type.Union` of `Type.Literal`s, so this helper is the safe wire-format.
+ *
+ * @example
+ * const Color = StringEnum(["red", "green", "blue"], { description: "Pick a color" });
+ * type Color = Static<typeof Color>; // "red" | "green" | "blue"
+ */
+export declare function StringEnum<T extends readonly string[]>(values: T, options?: StringEnumOptions<T>): TUnsafe<T[number]>;
+/**
+ * Returns a freshly-cloned, plain-object copy of the given schema so that the
+ * downstream validator compiler can ingest it without choking on non-POJO
+ * inputs that providers or tooling sometimes hand us.
+ */
+export declare function normalizeSchemaForValidation(schema: TSchema): TSchema;
+export {};

package/dist/types/facade/ml/kit/validation.d.ts

@@ -0,0 +1,26 @@
+import type { Tool, ToolCall } from "../types.js";
+export interface ValidationDiagnostics {
+    cacheSize: number;
+    ajvEnabled: boolean;
+    isBrowserExtension: boolean;
+}
+/**
+ * Looks up the tool referenced by a tool call and checks the call's arguments
+ * against that tool's declared schema.
+ *
+ * @param tools The set of tools that may be invoked.
+ * @param toolCall A model-issued tool call to verify.
+ * @returns The arguments once they pass validation.
+ * @throws When no matching tool exists, or when the arguments do not conform.
+ */
+export declare function validateToolCall(tools: Tool[], toolCall: ToolCall): any;
+/**
+ * Checks a tool call's arguments against the schema attached to the tool.
+ *
+ * @param tool The tool whose schema describes the expected arguments.
+ * @param toolCall The model-issued call carrying the arguments to verify.
+ * @returns The arguments after validation (type coercion may apply).
+ * @throws With a human-readable summary when the arguments fail to validate.
+ */
+export declare function validateToolArguments(tool: Tool, toolCall: ToolCall): any;
+export declare function getValidationDiagnostics(): ValidationDiagnostics;

package/dist/types/facade/ml/models.d.ts

@@ -0,0 +1,41 @@
+import { MODELS } from "./models.generated.js";
+import type { Api, KnownProvider, Model, Usage } from "./types.js";
+export interface ModelSearchFilters {
+    provider?: KnownProvider | string;
+    api?: Api;
+    reasoning?: boolean;
+    supportsImageInput?: boolean;
+    nameIncludes?: string;
+}
+export interface CostEstimateInput {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+}
+export declare class ModelRegistry {
+    private readonly registry;
+    constructor(seedModels?: typeof MODELS);
+    registerCustomModel<TApi extends Api>(model: Model<TApi>): void;
+    loadCustomModels<TApi extends Api>(models: Model<TApi>[]): void;
+    getModel<TApi extends Api = Api>(provider: string, modelId: string): Model<TApi>;
+    tryGetModel<TApi extends Api = Api>(provider: string, modelId: string): Model<TApi> | undefined;
+    getProviders(): KnownProvider[];
+    getModels<TApi extends Api = Api>(provider: string): Model<TApi>[];
+    findModels(filters?: ModelSearchFilters): Model<Api>[];
+    estimateCost<TApi extends Api>(model: Model<TApi>, estimate: CostEstimateInput): Usage["cost"];
+    calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"];
+}
+export declare const modelRegistry: ModelRegistry;
+export declare function getModel<TApi extends Api = Api>(provider: string, modelId: string): Model<TApi>;
+export declare function tryGetModel<TApi extends Api = Api>(provider: string, modelId: string): Model<TApi> | undefined;
+export declare function getProviders(): KnownProvider[];
+export declare function getModels<TApi extends Api = Api>(provider: string): Model<TApi>[];
+export declare function findModels(filters?: ModelSearchFilters): Model<Api>[];
+export declare function estimateCost<TApi extends Api>(model: Model<TApi>, estimate: CostEstimateInput): Usage["cost"];
+export declare function registerCustomModel<TApi extends Api>(model: Model<TApi>): void;
+export declare function loadCustomModels<TApi extends Api>(models: Model<TApi>[]): void;
+export declare function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"];
+/** Reports whether the given model offers the "xhigh" reasoning level. */
+export declare function supportsXhigh<TApi extends Api>(model: Model<TApi>): boolean;
+export declare function modelsAreEqual<TApi extends Api>(a: Model<TApi> | null | undefined, b: Model<TApi> | null | undefined): boolean;