@cerebriline/core 4.100.240

package/dist/services/llms/provider-settings.d.ts

@@ -0,0 +1,420 @@
+import * as Llms from "@cerebriline/llms";
+import { z } from "zod";
+import { type ProviderDefaults } from "./provider-defaults";
+export type ModelInfo = Llms.ModelInfo;
+export type ProviderClient = Llms.ProviderClient;
+export type ProviderProtocol = Llms.ProviderProtocol;
+export type ProviderId = Llms.ProviderId;
+export type ProviderCapability = Llms.ProviderCapability;
+export type ProviderConfig = Llms.ProviderConfig;
+export type BuiltInProviderId = Llms.BuiltInProviderId;
+export declare const BUILT_IN_PROVIDER: typeof Llms.BUILT_IN_PROVIDER;
+export declare const BUILT_IN_PROVIDER_IDS: readonly Llms.BuiltInProviderId[];
+export declare const isBuiltInProviderId: typeof Llms.isBuiltInProviderId;
+export declare const normalizeProviderId: typeof Llms.normalizeProviderId;
+export type ProviderDefaultsConfig = ProviderDefaults;
+export declare const ProviderIdSchema: z.ZodString;
+export declare const ProviderProtocolSchema: z.ZodEnum<{
+    "openai-responses": "openai-responses";
+    anthropic: "anthropic";
+    gemini: "gemini";
+    "openai-r1": "openai-r1";
+    "ai-sdk": "ai-sdk";
+    "openai-chat": "openai-chat";
+}>;
+export declare const ProviderClientSchema: z.ZodEnum<{
+    custom: "custom";
+    fetch: "fetch";
+    anthropic: "anthropic";
+    "openai-compatible": "openai-compatible";
+    gemini: "gemini";
+    vertex: "vertex";
+    bedrock: "bedrock";
+    openai: "openai";
+    "openai-r1": "openai-r1";
+    "ai-sdk": "ai-sdk";
+    "ai-sdk-community": "ai-sdk-community";
+}>;
+export declare const AuthSettingsSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    accountId: z.ZodOptional<z.ZodString>;
+    organizationId: z.ZodOptional<z.ZodString>;
+    organizationName: z.ZodOptional<z.ZodString>;
+    memberId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type AuthSettings = z.infer<typeof AuthSettingsSchema>;
+export declare const ReasoningSettingsSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
+    budgetTokens: z.ZodOptional<z.ZodNumber>;
+    reasoningHistory: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        last: "last";
+        auto: "auto";
+        all: "all";
+    }>>;
+    reasoningInline: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ReasoningSettings = z.infer<typeof ReasoningSettingsSchema>;
+/**
+ * Sampling parameters stored per provider.
+ *
+ * Every field is optional and an absent one is not a zero: it means the request
+ * will not mention that parameter, leaving whatever the model was built with in
+ * force. A local model carries a sampler in its Modelfile — often one measured
+ * against that quant — and a client that sent a complete set on every request
+ * would silently replace it.
+ *
+ * `repeatLastN`, `numPredict`, `numKeep` and `numGpu` accept negative values
+ * because Ollama gives -1 a meaning there (whole context / unlimited / decide
+ * for me), and
+ * `temperature` and `seed` accept zero because zero is a real setting.
+ */
+export declare const SamplingSettingsSchema: z.ZodObject<{
+    temperature: z.ZodOptional<z.ZodNumber>;
+    topK: z.ZodOptional<z.ZodNumber>;
+    topP: z.ZodOptional<z.ZodNumber>;
+    minP: z.ZodOptional<z.ZodNumber>;
+    typicalP: z.ZodOptional<z.ZodNumber>;
+    repeatLastN: z.ZodOptional<z.ZodNumber>;
+    repeatPenalty: z.ZodOptional<z.ZodNumber>;
+    presencePenalty: z.ZodOptional<z.ZodNumber>;
+    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    numPredict: z.ZodOptional<z.ZodNumber>;
+    numKeep: z.ZodOptional<z.ZodNumber>;
+    numGpu: z.ZodOptional<z.ZodNumber>;
+    stop: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    thinkBudget: z.ZodOptional<z.ZodString>;
+    thinkBudgetMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SamplingSettings = z.infer<typeof SamplingSettingsSchema>;
+/**
+ * opencoti's PolyKV control plane, as a profile configures it.
+ *
+ * A section of its own rather than loose fields because it is one arrangement
+ * with one engine: the pool tree, the admission policy the engine enforces on
+ * this profile's behalf, and how this client behaves when the engine says no.
+ * All of it is inert unless `enabled`, and inert anyway on a server launched
+ * without `--polykv-max-pools`.
+ */
+/**
+ * The tools a configuration withholds from its sessions.
+ *
+ * A deny list rather than an allow list: the tool set grows, and an allow list
+ * stored today would withhold every tool added after it from every profile
+ * that already exists. Naming what to drop means a new tool arrives switched
+ * on, which someone can see in the panel and correct.
+ *
+ * Held per configuration because the reason to drop a tool is the window it
+ * has to fit in: the schemas are paid before a single message exists -- 21,000
+ * to 24,000 tokens of a 65,536-token window, measured -- so a profile on a
+ * small local model and one on a 400k cloud model want opposite answers.
+ */
+export declare const ToolSelectionSchema: z.ZodObject<{
+    disabled: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    readLimitEnabled: z.ZodOptional<z.ZodBoolean>;
+    readLimitChars: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ToolSelection = z.infer<typeof ToolSelectionSchema>;
+export declare const PolykvSettingsSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    pinPrefix: z.ZodOptional<z.ZodBoolean>;
+    ephemeral: z.ZodOptional<z.ZodBoolean>;
+    compactionPressureThreshold: z.ZodOptional<z.ZodNumber>;
+    targetTpsPerSession: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        advisory: "advisory";
+        enforced: "enforced";
+    }>>;
+    onSaturation: z.ZodOptional<z.ZodEnum<{
+        warn: "warn";
+        reject: "reject";
+    }>>;
+    guaranteeMinSessions: z.ZodOptional<z.ZodNumber>;
+    settleTokens: z.ZodOptional<z.ZodNumber>;
+    settleMaxMs: z.ZodOptional<z.ZodNumber>;
+    prefillMaxSlots: z.ZodOptional<z.ZodNumber>;
+    overcommit: z.ZodOptional<z.ZodBoolean>;
+    swarm: z.ZodOptional<z.ZodBoolean>;
+    maxRetryAfterMs: z.ZodOptional<z.ZodNumber>;
+    dynamicContextSize: z.ZodOptional<z.ZodBoolean>;
+    continuationCompaction: z.ZodOptional<z.ZodBoolean>;
+    contextFloor: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PolykvSettings = z.infer<typeof PolykvSettingsSchema>;
+export declare const AwsSettingsSchema: z.ZodObject<{
+    accessKey: z.ZodOptional<z.ZodString>;
+    secretKey: z.ZodOptional<z.ZodString>;
+    sessionToken: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    profile: z.ZodOptional<z.ZodString>;
+    authentication: z.ZodOptional<z.ZodEnum<{
+        "api-key": "api-key";
+        profile: "profile";
+        iam: "iam";
+        apikey: "apikey";
+    }>>;
+    usePromptCache: z.ZodOptional<z.ZodBoolean>;
+    useCrossRegionInference: z.ZodOptional<z.ZodBoolean>;
+    useGlobalInference: z.ZodOptional<z.ZodBoolean>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    customModelBaseId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AwsSettings = z.infer<typeof AwsSettingsSchema>;
+export declare const GcpSettingsSchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GcpSettings = z.infer<typeof GcpSettingsSchema>;
+export declare const AzureSettingsSchema: z.ZodObject<{
+    apiVersion: z.ZodOptional<z.ZodString>;
+    useIdentity: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AzureSettings = z.infer<typeof AzureSettingsSchema>;
+export declare const SapSettingsSchema: z.ZodObject<{
+    clientId: z.ZodOptional<z.ZodString>;
+    clientSecret: z.ZodOptional<z.ZodString>;
+    tokenUrl: z.ZodOptional<z.ZodString>;
+    resourceGroup: z.ZodOptional<z.ZodString>;
+    deploymentId: z.ZodOptional<z.ZodString>;
+    useOrchestrationMode: z.ZodOptional<z.ZodBoolean>;
+    api: z.ZodOptional<z.ZodEnum<{
+        orchestration: "orchestration";
+        "foundation-models": "foundation-models";
+    }>>;
+    defaultSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type SapSettings = z.infer<typeof SapSettingsSchema>;
+export declare const OcaSettingsSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        internal: "internal";
+        external: "external";
+    }>>;
+    usePromptCache: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OcaSettings = z.infer<typeof OcaSettingsSchema>;
+export declare const ModelCatalogSettingsSchema: z.ZodObject<{
+    loadLatestOnInit: z.ZodOptional<z.ZodBoolean>;
+    loadPrivateOnAuth: z.ZodOptional<z.ZodBoolean>;
+    url: z.ZodOptional<z.ZodString>;
+    cacheTtlMs: z.ZodOptional<z.ZodNumber>;
+    failOnError: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ModelCatalogSettings = z.infer<typeof ModelCatalogSettingsSchema>;
+export type ModelCatalogConfig = ModelCatalogSettings;
+export declare const ProviderSettingsSchema: z.ZodObject<{
+    provider: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+    auth: z.ZodOptional<z.ZodObject<{
+        apiKey: z.ZodOptional<z.ZodString>;
+        accessToken: z.ZodOptional<z.ZodString>;
+        refreshToken: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodNumber>;
+        accountId: z.ZodOptional<z.ZodString>;
+        organizationId: z.ZodOptional<z.ZodString>;
+        organizationName: z.ZodOptional<z.ZodString>;
+        memberId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    model: z.ZodOptional<z.ZodString>;
+    protocol: z.ZodOptional<z.ZodEnum<{
+        "openai-responses": "openai-responses";
+        anthropic: "anthropic";
+        gemini: "gemini";
+        "openai-r1": "openai-r1";
+        "ai-sdk": "ai-sdk";
+        "openai-chat": "openai-chat";
+    }>>;
+    client: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        fetch: "fetch";
+        anthropic: "anthropic";
+        "openai-compatible": "openai-compatible";
+        gemini: "gemini";
+        vertex: "vertex";
+        bedrock: "bedrock";
+        openai: "openai";
+        "openai-r1": "openai-r1";
+        "ai-sdk": "ai-sdk";
+        "ai-sdk-community": "ai-sdk-community";
+    }>>;
+    routingProviderId: z.ZodOptional<z.ZodString>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    contextWindow: z.ZodOptional<z.ZodNumber>;
+    parallelSessions: z.ZodOptional<z.ZodNumber>;
+    outputBudget: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            manual: "manual";
+        }>>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    maxToolResultChars: z.ZodOptional<z.ZodNumber>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    reasoning: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        budgetTokens: z.ZodOptional<z.ZodNumber>;
+        reasoningHistory: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            last: "last";
+            auto: "auto";
+            all: "all";
+        }>>;
+        reasoningInline: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    sampling: z.ZodOptional<z.ZodObject<{
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        minP: z.ZodOptional<z.ZodNumber>;
+        typicalP: z.ZodOptional<z.ZodNumber>;
+        repeatLastN: z.ZodOptional<z.ZodNumber>;
+        repeatPenalty: z.ZodOptional<z.ZodNumber>;
+        presencePenalty: z.ZodOptional<z.ZodNumber>;
+        frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+        numPredict: z.ZodOptional<z.ZodNumber>;
+        numKeep: z.ZodOptional<z.ZodNumber>;
+        numGpu: z.ZodOptional<z.ZodNumber>;
+        stop: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        thinkBudget: z.ZodOptional<z.ZodString>;
+        thinkBudgetMessage: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    polykv: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        pinPrefix: z.ZodOptional<z.ZodBoolean>;
+        ephemeral: z.ZodOptional<z.ZodBoolean>;
+        compactionPressureThreshold: z.ZodOptional<z.ZodNumber>;
+        targetTpsPerSession: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            advisory: "advisory";
+            enforced: "enforced";
+        }>>;
+        onSaturation: z.ZodOptional<z.ZodEnum<{
+            warn: "warn";
+            reject: "reject";
+        }>>;
+        guaranteeMinSessions: z.ZodOptional<z.ZodNumber>;
+        settleTokens: z.ZodOptional<z.ZodNumber>;
+        settleMaxMs: z.ZodOptional<z.ZodNumber>;
+        prefillMaxSlots: z.ZodOptional<z.ZodNumber>;
+        overcommit: z.ZodOptional<z.ZodBoolean>;
+        swarm: z.ZodOptional<z.ZodBoolean>;
+        maxRetryAfterMs: z.ZodOptional<z.ZodNumber>;
+        dynamicContextSize: z.ZodOptional<z.ZodBoolean>;
+        continuationCompaction: z.ZodOptional<z.ZodBoolean>;
+        contextFloor: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    tools: z.ZodOptional<z.ZodObject<{
+        disabled: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        readLimitEnabled: z.ZodOptional<z.ZodBoolean>;
+        readLimitChars: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    aws: z.ZodOptional<z.ZodObject<{
+        accessKey: z.ZodOptional<z.ZodString>;
+        secretKey: z.ZodOptional<z.ZodString>;
+        sessionToken: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        profile: z.ZodOptional<z.ZodString>;
+        authentication: z.ZodOptional<z.ZodEnum<{
+            "api-key": "api-key";
+            profile: "profile";
+            iam: "iam";
+            apikey: "apikey";
+        }>>;
+        usePromptCache: z.ZodOptional<z.ZodBoolean>;
+        useCrossRegionInference: z.ZodOptional<z.ZodBoolean>;
+        useGlobalInference: z.ZodOptional<z.ZodBoolean>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        customModelBaseId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    gcp: z.ZodOptional<z.ZodObject<{
+        projectId: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    azure: z.ZodOptional<z.ZodObject<{
+        apiVersion: z.ZodOptional<z.ZodString>;
+        useIdentity: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    sap: z.ZodOptional<z.ZodObject<{
+        clientId: z.ZodOptional<z.ZodString>;
+        clientSecret: z.ZodOptional<z.ZodString>;
+        tokenUrl: z.ZodOptional<z.ZodString>;
+        resourceGroup: z.ZodOptional<z.ZodString>;
+        deploymentId: z.ZodOptional<z.ZodString>;
+        useOrchestrationMode: z.ZodOptional<z.ZodBoolean>;
+        api: z.ZodOptional<z.ZodEnum<{
+            orchestration: "orchestration";
+            "foundation-models": "foundation-models";
+        }>>;
+        defaultSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    oca: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            internal: "internal";
+            external: "external";
+        }>>;
+        usePromptCache: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    region: z.ZodOptional<z.ZodString>;
+    apiLine: z.ZodOptional<z.ZodEnum<{
+        china: "china";
+        international: "international";
+    }>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        vision: "vision";
+        reasoning: "reasoning";
+        tools: "tools";
+        streaming: "streaming";
+        "prompt-cache": "prompt-cache";
+        "computer-use": "computer-use";
+        oauth: "oauth";
+        popular: "popular";
+    }>>>;
+    modelCatalog: z.ZodOptional<z.ZodObject<{
+        loadLatestOnInit: z.ZodOptional<z.ZodBoolean>;
+        loadPrivateOnAuth: z.ZodOptional<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodString>;
+        cacheTtlMs: z.ZodOptional<z.ZodNumber>;
+        failOnError: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProviderSettings = z.infer<typeof ProviderSettingsSchema>;
+export interface ToProviderConfigOptions {
+    includeKnownModels?: boolean;
+}
+export declare function parseSettings(input: unknown): ProviderSettings;
+export declare function safeParseSettings(input: unknown): ReturnType<typeof ProviderSettingsSchema.safeParse>;
+export declare function toProviderConfig(settings: ProviderSettings, options?: ToProviderConfigOptions): ProviderConfig;
+export declare function createProviderConfig(input: unknown): ProviderConfig;
+export declare function safeCreateProviderConfig(input: unknown): {
+    success: true;
+    config: ProviderConfig;
+} | {
+    success: false;
+    error: z.ZodError;
+};

package/dist/services/llms/runtime-config.d.ts

@@ -0,0 +1,3 @@
+import type { LlmsConfig } from "./runtime-types";
+export declare function defineLlmsConfig(config: LlmsConfig): LlmsConfig;
+export declare function loadLlmsConfigFromFile(configPath: string): Promise<LlmsConfig>;

package/dist/services/llms/runtime-registry.d.ts

@@ -0,0 +1,19 @@
+import type { ApiHandler } from "@cerebriline/llms";
+import type { BuiltInProviderSummary, CreateHandlerInput, LlmsConfig, LlmsSdk, RegisterBuiltinProviderInput, RegisteredProviderSummary, RegisterModelInput, RegisterProviderInput } from "./runtime-types";
+export declare class DefaultLlmsSdk implements LlmsSdk {
+    private readonly configuredProviders;
+    constructor(config: LlmsConfig);
+    createHandler(input: CreateHandlerInput): ApiHandler;
+    createHandlerAsync(input: CreateHandlerInput): Promise<ApiHandler>;
+    registerProvider(input: RegisterProviderInput): void;
+    registerBuiltinProvider(input: RegisterBuiltinProviderInput): void;
+    registerModel(input: RegisterModelInput): void;
+    getProviders(): RegisteredProviderSummary[];
+    getBuiltInProviderIds(): import("@cerebriline/llms").BuiltInProviderId[];
+    getBuiltInProviders(): Promise<BuiltInProviderSummary[]>;
+    getModels(providerId: string): string[];
+    isProviderConfigured(providerId: string): boolean;
+    isModelConfigured(providerId: string, modelId: string): boolean;
+    private applyConfig;
+}
+export declare function createLlmsSdk(config: LlmsConfig): LlmsSdk;

package/dist/services/llms/runtime-types.d.ts

@@ -0,0 +1,84 @@
+import type { ApiHandler, BuiltInProviderId, HandlerFactory, LazyHandlerFactory, ModelCollection, ModelInfo, CatalogProviderCapability as ModelProviderCapability, ProviderClient, ProviderConfig, ProviderInfo, ProviderProtocol } from "@cerebriline/llms";
+import type { ProviderCapability } from "./provider-settings";
+export type ProviderConfigDefaults = Omit<ProviderConfig, "providerId" | "modelId">;
+export interface ProviderSelectionConfig {
+    id: string;
+    models: string[];
+    defaultModel?: string;
+    builtinProviderId?: BuiltInProviderId;
+    apiKey?: string;
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    capabilities?: ProviderCapability[];
+    settings?: ProviderConfigDefaults;
+}
+export interface AdditionalModelConfig {
+    providerId: string;
+    modelId: string;
+    info: ModelInfo;
+}
+export interface CustomProviderConfig {
+    collection: ModelCollection;
+    defaults?: ProviderConfigDefaults;
+    handlerFactory?: HandlerFactory;
+    asyncHandlerFactory?: LazyHandlerFactory;
+}
+export interface LlmsConfig {
+    providers: ProviderSelectionConfig[];
+    models?: AdditionalModelConfig[];
+    customProviders?: CustomProviderConfig[];
+}
+export interface CreateHandlerInput {
+    providerId: string;
+    modelId?: string;
+    overrides?: ProviderConfigDefaults;
+}
+export interface RegisteredProviderSummary {
+    id: string;
+    models: string[];
+    defaultModel: string;
+}
+export interface BuiltInProviderSummary extends Pick<ProviderInfo, "id" | "name" | "description" | "protocol" | "baseUrl" | "capabilities" | "env"> {
+    models: string[];
+    defaultModel: string;
+    modelCount: number;
+}
+export interface RegisterBuiltinProviderInput {
+    id: string;
+    builtinProviderId: BuiltInProviderId;
+    models: Record<string, ModelInfo>;
+    name?: string;
+    description?: string;
+    protocol?: ProviderProtocol;
+    baseUrl?: string;
+    client?: ProviderClient;
+    capabilities?: ModelProviderCapability[];
+    env?: string[];
+    defaultModel?: string;
+    defaults?: ProviderConfigDefaults;
+    exposeModels?: string[];
+}
+export interface RegisterProviderInput extends CustomProviderConfig {
+    exposeModels?: string[];
+    defaultModel?: string;
+}
+export interface RegisterModelInput {
+    providerId: string;
+    modelId: string;
+    info: ModelInfo;
+}
+export interface LlmsSdk {
+    createHandler(input: CreateHandlerInput): ApiHandler;
+    createHandlerAsync(input: CreateHandlerInput): Promise<ApiHandler>;
+    registerProvider(input: RegisterProviderInput): void;
+    registerBuiltinProvider(input: RegisterBuiltinProviderInput): void;
+    registerModel(input: RegisterModelInput): void;
+    getProviders(): RegisteredProviderSummary[];
+    getBuiltInProviderIds(): BuiltInProviderId[];
+    getBuiltInProviders(): Promise<BuiltInProviderSummary[]>;
+    getModels(providerId: string): string[];
+    isProviderConfigured(providerId: string): boolean;
+    isModelConfigured(providerId: string, modelId: string): boolean;
+}

package/dist/services/llms/session-budget.d.ts

@@ -0,0 +1,88 @@
+/**
+ * One session's output cap and thinking allowance, for every host.
+ *
+ * The VS Code factory resolved these for itself and the CLI did not, so at one
+ * commit the two sent different numbers for the same model: on a 196,608-token
+ * Ollama window the plugin asked for 96,000 tokens a turn (three quarters of
+ * the window, under the ceiling) and 24,000 of thinking at `medium`, while the
+ * CLI -- and so every harness run -- fell through to the gateway's flat share,
+ * 49,152 and 12,288. A test harness that thinks on half the plugin's budget is
+ * not measuring the plugin, and a change tuned on one misleads the other. So
+ * the rule lives here and both hosts call it.
+ *
+ * The order is the factory's, verbatim:
+ *  - the cap is a configured `num_predict`, then a per-turn override, then a
+ *    manual budget, then `auto` against the session's window, then the
+ *    gateway's own default;
+ *  - thinking is asked of the server on Ollama, which resolves a level itself,
+ *    and computed from the same table on a llama.cpp server, which takes an
+ *    absolute count;
+ *  - the budget message is the configured one, then the model's own.
+ */
+import { type OutputBudgetMode } from "@cerebriline/shared";
+export type SessionThinkingEngine = "ollama" | "llamacpp";
+/**
+ * Engines that take a per-turn thinking budget. Ollama resolves one from a
+ * level; a llama.cpp server -- opencoti included -- takes
+ * `reasoning_budget_tokens`, an absolute count.
+ */
+export declare function sessionThinkingEngine(providerId: string): SessionThinkingEngine | undefined;
+export interface SessionOutputCapInput {
+    /** `sampling.numPredict`: what goes on the wire ahead of anything else. */
+    configuredNumPredict?: number;
+    /** A per-turn cap the session or the model override set. */
+    maxTokensPerTurn?: number;
+    outputBudget?: {
+        mode?: OutputBudgetMode;
+        maxTokens?: number;
+    };
+    /** The session's one window: configured, then declared, then catalog. */
+    contextWindow?: number;
+    /** What the model says it can emit, when the catalog knows. */
+    modelMaxOutputTokens?: number;
+}
+/** The per-turn cap: what the prompt states and the server truncates at. */
+export declare function resolveSessionOutputCap(input: SessionOutputCapInput): number;
+export interface SessionThinkingInput {
+    providerId: string;
+    modelId: string | undefined;
+    baseUrl: string | undefined;
+    /** `false` is thinking switched off; anything else leaves it to the level. */
+    thinking?: boolean;
+    reasoningEffort?: string;
+    /** `sampling.thinkBudget`: a level or a bare count, llama.cpp only. */
+    configuredThinkBudget?: string;
+    configuredNumPredict?: number;
+    outputCap: number;
+    contextWindow: number | undefined;
+    fetchImpl: typeof fetch;
+    /**
+     * How Ollama is asked, when a host has its own transport (the extension's
+     * proxy-aware fetch and retry ladder). The question is the same either way:
+     * this model, this level, this num_predict and num_ctx.
+     */
+    probeOllama?: (baseUrl: string | undefined, modelId: string, query: {
+        think: string;
+        numPredict: number;
+        numCtx: number | undefined;
+    }) => Promise<{
+        level: string;
+        budgetTokens: number;
+    } | undefined>;
+}
+/** The thinking allowance this session will run under, or nothing to state. */
+export declare function resolveSessionThinkingAllowance(input: SessionThinkingInput): Promise<{
+    level: string;
+    budgetTokens: number;
+} | undefined>;
+/**
+ * What the server appends to reasoning it cut at the budget: the configured
+ * message, which goes on the wire and overrides the model file, then the
+ * model's own as Ollama reported it.
+ */
+export declare function resolveSessionThinkBudgetMessage(input: {
+    providerId: string;
+    modelId: string | undefined;
+    baseUrl: string | undefined;
+    configuredMessage?: string;
+}): string | undefined;

package/dist/services/local-runtime-bootstrap.d.ts

@@ -0,0 +1,62 @@
+import type { AgentConfig, AgentEvent, AgentHooks, AgentTool, BasicLogger, ITelemetryService, ToolApprovalRequest, ToolApprovalResult, WorkspaceInfo } from "@cerebriline/shared";
+import type { SubAgentEndContext, SubAgentStartContext, TeamEvent } from "../extensions/tools/team";
+import type { DelegatedSandboxes } from "../extensions/tools/team/delegated-sandboxes";
+import type { SpawnToolOptions } from "../extensions/tools/team/spawn-agent-tool";
+import type { RuntimeCapabilities } from "../runtime/capabilities";
+import type { LocalRuntimeStartOptions, ResolvedStartSessionInput } from "../runtime/host/runtime-host";
+import type { RuntimeBuilderInput } from "../runtime/orchestration/session-runtime";
+import type { CoreSessionConfig } from "../types/config";
+import { type ProviderConfig } from "../types/provider-settings";
+import type { ProviderSettingsManager } from "./storage/provider-settings-manager";
+import type { GitWorkspaceState } from "./workspace/workspace-manifest";
+export interface PrepareLocalRuntimeBootstrapOptions {
+    input: ResolvedStartSessionInput;
+    localRuntime?: LocalRuntimeStartOptions;
+    sessionId: string;
+    providerSettingsManager: ProviderSettingsManager;
+    defaultTelemetry?: ITelemetryService;
+    defaultLogger?: BasicLogger;
+    defaultCapabilities?: RuntimeCapabilities;
+    defaultToolPolicies?: AgentConfig["toolPolicies"];
+    /**
+     * Host-level default `fetch` threaded into `ProviderConfig.fetch` so the
+     * AI gateway providers can use a custom HTTP implementation.
+     */
+    defaultFetch?: typeof fetch;
+    onPluginEvent: (event: {
+        name: string;
+        payload?: unknown;
+    }) => void;
+    onTeamEvent: (event: TeamEvent) => void;
+    createSubAgentLifecycleCallbacks?: (config: CoreSessionConfig) => {
+        onSubAgentEvent?: (event: AgentEvent) => void;
+        onSubAgentStart?: (context: SubAgentStartContext) => void | Promise<void>;
+        onSubAgentEnd?: (context: SubAgentEndContext) => void | Promise<void>;
+    };
+    createSpawnTool: (options?: SpawnToolOptions) => AgentTool;
+    createSwarmTool?: () => AgentTool;
+    /**
+     * The session's delegated-agent workspaces, for the paths the runtime
+     * builder runs itself: configured agents and teammates. See
+     * `RuntimeBuilderInput.delegatedSandboxes`.
+     */
+    delegatedSandboxes?: () => DelegatedSandboxes;
+    readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
+    writeSessionMetadata: (metadata: Record<string, unknown>) => Promise<void> | void;
+}
+export interface LocalRuntimeBootstrap {
+    effectiveInput: ResolvedStartSessionInput;
+    config: CoreSessionConfig;
+    providerConfig: ProviderConfig;
+    workspaceMetadata: string;
+    /** Structured git + path metadata generated alongside workspaceMetadata. */
+    workspaceInfo: WorkspaceInfo;
+    gitState: GitWorkspaceState;
+    extensions: AgentConfig["extensions"];
+    hooks: AgentHooks | undefined;
+    toolPolicies: AgentConfig["toolPolicies"];
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
+    pluginSandboxShutdown?: () => Promise<void>;
+    runtimeBuilderInput: RuntimeBuilderInput;
+}
+export declare function prepareLocalRuntimeBootstrap(options: PrepareLocalRuntimeBootstrapOptions): Promise<LocalRuntimeBootstrap>;