indusagi 0.13.5 → 0.13.7

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

@@ -1,46 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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;