indusagi 0.13.5 → 0.13.7

package/dist/types/facade/ml/adapters/amazon-bedrock.d.ts

@@ -1,32 +0,0 @@
-import { type Message, type SystemContentBlock, type ToolConfiguration } from "@aws-sdk/client-bedrock-runtime";
-import type { Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions, ThinkingBudgets, ThinkingLevel } from "../types.js";
-export interface BedrockOptions extends StreamOptions {
-    region?: string;
-    profile?: string;
-    toolChoice?: "auto" | "any" | "none" | {
-        type: "tool";
-        name: string;
-    };
-    reasoning?: ThinkingLevel;
-    thinkingBudgets?: ThinkingBudgets;
-    interleavedThinking?: boolean;
-}
-export declare class BedrockRequestBuilder {
-    private readonly model;
-    private readonly context;
-    private readonly options;
-    constructor(model: Model<"bedrock-converse-stream">, context: Context, options: BedrockOptions);
-    build(): {
-        modelId: string;
-        messages: Message[];
-        system: SystemContentBlock[] | undefined;
-        inferenceConfig: {
-            maxTokens: number | undefined;
-            temperature: number | undefined;
-        };
-        toolConfig: ToolConfiguration | undefined;
-        additionalModelRequestFields: Record<string, any> | undefined;
-    };
-}
-export declare const streamBedrock: StreamFunction<"bedrock-converse-stream", BedrockOptions>;
-export declare const streamSimpleBedrock: StreamFunction<"bedrock-converse-stream", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/anthropic-retry.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/facade/ml/adapters/anthropic.d.ts

@@ -1,78 +0,0 @@
-import type { MessageCreateParamsStreaming } from "@anthropic-ai/sdk/resources/messages.js";
-import type { Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
-import { BaseStreamHandler } from "../kit/base-stream-handler.js";
-import { type ProviderLifecycleHooks } from "./simple-options.js";
-export interface AnthropicOptions extends StreamOptions {
-    thinkingEnabled?: boolean;
-    thinkingBudgetTokens?: number;
-    interleavedThinking?: boolean;
-    toolChoice?: "auto" | "any" | "none" | {
-        type: "tool";
-        name: string;
-    };
-}
-export interface AnthropicExecutionOptions {
-    hooks?: ProviderLifecycleHooks<MessageCreateParamsStreaming, unknown>;
-    retryPolicy?: {
-        maxAttempts?: number;
-        baseDelayMs?: number;
-    };
-}
-/**
- * Assembles the streaming request payload for the Anthropic Messages API.
- *
- * Acts as the single place that turns a generic model/context/options triple
- * into a concrete `MessageCreateParamsStreaming` object.
- */
-export declare class AnthropicRequestBuilder {
-    private readonly model;
-    private readonly context;
-    private readonly isOAuthToken;
-    private readonly options?;
-    constructor(model: Model<"anthropic-messages">, context: Context, isOAuthToken: boolean, options?: AnthropicOptions | undefined);
-    /**
-     * Produce the parameters passed to the Anthropic streaming endpoint.
-     *
-     * @returns The fully populated SDK streaming request.
-     */
-    build(): MessageCreateParamsStreaming;
-}
-/**
- * Stream handler tailored to Anthropic.
- *
- * Drives the Anthropic SDK stream and forwards normalized assistant events.
- */
-export declare class AnthropicStreamHandler extends BaseStreamHandler {
-    private readonly executeFn?;
-    constructor(executeFn?: (() => Promise<void>) | undefined);
-    /**
-     * Run the supplied executor, if any, to consume the Anthropic stream.
-     */
-    protected processStream(): Promise<void>;
-    /**
-     * Walk the raw SDK stream, handing each event to the supplied callback.
-     *
-     * @param anthropicStream - Raw async iterable produced by the Anthropic SDK.
-     * @param onEvent - Invoked once per streamed event.
-     */
-    process(anthropicStream: AsyncIterable<unknown>, onEvent: (event: any) => void): Promise<void>;
-}
-/**
- * Reads a `Retry-After` header off an Anthropic APIError and converts it to a
- * delay in milliseconds. The header is the integer-seconds form per the
- * Anthropic API; a missing/non-numeric value yields `null` so callers fall
- * back to exponential backoff.
- */
-export declare function parseAnthropicRetryAfterMs(error: unknown): number | null;
-/**
- * Classifies an Anthropic failure as worth retrying. Mirrors
- * `kit/provider-errors.ts:isRetryableError`: transient HTTP statuses (408/409/
- * 429/529/5xx) and an `overloaded_error` body are retryable; auth/validation
- * (401/403/4xx) are not. Generic errors fall back to a message sniff covering
- * network/timeout/overload conditions. The `_attempt` is accepted to satisfy
- * the RetryPolicy.shouldRetry contract but unused here (the loop already caps
- * attempts).
- */
-export declare function shouldRetryAnthropic(error: unknown, _attempt: number): boolean;
-export declare const streamAnthropic: StreamFunction<"anthropic-messages", AnthropicOptions>;
-export declare const streamSimpleAnthropic: StreamFunction<"anthropic-messages", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/azure-openai-responses.d.ts

@@ -1,14 +0,0 @@
-import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
-export interface AzureOpenAIResponsesOptions extends StreamOptions {
-    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
-    reasoningSummary?: "auto" | "detailed" | "concise" | null;
-    azureApiVersion?: string;
-    azureResourceName?: string;
-    azureBaseUrl?: string;
-    azureDeploymentName?: string;
-}
-/**
- * Streaming entry point for Azure OpenAI Responses deployments.
- */
-export declare const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses", AzureOpenAIResponsesOptions>;
-export declare const streamSimpleAzureOpenAIResponses: StreamFunction<"azure-openai-responses", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/google-shared.d.ts

@@ -1,99 +0,0 @@
-/**
- * Common building blocks used by both Google front-ends — the Generative AI
- * (Gemini) adapter and the Vertex AI adapter. Covers turning our messages and
- * tools into Google's shapes, mapping finish reasons back to our stop reasons,
- * and the bookkeeping around reasoning ("thought") signatures.
- */
-import { type Content, FinishReason, FunctionCallingConfigMode, type Part, type Schema } from "@google/genai";
-import type { Context, Model, StopReason, Tool } from "../types.js";
-import { type ProviderLifecycleHooks } from "./simple-options.js";
-type GoogleApiType = "google-generative-ai" | "google-vertex";
-export interface GoogleRequestExecutionOptions<TRequest = unknown, TResponse = unknown> {
-    hooks?: ProviderLifecycleHooks<TRequest, TResponse>;
-    retryPolicy?: {
-        maxAttempts?: number;
-        baseDelayMs?: number;
-    };
-}
-export declare function executeGoogleRequest<TRequest, TResponse>(request: TRequest, executor: () => Promise<TResponse>, options?: GoogleRequestExecutionOptions<TRequest, TResponse>): Promise<TResponse>;
-/**
- * Discrete reasoning intensities understood by Gemini. Every entry corresponds
- * one-to-one with a value of the Google SDK's ThinkingLevel enum.
- */
-export type GoogleThinkingLevel = "THINKING_LEVEL_UNSPECIFIED" | "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
-/**
- * The four reasoning efforts callers can request, ordered weakest to strongest.
- * Drawn from the internal ThinkingLevel set with the "xhigh" tier collapsed away.
- */
-export type ClampedReasoningEffort = "minimal" | "low" | "medium" | "high";
-/** The slice of a Model object the Gemini reasoning helpers actually consult. */
-type GeminiModelRef = {
-    id: string;
-};
-/**
- * Family buckets that decide how reasoning effort maps onto a request. Gemini 3
- * variants take a discrete level; everything else takes a token budget.
- */
-export type GeminiFamily = "gemini-3-pro" | "gemini-3-flash" | "default";
-/** Sort a model id into the Gemini family whose reasoning rules apply to it. */
-export declare function classifyGeminiFamily(modelId: string): GeminiFamily;
-/**
- * Pick the discrete Gemini thinking level for a given effort. The Gemini-3 Pro
- * family uses its coarser two-rung table; all other ids use the full four-rung
- * mapping.
- */
-export declare function selectGeminiThinkingLevel(effort: ClampedReasoningEffort, model: GeminiModelRef): GoogleThinkingLevel;
-/**
- * Resolve the thinking-token budget for a model/effort pair. A caller-supplied
- * override wins outright; otherwise the per-family default table is consulted,
- * and unrecognized families return -1 so the model sizes its own budget.
- */
-export declare function resolveGeminiThinkingBudget(model: GeminiModelRef, effort: ClampedReasoningEffort, customBudgets?: Partial<Record<ClampedReasoningEffort, number>>): number;
-/**
- * Distinguishes a reasoning fragment from a normal answer fragment: a Gemini
- * `Part` whose `thought` flag is set holds the model's internal reasoning.
- */
-export declare function isThinkingPart(part: Pick<Part, "thought" | "thoughtSignature">): boolean;
-/**
- * Keep whichever thought signature is freshest as chunks stream in: a new
- * non-empty value replaces the old one, otherwise the previous value stands.
- */
-export declare function retainThoughtSignature(existing: string | undefined, incoming: string | undefined): string | undefined;
-/**
- * Some models served through Google demand that every function call — and the
- * function response that answers it — carry an explicit correlation id. This
- * returns true for those model families.
- */
-export declare function requiresToolCallId(modelId: string): boolean;
-/**
- * Map our internal conversation history onto the `Content[]` array Gemini's
- * generate-content request expects.
- */
-export declare function convertMessages<T extends GoogleApiType>(model: Model<T>, context: Context): Content[];
-/**
- * Repackage our tool definitions into the nested function-declaration block
- * Gemini reads them from.
- */
-export declare function convertTools(tools: Tool[]): {
-    functionDeclarations: {
-        name: string;
-        description?: string;
-        parameters: Schema;
-    }[];
-}[] | undefined;
-/**
- * Resolve one of our tool-choice keywords to the matching Gemini
- * FunctionCallingConfigMode, defaulting to AUTO for anything unrecognized.
- */
-export declare function mapToolChoice(choice: string): FunctionCallingConfigMode;
-/**
- * Look up the unified StopReason for a Gemini FinishReason enum value, throwing
- * if the enum carries a value the table above does not cover.
- */
-export declare function mapStopReason(reason: FinishReason): StopReason;
-/**
- * Variant of the finish-reason lookup that takes the raw string seen in
- * deserialized API JSON, returning "error" for anything not explicitly listed.
- */
-export declare function mapStopReasonString(reason: string): StopReason;
-export {};

package/dist/types/facade/ml/adapters/google-vertex.d.ts

@@ -1,14 +0,0 @@
-import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
-import { type GoogleThinkingLevel } from "./google-shared.js";
-export interface GoogleVertexOptions extends StreamOptions {
-    toolChoice?: "auto" | "none" | "any";
-    thinking?: {
-        enabled: boolean;
-        budgetTokens?: number;
-        level?: GoogleThinkingLevel;
-    };
-    project?: string;
-    location?: string;
-}
-export declare const streamGoogleVertex: StreamFunction<"google-vertex", GoogleVertexOptions>;
-export declare const streamSimpleGoogleVertex: StreamFunction<"google-vertex", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/google.d.ts

@@ -1,15 +0,0 @@
-import { type ThinkingConfig } from "@google/genai";
-import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
-import { type GoogleThinkingLevel } from "./google-shared.js";
-export interface GoogleOptions extends StreamOptions {
-    toolChoice?: "auto" | "none" | "any";
-    thinking?: {
-        enabled: boolean;
-        budgetTokens?: number;
-        level?: GoogleThinkingLevel;
-        /** @internal already-computed thinking config, reused as-is when present */
-        _resolved?: ThinkingConfig;
-    };
-}
-export declare const streamGoogle: StreamFunction<"google-generative-ai", GoogleOptions>;
-export declare const streamSimpleGoogle: StreamFunction<"google-generative-ai", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/kimi.d.ts

@@ -1,21 +0,0 @@
-/**
- * Adapter for Moonshot AI's Kimi models.
- *
- * Two providers are handled here:
- *   - `kimi`        — the general Kimi API at https://api.kimi.moonshot.cn/v1
- *   - `kimi-coding` — the coding-focused Kimi Code endpoint (a paid tier)
- *
- * Both speak an OpenAI-compatible chat-completions protocol.
- */
-import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
-export interface KimiOptions extends StreamOptions {
-    reasoningLevel?: "none" | "low" | "medium" | "high";
-}
-/**
- * Streaming entry point for Kimi (OpenAI-compatible chat completions).
- */
-export declare const streamKimi: StreamFunction<"kimi-openai-compatible", KimiOptions>;
-/**
- * Convenience entry point that derives Kimi options from SimpleStreamOptions.
- */
-export declare const streamSimpleKimi: StreamFunction<"kimi-openai-compatible", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/mock.d.ts

@@ -1,9 +0,0 @@
-import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
-interface MockStreamOptions extends StreamOptions {
-    mockDelayMs?: number;
-    mockText?: string;
-    mockToolName?: string;
-}
-export declare const streamMock: StreamFunction<"mock-ai", MockStreamOptions>;
-export declare const streamSimpleMock: StreamFunction<"mock-ai", SimpleStreamOptions>;
-export {};

package/dist/types/facade/ml/adapters/nvidia.d.ts

@@ -1,12 +0,0 @@
-/**
- * Adapter for NVIDIA's hosted inference API.
- *
- * Endpoint: https://integrate.api.nvidia.com/v1 (OpenAI-compatible)
- * Credentials are read from the NVIDIA_API_KEY environment variable.
- */
-import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
-export interface NvidiaOptions extends StreamOptions {
-    topP?: number;
-}
-export declare const streamNvidia: StreamFunction<"nvidia-openai-compatible", NvidiaOptions>;
-export declare const streamSimpleNvidia: StreamFunction<"nvidia-openai-compatible", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/openai-codex-responses.d.ts

@@ -1,8 +0,0 @@
-import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
-export interface OpenAICodexResponsesOptions extends StreamOptions {
-    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
-    reasoningSummary?: "auto" | "concise" | "detailed" | "off" | "on" | null;
-    textVerbosity?: "low" | "medium" | "high";
-}
-export declare const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses", OpenAICodexResponsesOptions>;
-export declare const streamSimpleOpenAICodexResponses: StreamFunction<"openai-codex-responses", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/openai-completions.d.ts

@@ -1,24 +0,0 @@
-import type { ChatCompletionMessageParam } from "openai/resources/chat/completions.js";
-import type { Context, Model, OpenAICompletionsCompat, SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
-export interface OpenAICompletionsOptions extends StreamOptions {
-    toolChoice?: "auto" | "none" | "required" | {
-        type: "function";
-        function: {
-            name: string;
-        };
-    };
-    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
-    retryPolicy?: {
-        maxAttempts?: number;
-        baseDelayMs?: number;
-    };
-}
-export declare class OpenAICompatibilityAdapter {
-    private readonly model;
-    constructor(model: Model<"openai-completions">);
-    resolveCompat(): OpenAICompletionsCompat;
-    normalizeToolCallId(id: string): string;
-}
-export declare const streamOpenAICompletions: StreamFunction<"openai-completions", OpenAICompletionsOptions>;
-export declare const streamSimpleOpenAICompletions: StreamFunction<"openai-completions", SimpleStreamOptions>;
-export declare function convertMessages(model: Model<"openai-completions">, context: Context, compat: Required<OpenAICompletionsCompat>): ChatCompletionMessageParam[];

package/dist/types/facade/ml/adapters/openai-responses-shared.d.ts

@@ -1,25 +0,0 @@
-import type { Tool as OpenAITool, ResponseCreateParamsStreaming, ResponseInput, ResponseStreamEvent } from "openai/resources/responses/responses.js";
-import type { Api, AssistantMessage, Context, Model, Tool, Usage } from "../types.js";
-import type { AssistantMessageEventStream } from "../kit/event-stream.js";
-import { type ProviderLifecycleHooks } from "./simple-options.js";
-export interface OpenAIResponsesStreamOptions {
-    serviceTier?: ResponseCreateParamsStreaming["service_tier"];
-    applyServiceTierPricing?: (usage: Usage, serviceTier: ResponseCreateParamsStreaming["service_tier"] | undefined) => void;
-}
-export interface OpenAIRequestExecutionOptions<TRequest = unknown, TResponse = unknown> {
-    hooks?: ProviderLifecycleHooks<TRequest, TResponse>;
-    retryPolicy?: {
-        maxAttempts?: number;
-        baseDelayMs?: number;
-    };
-}
-export declare function executeOpenAIRequest<TRequest, TResponse>(request: TRequest, executor: () => Promise<TResponse>, options?: OpenAIRequestExecutionOptions<TRequest, TResponse>): Promise<TResponse>;
-export interface ConvertResponsesMessagesOptions {
-    includeSystemPrompt?: boolean;
-}
-export interface ConvertResponsesToolsOptions {
-    strict?: boolean | null;
-}
-export declare function convertResponsesMessages<TApi extends Api>(model: Model<TApi>, context: Context, allowedToolCallProviders: ReadonlySet<string>, options?: ConvertResponsesMessagesOptions): ResponseInput;
-export declare function convertResponsesTools(tools: Tool[], options?: ConvertResponsesToolsOptions): OpenAITool[];
-export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<ResponseStreamEvent>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: OpenAIResponsesStreamOptions): Promise<void>;

package/dist/types/facade/ml/adapters/openai-responses.d.ts

@@ -1,12 +0,0 @@
-import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
-import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
-export interface OpenAIResponsesOptions extends StreamOptions {
-    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
-    reasoningSummary?: "auto" | "detailed" | "concise" | null;
-    serviceTier?: ResponseCreateParamsStreaming["service_tier"];
-}
-/**
- * Streaming entry point for the OpenAI Responses API.
- */
-export declare const streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIResponsesOptions>;
-export declare const streamSimpleOpenAIResponses: StreamFunction<"openai-responses", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/openai-scaffold.d.ts

@@ -1,3 +0,0 @@
-import { type SimpleStreamOptions, type StreamFunction, type StreamOptions } from "../types.js";
-export declare const streamOpenAICompletionsScaffold: StreamFunction<"openai-completions", StreamOptions>;
-export declare const streamSimpleOpenAICompletionsScaffold: StreamFunction<"openai-completions", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/register-builtins.d.ts

@@ -1,2 +0,0 @@
-export declare function registerBuiltInApiProviders(): void;
-export declare function resetApiProviders(): void;

package/dist/types/facade/ml/adapters/simple-options.d.ts

@@ -1,39 +0,0 @@
-import type { Api, Model, SimpleStreamOptions, StreamOptions, ThinkingBudgets, ThinkingLevel } from "../types.js";
-export interface ProviderLifecycleHooks<TRequest = unknown, TResponse = unknown> {
-    onBeforeRequest?: (request: TRequest) => void | Promise<void>;
-    onAfterResponse?: (response: TResponse) => void | Promise<void>;
-    onError?: (error: unknown) => void | Promise<void>;
-}
-export interface RetryPolicy {
-    maxAttempts: number;
-    baseDelayMs: number;
-    maxDelayMs?: number;
-    /**
-     * When present, abort is checked between attempts and before each backoff
-     * sleep. A live request is short-circuited the moment its signal fires —
-     * but the presence of a signal no longer suppresses transient retries.
-     */
-    signal?: AbortSignal;
-    shouldRetry?: (error: unknown, attempt: number) => boolean;
-    /**
-     * Returns the server-requested cooldown (e.g. a parsed `Retry-After`
-     * header) in milliseconds, or `null` when the error carries no such hint.
-     * When provided, it takes priority over exponential backoff (still clamped
-     * by `maxDelayMs`).
-     */
-    getRetryAfterMs?: (error: unknown) => number | null;
-}
-export declare class SimpleOptionsProviderError extends Error {
-    readonly code: "rate_limit" | "timeout" | "network" | "validation" | "auth" | "unknown";
-    readonly cause?: unknown | undefined;
-    constructor(message: string, code?: "rate_limit" | "timeout" | "network" | "validation" | "auth" | "unknown", cause?: unknown | undefined);
-}
-export declare function normalizeProviderError(error: unknown): SimpleOptionsProviderError;
-export declare function executeWithRetry<T>(operation: () => Promise<T>, policy: RetryPolicy): Promise<T>;
-export declare function buildBaseOptions(model: Model<Api>, options?: SimpleStreamOptions, apiKey?: string): StreamOptions;
-export declare function clampReasoning(effort: ThinkingLevel | undefined): Exclude<ThinkingLevel, "xhigh"> | undefined;
-export declare function mapThinkingLevel(level: ThinkingLevel | undefined, provider?: "supports-xhigh" | "clamp-xhigh"): ThinkingLevel | Exclude<ThinkingLevel, "xhigh"> | undefined;
-export declare function adjustMaxTokensForThinking(baseMaxTokens: number, modelMaxTokens: number, reasoningLevel: ThinkingLevel, customBudgets?: ThinkingBudgets): {
-    maxTokens: number;
-    thinkingBudget: number;
-};

package/dist/types/facade/ml/adapters/simple-options.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/facade/ml/adapters/transform-messages.d.ts

@@ -1,23 +0,0 @@
-import type { Api, AssistantMessage, Message, Model } from "../types.js";
-export interface MessageTransformContext<TApi extends Api> {
-    model: Model<TApi>;
-    normalizeToolCallId?: (id: string, model: Model<TApi>, source: AssistantMessage) => string;
-    debug?: (stage: string, details?: unknown) => void;
-}
-export interface MessageTransformation<TApi extends Api> {
-    name: string;
-    apply(messages: Message[], context: MessageTransformContext<TApi>): Message[];
-}
-export declare class MessageTransformationPipeline<TApi extends Api> {
-    private transformations;
-    addTransformation(transformation: MessageTransformation<TApi>): this;
-    transform(messages: Message[], context: MessageTransformContext<TApi>): Message[];
-}
-/**
- * Push a conversation through the shared transformation pipeline so it can be
- * sent to any provider safely. Tool-call identifiers are the tricky part: some
- * providers hand back long ids that include characters like `|`, while others
- * only accept short word-character ids. The `normalizeToolCallId` callback
- * bridges those formats whenever messages cross a model or provider boundary.
- */
-export declare function transformMessages<TApi extends Api>(messages: Message[], model: Model<TApi>, normalizeToolCallId?: (id: string, model: Model<TApi>, source: AssistantMessage) => string): Message[];

package/dist/types/facade/ml/api-registry.d.ts

@@ -1,49 +0,0 @@
-import type { Api, AssistantMessageEventStream, Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from "./types.js";
-export type ApiStreamFunction = (model: Model<Api>, context: Context, options?: StreamOptions) => AssistantMessageEventStream;
-export type ApiStreamSimpleFunction = (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
-export interface ApiProvider<TApi extends Api = Api, TOptions extends StreamOptions = StreamOptions> {
-    api: TApi;
-    stream: StreamFunction<TApi, TOptions>;
-    streamSimple: StreamFunction<TApi, SimpleStreamOptions>;
-}
-export interface ApiProviderMetadata {
-    sourceId?: string;
-    version?: string;
-    enabled: boolean;
-    registeredAt: number;
-    updatedAt: number;
-}
-export interface RegisteredApiProvider {
-    provider: ApiProviderInternal;
-    metadata: ApiProviderMetadata;
-}
-export interface ApiProviderInternal {
-    api: Api;
-    stream: ApiStreamFunction;
-    streamSimple: ApiStreamSimpleFunction;
-}
-export interface RegisterApiProviderOptions {
-    sourceId?: string;
-    version?: string;
-    enabled?: boolean;
-}
-export declare class ProviderRegistry {
-    private readonly registry;
-    register<TApi extends Api, TOptions extends StreamOptions>(provider: ApiProvider<TApi, TOptions>, options?: RegisterApiProviderOptions): void;
-    get(api: Api): ApiProviderInternal | undefined;
-    getWithMetadata(api: Api): RegisteredApiProvider | undefined;
-    list(includeDisabled?: boolean): ApiProviderInternal[];
-    enable(api: Api): boolean;
-    disable(api: Api): boolean;
-    unregisterBySource(sourceId: string): void;
-    clear(): void;
-}
-export declare const providerRegistry: ProviderRegistry;
-export declare function registerApiProvider<TApi extends Api, TOptions extends StreamOptions>(provider: ApiProvider<TApi, TOptions>, sourceIdOrOptions?: string | RegisterApiProviderOptions): void;
-export declare function getApiProvider(api: Api): ApiProviderInternal | undefined;
-export declare function getApiProviderWithMetadata(api: Api): RegisteredApiProvider | undefined;
-export declare function getApiProviders(includeDisabled?: boolean): ApiProviderInternal[];
-export declare function enableApiProvider(api: Api): boolean;
-export declare function disableApiProvider(api: Api): boolean;
-export declare function unregisterApiProviders(sourceId: string): void;
-export declare function clearApiProviders(): void;

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

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/types/facade/ml/env-api-keys.d.ts

@@ -1,19 +0,0 @@
-import type { KnownProvider } from "./types.js";
-export interface EnvApiKeyResolution {
-    provider: string;
-    apiKey?: string;
-    isAuthenticatedMarker: boolean;
-    isValid: boolean;
-}
-/**
- * Resolve a provider's credential from the process environment.
- *
- * Most providers map to a single env var (such as OPENAI_API_KEY); a few use
- * custom logic (Bedrock and Vertex return the SDK marker, Copilot/Anthropic
- * accept token fallbacks). Returns undefined when nothing usable is configured.
- */
-export declare function getEnvApiKey(provider: KnownProvider): string | undefined;
-export declare function getEnvApiKey(provider: string): string | undefined;
-export declare function isLikelyValidApiKey(value: string | undefined): boolean;
-export declare function resolveEnvApiKey(provider: KnownProvider | string): EnvApiKeyResolution;
-export declare function rotateEnvApiKey(provider: KnownProvider | string, fallback?: string): string | undefined;

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

@@ -1,27 +0,0 @@
-export * from "./api-registry.js";
-export * from "./env-api-keys.js";
-export * from "./models.generated.js";
-export * from "./models.js";
-export * from "./adapters/mock.js";
-export * from "./adapters/openai-scaffold.js";
-export * from "./adapters/anthropic.js";
-export * from "./adapters/azure-openai-responses.js";
-export * from "./adapters/google.js";
-export * from "./adapters/google-vertex.js";
-export * from "./adapters/openai-completions.js";
-export * from "./adapters/openai-responses.js";
-export * from "./adapters/openai-responses-shared.js";
-export * from "./adapters/openai-codex-responses.js";
-export * from "./adapters/amazon-bedrock.js";
-export * from "./adapters/kimi.js";
-export * from "./adapters/nvidia.js";
-export { executeGoogleRequest, convertTools, isThinkingPart, retainThoughtSignature, requiresToolCallId, mapToolChoice, mapStopReason, mapStopReasonString, type GoogleThinkingLevel, } from "./adapters/google-shared.js";
-export * from "./adapters/simple-options.js";
-export * from "./adapters/register-builtins.js";
-export * from "./stream.js";
-export * from "./types.js";
-export * from "./kit/index.js";
-export * from "./kit/auth/index.js";
-export * from "./kit/overflow.js";
-export * from "./kit/typebox-helpers.js";
-export * from "./kit/validation.js";

package/dist/types/facade/ml/kit/auth/anthropic.d.ts

@@ -1,17 +0,0 @@
-/**
- * Sign-in flow for Anthropic accounts (Claude Pro / Max) over OAuth + PKCE.
- */
-import type { OAuthCredentials, OAuthProviderInterface } from "./types.js";
-/**
- * Walk a user through Anthropic OAuth sign-in.
- *
- * @param onAuthUrl - Invoked with the authorization URL so the caller can open it.
- * @param onPromptCode - Invoked to collect the authorization code from the user.
- */
-export declare function loginAnthropic(onAuthUrl: (url: string) => void, onPromptCode: () => Promise<string>): Promise<OAuthCredentials>;
-/**
- * Exchange an Anthropic refresh token for a renewed credential.
- */
-export declare function refreshAnthropicToken(refreshToken: string): Promise<OAuthCredentials>;
-export declare function isAnthropicOAuthCredentialsValid(credentials: OAuthCredentials): boolean;
-export declare const anthropicOAuthProvider: OAuthProviderInterface;

package/dist/types/facade/ml/kit/auth/github-copilot.d.ts

@@ -1,22 +0,0 @@
-/**
- * GitHub Copilot sign-in via the OAuth device-authorization grant.
- */
-import type { OAuthCredentials, OAuthProviderInterface } from "./types.js";
-type LoginOptions = {
-    onAuth: (url: string, instructions?: string) => void;
-    onPrompt: (prompt: {
-        message: string;
-        placeholder?: string;
-        allowEmpty?: boolean;
-    }) => Promise<string>;
-    onProgress?: (message: string) => void;
-    signal?: AbortSignal;
-};
-export declare function normalizeDomain(raw: string): string | null;
-/** Module-level entry point for resolving the Copilot API base URL. */
-export declare function getGitHubCopilotBaseUrl(token?: string, enterpriseDomain?: string): string;
-export declare function refreshGitHubCopilotToken(refreshToken: string, enterpriseDomain?: string): Promise<OAuthCredentials>;
-export declare function loginGitHubCopilot(options: LoginOptions): Promise<OAuthCredentials>;
-export declare function isGitHubCopilotOAuthCredentialsValid(credentials: OAuthCredentials): boolean;
-export declare const githubCopilotOAuthProvider: OAuthProviderInterface;
-export {};