@cerebriline/core 4.100.245 → 4.100.247

package/dist/runtime/orchestration/team-persistence-writer.d.ts

@@ -0,0 +1,65 @@
+import type { TeamRuntimeState, TeamTeammateSpec } from "@cerebriline/shared";
+import type { TeamEvent, TeamRuntimeStateDelta } from "../../extensions/tools/team";
+import type { TeamPersistenceBatch } from "../../types/storage";
+/** Default batch window for coalescing durable team writes. */
+export declare const TEAM_PERSIST_BATCH_MS = 300;
+/**
+ * Telemetry (heartbeats/progress) updates run liveness fields in memory. Those
+ * are flushed at most this often so recovery sees a reasonably fresh
+ * `heartbeatAt` without writing on every 2s heartbeat or streamed chunk.
+ */
+export declare const TEAM_TELEMETRY_FLUSH_MS = 60000;
+/**
+ * Cap on events held for retry after failed writes, so a store that stays
+ * broken cannot grow memory without bound. Oldest events are dropped first.
+ */
+export declare const TEAM_PERSIST_MAX_PENDING_EVENTS = 5000;
+export interface TeamPersistenceSource {
+    hasPendingStateDelta(): boolean;
+    drainStateDelta(): TeamRuntimeStateDelta;
+    requeueStateDelta(delta: TeamRuntimeStateDelta): void;
+    exportState(): TeamRuntimeState;
+}
+export interface TeamPersistenceSink {
+    persistBatch(teamName: string, batch: TeamPersistenceBatch): unknown;
+}
+export interface TeamPersistenceWriterOptions {
+    teamKey: string;
+    store: TeamPersistenceSink;
+    source: () => TeamPersistenceSource | undefined;
+    teammates: () => TeamTeammateSpec[];
+    batchMs?: number;
+    telemetryFlushMs?: number;
+    onError?: (error: unknown) => void;
+    now?: () => number;
+}
+/**
+ * Coalesces durable team writes off the event hot path.
+ *
+ * - Telemetry events (`agent_event`, `run_progress`) never trigger a write.
+ * - Durable events are queued and flushed together after `batchMs`.
+ * - Terminal run states and membership changes flush immediately.
+ * - `flush()` is synchronous so shutdown paths can force a final write.
+ * - A failed write keeps its batch and retries on the next flush.
+ */
+export declare class TeamPersistenceWriter {
+    private readonly opts;
+    private pendingEvents;
+    private teammatesDirty;
+    private timer;
+    private lastFlushAt;
+    private disposed;
+    constructor(options: TeamPersistenceWriterOptions);
+    /** Called for every team event. Cheap for telemetry. */
+    onEvent(event: TeamEvent): void;
+    /** Teammate specs changed (spawn/shutdown); include them in next flush. */
+    markTeammatesDirty(): void;
+    /** State changed without a team event (read receipts, cleanup). */
+    markStateDirty(): void;
+    /** Write everything pending now. Safe to call repeatedly. */
+    flush(): void;
+    /** Final flush and stop accepting events. */
+    dispose(): void;
+    private schedule;
+    private clearTimer;
+}

package/dist/runtime/safety/rules.d.ts

@@ -2,5 +2,16 @@ import type { RuleConfig, UserInstructionConfigWatcher } from "../../extensions/
 export declare function isRuleEnabled(rule: RuleConfig): boolean;
 export declare function formatRulesForSystemPrompt(rules: ReadonlyArray<RuleConfig>): string;
 export declare function mergeRulesForSystemPrompt(primaryRules?: string, additionalRules?: string): string | undefined;
+/**
+ * The rules a session's system prompt includes, from any source that can list
+ * rule records: enabled rules only, in a stable name order. Every renderer of
+ * the rules section goes through this one selection so they cannot drift.
+ */
+export declare function listEnabledRulesFromRecords(records: ReadonlyArray<{
+    item: RuleConfig;
+}>): RuleConfig[];
+export declare function loadRulesForSystemPromptFromRecords(records: ReadonlyArray<{
+    item: RuleConfig;
+}>): string;
 export declare function listEnabledRulesFromWatcher(watcher: UserInstructionConfigWatcher): RuleConfig[];
 export declare function loadRulesForSystemPromptFromWatcher(watcher: UserInstructionConfigWatcher): string;

package/dist/runtime/turn-queue/pending-prompt-service.d.ts

@@ -83,6 +83,7 @@ export declare class PendingPromptsController {
     private readonly service;
     constructor(deps: PendingPromptsControllerDeps);
     list(sessionId: string): SessionPendingPrompt[];
+    steerFirst(sessionId: string): PendingPromptMutationResult;
     update(input: PendingPromptsUpdateInput): PendingPromptMutationResult;
     delete(input: PendingPromptsDeleteInput): PendingPromptMutationResult;
     enqueue(sessionId: string, entry: {

package/dist/services/agent-events.d.ts

@@ -55,5 +55,6 @@ export declare function legacyTokenUsageFromUsageEvent(event: Extract<AgentEvent
     cacheWriteTokens: number;
     cacheReadTokens: number;
     totalCost?: number;
+    reasoningTokenCount?: number;
 };
 export declare function handleAgentEvent(ctx: AgentEventContext, event: AgentEvent, overrides?: AgentTelemetryContextOverrides): void;

package/dist/services/cloud-handoff/git-preflight.d.ts

@@ -0,0 +1,24 @@
+import { type GitCommand } from "../workspace/workspace-manifest";
+export type { GitCommand } from "../workspace/workspace-manifest";
+export type CloudHandoffGitContext = {
+    repoUrl: string;
+    branch: string;
+    headSha: string;
+    workspaceRelativePath?: string;
+};
+export type CloudHandoffGitPreflightErrorCode = "not_git_repository" | "dirty_worktree" | "detached_head" | "missing_upstream" | "unsupported_remote" | "remote_branch_missing" | "unpushed_commits" | "git_command_failed";
+export declare class CloudHandoffGitPreflightError extends Error {
+    readonly code: CloudHandoffGitPreflightErrorCode;
+    constructor(code: CloudHandoffGitPreflightErrorCode, message: string, options?: ErrorOptions);
+}
+/** Converts supported GitHub clone URLs to the URL expected by cloud sessions. */
+export declare function normalizeGitHubRemoteUrl(remoteUrl: string): string | null;
+/**
+ * Refuses handoff unless a fresh GitHub clone of the upstream branch will be
+ * byte-for-byte anchored at the current local commit.
+ */
+export declare function preflightCloudHandoffGit(input: {
+    cwd: string;
+    git?: GitCommand;
+    signal?: AbortSignal;
+}): Promise<CloudHandoffGitContext>;

package/dist/services/cloud-handoff/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./git-preflight";
+export * from "./metadata";
+export * from "./transcript";
+export * from "./types";

package/dist/services/cloud-handoff/metadata.d.ts

@@ -0,0 +1,7 @@
+import type { CloudHandoffFingerprint, CloudHandoffMetadata } from "./types";
+export declare function createCloudHandoffFingerprint(input: CloudHandoffFingerprint): CloudHandoffFingerprint;
+export declare function cloudHandoffFingerprintsEqual(left: CloudHandoffFingerprint | undefined, right: CloudHandoffFingerprint | undefined): boolean;
+export declare function readCloudHandoffMetadata(metadata: unknown): CloudHandoffMetadata | undefined;
+export declare function mergeCloudHandoffMetadata(metadata: Record<string, unknown> | null | undefined, handoff: CloudHandoffMetadata): Record<string, unknown>;
+export declare function clearCloudHandoffMetadata(metadata: Record<string, unknown> | null | undefined): Record<string, unknown>;
+export declare function buildCloudHandoffDashboardUrl(appBaseUrl: string, outerSessionId: string): string;

package/dist/services/cloud-handoff/transcript.d.ts

@@ -0,0 +1,5 @@
+/** Compares the durable JSON wire shape, including image content and order. */
+export declare function cloudHandoffTranscriptsEqual(localMessages: readonly unknown[], cloudMessages: readonly unknown[]): boolean;
+export declare class CloudHandoffTranscriptMismatchError extends Error {
+    constructor(localCount: number, cloudCount: number);
+}

package/dist/services/cloud-handoff/types.d.ts

@@ -0,0 +1,35 @@
+export type CloudHandoffFingerprint = {
+    repoUrl: string;
+    branch: string;
+    headSha: string;
+    modelId: string;
+    organizationId?: string;
+    /** Repository-relative source cwd; omitted when the session is at repo root. */
+    workspaceRelativePath?: string;
+    /** Source interaction mode; omitted for the default Act mode. */
+    mode?: "plan" | "yolo" | "zen";
+};
+export type CloudHandoffMetadata = {
+    toCloudSessionId: string;
+    handedOffAt: string;
+    status: "pending" | "complete";
+    innerSessionId?: string;
+    dashboardUrl?: string;
+    fingerprint?: CloudHandoffFingerprint;
+};
+export type CloudHandoffDestination = "in_app" | "external";
+export type CloudHandoffProgressPhase = "checking" | "creating" | "provisioning" | "connecting" | "seeding" | "verifying" | "starting" | "complete";
+export type CloudHandoffProgress = {
+    phase: CloudHandoffProgressPhase;
+    message: string;
+    sessionId?: string;
+    dashboardUrl?: string;
+};
+export type CloudHandoffResult = {
+    outerSessionId: string;
+    innerSessionId: string;
+    dashboardUrl: string;
+    destination: CloudHandoffDestination;
+    warning?: string;
+    warningKind?: "unqueued" | "unconfirmed";
+};

package/dist/services/feature-flags/FeatureFlagsService.d.ts

@@ -25,11 +25,13 @@ export declare class FeatureFlagsService {
     private context;
     private cache;
     private cacheInfo;
+    private pendingPoll?;
     constructor(options: FeatureFlagsServiceOptions);
     setContext(context: FeatureFlagsContext): void;
     hydrateCache(snapshot: FeatureFlagsCacheSnapshot): void;
     getCacheSnapshot(): FeatureFlagsCacheSnapshot;
     poll(userId?: string | null): Promise<void>;
+    private pollFlags;
     private hydrateFromPersistentCache;
     private isFeatureFlagPayload;
     private readPayloadRecord;

package/dist/services/feature-flags/cline-account-feature-flags.d.ts

@@ -0,0 +1,5 @@
+import type { FeatureFlag } from "@cerebriline/shared";
+/** Evaluate a boolean rollout flag for the persisted Cline account in any host.
+ * Grants are cached for one minute; only an explicit boolean flag enables access.
+ */
+export declare function isClineAccountFeatureEnabled(flag: FeatureFlag): Promise<boolean>;

package/dist/services/llms/cline-recommended-models.d.ts

@@ -46,6 +46,7 @@ export declare function getCachedClineRecommendedModels(options?: FetchClineReco
  */
 export declare function peekClineRecommendedModels(): ClineRecommendedModelsData;
 export declare function resetClineRecommendedModelsCacheForTests(): void;
+export declare function idSlug(modelId: string): string;
 /**
  * Stamps recommended-feed tiers onto a provider's model list so clients can
  * render Recommended/Free/Subscribed sections straight off `ProviderModel`

package/dist/services/llms/handler-factory.d.ts

@@ -1,5 +1,17 @@
 import type { AgentConfig, AgentModel, BasicLogger, ITelemetryService, ModelInfo } from "@cerebriline/shared";
+import type { ProviderConfig } from "./provider-settings";
 export declare function resolveKnownModelsFromConfig(config: AgentConfig): Record<string, ModelInfo> | undefined;
+export type ConnectionConfig = Pick<AgentConfig, "providerId" | "modelId" | "apiKey" | "baseUrl" | "headers" | "providerConfig">;
+/**
+ * Resolve the provider connection for a request from the live session config.
+ * Top-level fields win over the nested `providerConfig` snapshot, and the
+ * snapshot only contributes when it describes the same provider, so a token
+ * refresh or connection change written to the top level (see
+ * `syncOAuthCredentials` / `updateConnection`) applies to every request built
+ * afterwards. Every request builder (main agent, compaction summarizer) must
+ * go through this so they never disagree on credentials.
+ */
+export declare function resolveConnectionProviderConfig(config: ConnectionConfig): ProviderConfig;
 export interface CreateAgentModelOptions {
     /**
      * Set by the caller that is running the conversation itself.

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

@@ -28,7 +28,7 @@ export declare const DEFAULT_MODELS_CATALOG_URL = "https://models.dev/api.json";
  */
 export declare function isPrivateModelCatalogProvider(providerId: string): boolean;
 export declare function clearPublicModelsCatalogCache(): void;
-export declare function getLiveModelsCatalog(options?: Pick<ModelCatalogConfig, "url" | "cacheTtlMs">): Promise<Record<string, Record<string, ModelInfo>>>;
+export declare function getLiveModelsCatalog(options?: Pick<ModelCatalogConfig, "url" | "cacheTtlMs" | "includeClineCloudModels">): Promise<Record<string, Record<string, ModelInfo>>>;
 export declare function clearLiveModelsCatalogCache(url?: string): void;
 export declare function clearPrivateModelsCatalogCache(): void;
 export declare const OPENAI_COMPATIBLE_PROVIDERS: Record<string, ProviderDefaults>;

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

@@ -17,23 +17,23 @@ export declare const ProviderIdSchema: z.ZodString;
 export declare const ProviderProtocolSchema: z.ZodEnum<{
     anthropic: "anthropic";
     gemini: "gemini";
-    "openai-chat": "openai-chat";
-    "openai-responses": "openai-responses";
     "openai-r1": "openai-r1";
     "ai-sdk": "ai-sdk";
+    "openai-responses": "openai-responses";
+    "openai-chat": "openai-chat";
 }>;
 export declare const ProviderClientSchema: z.ZodEnum<{
     custom: "custom";
     fetch: "fetch";
     anthropic: "anthropic";
+    bedrock: "bedrock";
     gemini: "gemini";
+    vertex: "vertex";
+    "openai-compatible": "openai-compatible";
+    openai: "openai";
     "openai-r1": "openai-r1";
     "ai-sdk": "ai-sdk";
     "ai-sdk-community": "ai-sdk-community";
-    openai: "openai";
-    "openai-compatible": "openai-compatible";
-    bedrock: "bedrock";
-    vertex: "vertex";
 }>;
 export declare const AuthSettingsSchema: z.ZodObject<{
     apiKey: z.ZodOptional<z.ZodString>;
@@ -162,10 +162,10 @@ export declare const AwsSettingsSchema: z.ZodObject<{
     region: z.ZodOptional<z.ZodString>;
     profile: z.ZodOptional<z.ZodString>;
     authentication: z.ZodOptional<z.ZodEnum<{
-        profile: "profile";
         iam: "iam";
         "api-key": "api-key";
         apikey: "apikey";
+        profile: "profile";
     }>>;
     usePromptCache: z.ZodOptional<z.ZodBoolean>;
     useCrossRegionInference: z.ZodOptional<z.ZodBoolean>;
@@ -200,14 +200,15 @@ export declare const SapSettingsSchema: z.ZodObject<{
 export type SapSettings = z.infer<typeof SapSettingsSchema>;
 export declare const OcaSettingsSchema: z.ZodObject<{
     mode: z.ZodOptional<z.ZodEnum<{
-        internal: "internal";
         external: "external";
+        internal: "internal";
     }>>;
     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>;
+    includeClineCloudModels: z.ZodOptional<z.ZodBoolean>;
     loadPrivateOnAuth: z.ZodOptional<z.ZodBoolean>;
     url: z.ZodOptional<z.ZodString>;
     cacheTtlMs: z.ZodOptional<z.ZodNumber>;
@@ -233,23 +234,23 @@ export declare const ProviderSettingsSchema: z.ZodObject<{
     protocol: z.ZodOptional<z.ZodEnum<{
         anthropic: "anthropic";
         gemini: "gemini";
-        "openai-chat": "openai-chat";
-        "openai-responses": "openai-responses";
         "openai-r1": "openai-r1";
         "ai-sdk": "ai-sdk";
+        "openai-responses": "openai-responses";
+        "openai-chat": "openai-chat";
     }>>;
     client: z.ZodOptional<z.ZodEnum<{
         custom: "custom";
         fetch: "fetch";
         anthropic: "anthropic";
+        bedrock: "bedrock";
         gemini: "gemini";
+        vertex: "vertex";
+        "openai-compatible": "openai-compatible";
+        openai: "openai";
         "openai-r1": "openai-r1";
         "ai-sdk": "ai-sdk";
         "ai-sdk-community": "ai-sdk-community";
-        openai: "openai";
-        "openai-compatible": "openai-compatible";
-        bedrock: "bedrock";
-        vertex: "vertex";
     }>>;
     routingProviderId: z.ZodOptional<z.ZodString>;
     maxTokens: z.ZodOptional<z.ZodNumber>;
@@ -341,10 +342,10 @@ export declare const ProviderSettingsSchema: z.ZodObject<{
         region: z.ZodOptional<z.ZodString>;
         profile: z.ZodOptional<z.ZodString>;
         authentication: z.ZodOptional<z.ZodEnum<{
-            profile: "profile";
             iam: "iam";
             "api-key": "api-key";
             apikey: "apikey";
+            profile: "profile";
         }>>;
         usePromptCache: z.ZodOptional<z.ZodBoolean>;
         useCrossRegionInference: z.ZodOptional<z.ZodBoolean>;
@@ -375,8 +376,8 @@ export declare const ProviderSettingsSchema: z.ZodObject<{
     }, z.core.$strip>>;
     oca: z.ZodOptional<z.ZodObject<{
         mode: z.ZodOptional<z.ZodEnum<{
-            internal: "internal";
             external: "external";
+            internal: "internal";
         }>>;
         usePromptCache: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -389,14 +390,15 @@ export declare const ProviderSettingsSchema: z.ZodObject<{
         vision: "vision";
         reasoning: "reasoning";
         tools: "tools";
-        "prompt-cache": "prompt-cache";
         streaming: "streaming";
+        "prompt-cache": "prompt-cache";
         "computer-use": "computer-use";
         oauth: "oauth";
         popular: "popular";
     }>>>;
     modelCatalog: z.ZodOptional<z.ZodObject<{
         loadLatestOnInit: z.ZodOptional<z.ZodBoolean>;
+        includeClineCloudModels: z.ZodOptional<z.ZodBoolean>;
         loadPrivateOnAuth: z.ZodOptional<z.ZodBoolean>;
         url: z.ZodOptional<z.ZodString>;
         cacheTtlMs: z.ZodOptional<z.ZodNumber>;

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

@@ -5,6 +5,7 @@ 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 { SessionHistoryOriginMetadata } from "../session/history-origin";
 import type { CoreSessionConfig } from "../types/config";
 import { type ProviderConfig } from "../types/provider-settings";
 import type { ProviderSettingsManager } from "./storage/provider-settings-manager";
@@ -13,6 +14,12 @@ export interface PrepareLocalRuntimeBootstrapOptions {
     input: ResolvedStartSessionInput;
     localRuntime?: LocalRuntimeStartOptions;
     sessionId: string;
+    /**
+     * How the session was initiated (user, automation, import, ...). Stamped
+     * on every telemetry event the session emits so errors can be filtered by
+     * provenance, e.g. transcripts imported from another agent.
+     */
+    sessionOrigin?: SessionHistoryOriginMetadata;
     providerSettingsManager: ProviderSettingsManager;
     defaultTelemetry?: ITelemetryService;
     defaultLogger?: BasicLogger;

package/dist/services/mcp-install.d.ts

@@ -12,6 +12,15 @@ export interface McpInstallResult {
     transport: McpServerTransportConfig;
     warnings: string[];
 }
+/**
+ * Parse `Header-Name: value` strings, one header per string, as
+ * `cline mcp add --header` does. Throws on a malformed header and warns about
+ * values that look like unfilled placeholders such as `<token>`.
+ */
+export declare function parseMcpHeaders(values: string[]): {
+    headers?: Record<string, string>;
+    warnings: string[];
+};
 export declare function buildMcpInstallTransport(options: {
     headers?: string[];
     name: string;

package/dist/services/plugin-commands.d.ts

@@ -0,0 +1,28 @@
+import { type BasicLogger } from "@cerebriline/shared";
+export interface PluginSlashCommand {
+    /** Normalized token: lowercase, no leading slash. */
+    name: string;
+    description?: string;
+}
+export interface PluginCommandResult {
+    reply?: string;
+    submitPrompt?: string;
+}
+/**
+ * Executes plugin-registered slash commands (`api.registerCommand`) for one
+ * workspace. Plugins are loaded on first use and kept alive so repeated
+ * commands answer instantly; the loaded set is refreshed when plugin module
+ * paths or mtimes change (installs, updates, toggles).
+ */
+export interface PluginCommandService {
+    listCommands(): Promise<PluginSlashCommand[]>;
+    /** Runs `/name input`. Resolves undefined when no plugin declares `name`. */
+    run(name: string, input: string): Promise<PluginCommandResult | undefined>;
+    shutdown(): Promise<void>;
+}
+export declare function normalizePluginCommandName(name: string): string;
+export declare function createPluginCommandService(options: {
+    cwd: string;
+    workspacePath?: string;
+    logger?: BasicLogger;
+}): PluginCommandService;

package/dist/services/providers/local-provider-registry.d.ts

@@ -31,6 +31,7 @@ export declare const StoredModelEntrySchema: z.ZodObject<{
         "speech-generation": "speech-generation";
         "video-generation": "video-generation";
         transcription: "transcription";
+        realtime: "realtime";
     }>>;
     operationModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         streaming: "streaming";
@@ -70,9 +71,9 @@ export declare const StoredProviderMetadataSchema: z.ZodObject<{
     defaultModelId: z.ZodOptional<z.ZodString>;
     protocol: z.ZodOptional<z.ZodEnum<{
         "openai-responses": "openai-responses";
+        "openai-chat": "openai-chat";
         anthropic: "anthropic";
         gemini: "gemini";
-        "openai-chat": "openai-chat";
         "openai-r1": "openai-r1";
         "ai-sdk": "ai-sdk";
     }>>;
@@ -112,9 +113,9 @@ export declare const StoredProviderEntrySchema: z.ZodObject<{
         defaultModelId: z.ZodOptional<z.ZodString>;
         protocol: z.ZodOptional<z.ZodEnum<{
             "openai-responses": "openai-responses";
+            "openai-chat": "openai-chat";
             anthropic: "anthropic";
             gemini: "gemini";
-            "openai-chat": "openai-chat";
             "openai-r1": "openai-r1";
             "ai-sdk": "ai-sdk";
         }>>;
@@ -176,6 +177,7 @@ export declare const StoredProviderEntrySchema: z.ZodObject<{
             "speech-generation": "speech-generation";
             "video-generation": "video-generation";
             transcription: "transcription";
+            realtime: "realtime";
         }>>;
         operationModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
             streaming: "streaming";
@@ -208,6 +210,7 @@ export declare const StoredProviderEntrySchema: z.ZodObject<{
             r1: "r1";
         }>>;
     }, z.core.$loose>>>;
+    discoveredModelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>;
 export type StoredProviderEntry = z.infer<typeof StoredProviderEntrySchema>;
 export declare const StoredModelsFileSchema: z.ZodObject<{
@@ -219,9 +222,9 @@ export declare const StoredModelsFileSchema: z.ZodObject<{
             defaultModelId: z.ZodOptional<z.ZodString>;
             protocol: z.ZodOptional<z.ZodEnum<{
                 "openai-responses": "openai-responses";
+                "openai-chat": "openai-chat";
                 anthropic: "anthropic";
                 gemini: "gemini";
-                "openai-chat": "openai-chat";
                 "openai-r1": "openai-r1";
                 "ai-sdk": "ai-sdk";
             }>>;
@@ -283,6 +286,7 @@ export declare const StoredModelsFileSchema: z.ZodObject<{
                 "speech-generation": "speech-generation";
                 "video-generation": "video-generation";
                 transcription: "transcription";
+                realtime: "realtime";
             }>>;
             operationModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                 streaming: "streaming";
@@ -315,6 +319,7 @@ export declare const StoredModelsFileSchema: z.ZodObject<{
                 r1: "r1";
             }>>;
         }, z.core.$loose>>>;
+        discoveredModelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$loose>>;
 }, z.core.$strip>;
 export type StoredModelsFile = z.infer<typeof StoredModelsFileSchema>;

package/dist/services/providers/local-provider-service.d.ts

@@ -29,32 +29,33 @@ export interface TranscribeLocalAudioRequest {
     providerId: string;
     modelId: string;
     audio: Uint8Array;
-    mediaType?: string;
     abortSignal?: AbortSignal;
 }
 export interface TranscribeConfiguredVoiceInputRequest {
     audio: Uint8Array;
-    mediaType?: string;
     abortSignal?: AbortSignal;
 }
 export interface CreateConfiguredStreamingTranscriptionSessionRequest {
     expiresAfterSeconds?: number;
     abortSignal?: AbortSignal;
 }
-export declare function isDedicatedTranscriptionModel(model: Pick<ProviderModel, "operation">): boolean;
-export declare function addLocalProvider(manager: ProviderSettingsManager, request: Omit<AddProviderActionRequest, "action">): Promise<{
+export declare function isDedicatedTranscriptionModel(model: Pick<ProviderModel, "operation" | "inputModalities" | "outputModalities">): boolean;
+export declare function addLocalProvider(manager: ProviderSettingsManager, request: Omit<AddProviderActionRequest, "action">): ReturnType<typeof addLocalProviderUnlocked>;
+declare function addLocalProviderUnlocked(manager: ProviderSettingsManager, request: Omit<AddProviderActionRequest, "action">): Promise<{
     providerId: string;
     settingsPath: string;
     modelsPath: string;
     modelsCount: number;
 }>;
-export declare function updateLocalProvider(manager: ProviderSettingsManager, request: UpdateLocalProviderRequest): Promise<{
+export declare function updateLocalProvider(manager: ProviderSettingsManager, request: UpdateLocalProviderRequest): ReturnType<typeof updateLocalProviderUnlocked>;
+declare function updateLocalProviderUnlocked(manager: ProviderSettingsManager, request: UpdateLocalProviderRequest): Promise<{
     providerId: string;
     settingsPath: string;
     modelsPath: string;
     modelsCount: number;
 }>;
-export declare function deleteLocalProvider(manager: ProviderSettingsManager, request: DeleteLocalProviderRequest): Promise<{
+export declare function deleteLocalProvider(manager: ProviderSettingsManager, request: DeleteLocalProviderRequest): ReturnType<typeof deleteLocalProviderUnlocked>;
+declare function deleteLocalProviderUnlocked(manager: ProviderSettingsManager, request: DeleteLocalProviderRequest): Promise<{
     providerId: string;
     settingsPath: string;
     modelsPath: string;
@@ -71,7 +72,14 @@ export declare function listLocalProviders(manager: ProviderSettingsManager, opt
     settingsPath: string;
     voiceInput?: VoiceInputSelection;
 }>;
-export declare function getLocalProviderModels(providerId: string, config?: ProviderConfig): Promise<{
+export declare function getLocalProviderModels(providerId: string, config?: ProviderConfig, options?: {
+    loadLatest?: boolean;
+}): Promise<{
+    providerId: string;
+    models: ProviderModel[];
+}>;
+/** The same executable voice catalog is used by pickers, saves, and requests. */
+export declare function getLocalTranscriptionModels(providerId: string, config?: ProviderConfig): Promise<{
     providerId: string;
     models: ProviderModel[];
 }>;
@@ -82,12 +90,14 @@ export declare function saveVoiceInputSettings(manager: ProviderSettingsManager,
 }>;
 export declare function transcribeConfiguredVoiceInput(manager: ProviderSettingsManager, request: TranscribeConfiguredVoiceInputRequest): Promise<LlmsModels.AudioTranscriptionResult>;
 export declare function createConfiguredStreamingTranscriptionSession(manager: ProviderSettingsManager, request?: CreateConfiguredStreamingTranscriptionSessionRequest): Promise<LlmsModels.StreamingAudioTranscriptionSession>;
-export declare function saveLocalProviderSettings(manager: ProviderSettingsManager, request: Omit<SaveProviderSettingsActionRequest, "action">): {
+export declare function saveLocalProviderSettings(manager: ProviderSettingsManager, request: Omit<SaveProviderSettingsActionRequest, "action">): ReturnType<typeof saveLocalProviderSettingsUnlocked>;
+declare function saveLocalProviderSettingsUnlocked(manager: ProviderSettingsManager, request: Omit<SaveProviderSettingsActionRequest, "action">): Promise<{
     providerId: string;
     enabled: boolean;
     settingsPath: string;
-};
-export declare function refreshProviderModelsFromSource(manager: ProviderSettingsManager, providerId: string): Promise<{
+}>;
+export declare function refreshProviderModelsFromSource(manager: ProviderSettingsManager, providerId: string): ReturnType<typeof refreshProviderModelsFromSourceUnlocked>;
+declare function refreshProviderModelsFromSourceUnlocked(manager: ProviderSettingsManager, providerId: string): Promise<{
     providerId: string;
     refreshed: boolean;
     modelsCount?: number;

package/dist/services/providers/model-source.d.ts

@@ -1,3 +1,8 @@
 export declare function extractModelIdsFromPayload(payload: unknown, providerId: string): string[];
-export declare function fetchModelIdsFromSource(url: string, providerId: string): Promise<string[]>;
+export interface ModelSourceAuth {
+    baseUrl?: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+}
+export declare function fetchModelIdsFromSource(url: string, providerId: string, auth?: ModelSourceAuth): Promise<string[]>;
 export declare function resolveModelsSourceUrl(baseUrl: string | undefined, defaultBaseUrl: string | undefined, modelsSourceUrl: string | undefined): string | undefined;

package/dist/services/providers/provider-config-fields.d.ts

@@ -34,4 +34,15 @@ export interface ProviderConfigFields {
  * input, no default base URL) so callers can render a reasonable configure
  * dialog without per-id branches.
  */
+/**
+ * Whether a provider authenticates through credentials already stored on the
+ * machine by a local CLI (Codex CLI, Claude Code, ...) instead of an API key
+ * or an OAuth flow.
+ *
+ * Read from the provider registry's `local-auth` capability rather than a
+ * hardcoded id list, so tagging a provider in `@cerebriline/llms` is all it takes
+ * for configure UIs to route it to their local-readiness flow. Mirrors
+ * `isOAuthProvider` for the OAuth side.
+ */
+export declare function isLocalAuthProvider(providerId: string): boolean;
 export declare function getProviderConfigFields(providerId: string): ProviderConfigFields;

package/dist/services/retrieval/code-index.d.ts

@@ -65,6 +65,8 @@ export interface CodeSearchOptions {
     reranker?: RetrievalEndpoint;
     /** Passages returned. @default 8 */
     limit?: number;
+    /** How the folder's files are read for line numbers. @default from disk */
+    readFile?: (absolutePath: string) => Promise<string | undefined>;
     signal?: AbortSignal;
 }
 export interface CodeHit {