@clinebot/core 0.0.37 → 0.0.38

package/dist/runtime/{session-runtime-orchestrator.d.ts → orchestration/session-runtime-orchestrator.d.ts}

@@ -1,5 +1,5 @@
 /**
- * Per-session `SessionRuntime` orchestrator (PLAN.md §3.2.3).
+ * Per-session `SessionRuntime` orchestrator.
  *
  * Owns all cross-turn state for one logical agent session:
  *
@@ -7,33 +7,21 @@
  *   - `MistakeTracker`         — per-session consecutive-mistake counter
  *   - `LoopDetectionTracker`   — per-session repeated-tool-call detector
  *   - `MessageBuilder`         — provider-message assembly cache
- *   - `HookEngine` + `HookBridge` — legacy `AgentHooks`/`AgentExtension[]`
- *                                   → runtime-hook synthesis
+ *   - `AgentRuntimeHooks`      — runtime-native hooks from config/extensions
  *   - `RuntimeEventAdapter`    — per-run stateful `AgentRuntimeEvent`
  *                                → legacy `AgentEvent` translator
  *   - listener registry        — host subscribers see legacy `AgentEvent`s
  *   - pending tool set, abort  — per-run lifecycle housekeeping
  *
  * A fresh `AgentRuntime` is instantiated per run via
- * `createAgentRuntime(createAgentRuntimeConfig({...}))`; it is the
- * only class that depends on `@clinebot/agents`. All session-level
- * state outlives any one `AgentRuntime`, making OAuth-retry + run
- * replay feasible (§3.2.2 invariant #3).
- *
- * NOTE: this class lives alongside the pre-existing
- * `packages/core/src/runtime/session-runtime.ts`, which exports
- * transport-level `SessionRuntime`/`RuntimeBuilder` interfaces
- * consumed by `LocalRuntimeHost`. Both coexist through Step 8/9; the
- * transport-level interface is retired in Step 10 (§3.6 Step 10).
- *
- * @see PLAN.md §3.2.3 — public surface.
- * @see PLAN.md §3.2.2 — call graph and invariants.
- * @see PLAN.md §3.6 Step 8d — landing commit.
+ * `createAgentRuntime(createAgentRuntimeConfig({...}))`. All
+ * session-level state outlives any one `AgentRuntime`, making
+ * OAuth-retry and run replay feasible.
  */
 import type { AgentRuntime } from "@clinebot/agents";
 import { createAgentRuntime } from "@clinebot/agents";
-import { type AgentConfig, type AgentEvent, type AgentExtensionRegistry, type AgentResult, type BasicLogger, HookEngine, type ITelemetryService, type Message, type MessageWithMetadata, type Tool } from "@clinebot/shared";
-import { MessageBuilder } from "../session/message-builder";
+import { type AgentConfig, type AgentEvent, type AgentExtensionRegistry, type AgentResult, type AgentTool, type BasicLogger, type ITelemetryService, type Message, type MessageWithMetadata } from "@clinebot/shared";
+import { MessageBuilder } from "../../session/services/message-builder";
 /**
  * Listener invoked for every legacy `AgentEvent` produced by the
  * session runtime. Use `subscribeEvents(listener)` — it returns an
@@ -44,8 +32,6 @@ export type SessionEventListener = (event: AgentEvent) => void;
 export interface SessionRuntimeOrchestratorDeps {
     readonly logger?: BasicLogger;
     readonly telemetry?: ITelemetryService;
-    /** Optional pre-constructed `HookEngine`. A fresh one is built when omitted. */
-    readonly hookEngine?: HookEngine;
     /**
      * Test hook: override the `AgentRuntime` factory. Production
      * callers leave this undefined and get the real `createAgentRuntime`.
@@ -67,13 +53,7 @@ export interface ConnectionOverrides {
 /**
  * Per-session orchestrator. Construct once per agent session; call
  * `run` / `continue` repeatedly. The class matches the subset of
- * legacy `Agent` surface that `legacy-agent-facade` needs in Step 8e.
- *
- * Named `SessionRuntime` to match PLAN.md §3.2.3. To avoid a symbol
- * collision with the pre-existing transport-level `SessionRuntime`
- * interface in `session-runtime.ts`, this file is **not** re-exported
- * from `runtime/index.ts` or `src/index.ts`. Consumers (facade in
- * Step 8e) import directly from this module.
+ * runtime-facing session surface.
  */
 export declare class SessionRuntime {
     private config;
@@ -81,8 +61,6 @@ export declare class SessionRuntime {
     private readonly parentAgentId?;
     private readonly logger?;
     readonly telemetry?: ITelemetryService;
-    private readonly hookEngine;
-    private readonly hookBridge;
     private readonly conversation;
     private readonly mistakeTracker;
     private readonly loopTracker;
@@ -103,7 +81,7 @@ export declare class SessionRuntime {
     private extensionsInitialized;
     private readonly listeners;
     private readonly createAgentRuntimeImpl;
-    /** Stable run id shared with the HookBridge during an active run. */
+    /** Stable run id for the active run. */
     private activeRunId;
     /** True while a run is in flight. `canStartRun()` is the negation. */
     private running;
@@ -113,7 +91,7 @@ export declare class SessionRuntime {
     private abortReason;
     /** Reference to the current run's `AgentRuntime` so `abort` can forward. */
     private activeRuntime;
-    /** Promise for the current run so shutdown can await an aborted run's drain. */
+    /** Promise returned from the current run so shutdown can await its drain. */
     private activeRunPromise;
     /** Per-run `Agent → AgentEvent` adapter; `reset()` each run. */
     private readonly eventAdapter;
@@ -166,9 +144,9 @@ export declare class SessionRuntime {
      * `api.registerTool` / `registerCommand` / `registerMessageBuilder`
      * / `registerProvider` / `registerAutomationEventType`.
      */
-    getExtensionRegistry(): AgentExtensionRegistry<Tool, Message[]>;
+    getExtensionRegistry(): AgentExtensionRegistry<AgentTool, Message[]>;
     /** Append additional tools to every subsequent turn's runtime config. */
-    addTools(tools: Tool[]): void;
+    addTools(tools: AgentTool[]): void;
     /** Mutate provider / reasoning fields for subsequent runs. */
     updateConnection(overrides: ConnectionOverrides): void;
     clearHistory(): void;
@@ -182,36 +160,13 @@ export declare class SessionRuntime {
      */
     subscribeEvents(listener: SessionEventListener): () => void;
     abort(reason?: unknown): void;
-    /**
-     * Shut the session down. Fires `hook.session_shutdown` exactly once
-     * (legacy parity with `Agent.shutdown` at pre-Step-9 `agent.ts:325`)
-     * and drains any in-flight async hooks through the hook engine.
-     *
-     * @param reason    Optional caller-supplied reason string (e.g.
-     *                  `"session_complete"`, `"session_error"`,
-     *                  `"session_stop"`, `"ctrl_d"`). Propagated into
-     *                  the `session_shutdown` hook payload as
-     *                  `AgentHookSessionShutdownContext.reason` so hook
-     *                  handlers (e.g. hook-file runners) can route on
-     *                  it — this matches the legacy `Agent.shutdown(reason)`
-     *                  contract and keeps `isAbortReason(ctx.reason)`
-     *                  checks in `hook-file-hooks.ts` working.
-     * @param timeoutMs Optional drain timeout forwarded to
-     *                  `HookEngine.shutdown`. Defaults to the engine's
-     *                  own default (3000 ms) when omitted.
-     */
-    shutdown(reason?: string, timeoutMs?: number): Promise<void>;
+    /** Shut the session down after any active run drains. */
+    shutdown(_reason?: string, _timeoutMs?: number): Promise<void>;
     run(userMessage: string, userImages?: string[], userFiles?: string[]): Promise<AgentResult>;
     continue(userMessage?: string, userImages?: string[], userFiles?: string[]): Promise<AgentResult>;
+    private composeSystemPrompt;
     private executeRun;
     private executeRunInternal;
-    /**
-     * Build an aborted `AgentResult` without invoking the AgentRuntime.
-     * Used by the `hook.session_start` / `hook.input` cancel paths —
-     * legacy parity: a hook that returns `{ cancel: true }` short-circuits
-     * the run and yields `finishReason: "aborted"`.
-     */
-    private finalizeAbortedRun;
     /**
      * Initialize the contribution registry once per session. Runs
      * extension `setup()` callbacks so they can `registerTool`,
@@ -228,8 +183,12 @@ export declare class SessionRuntime {
      * been activated.
      */
     private ensureExtensionsInitialized;
-    private prepareMessagesForApi;
+    private createRuntimeHooks;
+    private createRuntimePrepareTurn;
+    private prepareMessagesForModelRequest;
+    private prepareProviderMessagesForApi;
     private handleRuntimeEvent;
+    private syncConversationFromRuntimeMessage;
     private emitLegacyEvent;
     /**
      * Feed the `LoopDetectionTracker` with a tool-call and react to
@@ -256,6 +215,4 @@ export declare class SessionRuntime {
      */
     private enqueueMistakeRecord;
     private buildLegacyResult;
-    private dispatchRunEnd;
 }
-//# sourceMappingURL=session-runtime-orchestrator.d.ts.map

package/dist/runtime/{session-runtime.d.ts → orchestration/session-runtime.d.ts}

@@ -1,8 +1,9 @@
-import type { AgentConfig, AgentHooks, AgentResult, BasicLogger, ITelemetryService, RuntimeConfigExtensionKind, Tool } from "@clinebot/shared";
-import type { UserInstructionConfigWatcher } from "../extensions/config";
-import type { ToolExecutors } from "../extensions/tools";
-import type { AgentTeamsRuntime, DelegatedAgentConfigProvider, TeamEvent } from "../extensions/tools/team";
-import type { CoreSessionConfig } from "../types/config";
+import type { AgentConfig, AgentHooks, AgentResult, AgentTool, BasicLogger, ITelemetryService, RuntimeConfigExtensionKind } from "@clinebot/shared";
+import type { UserInstructionConfigService } from "../../extensions/config";
+import type { ToolExecutors } from "../../extensions/tools";
+import type { AgentTeamsRuntime, DelegatedAgentConfigProvider, TeamEvent } from "../../extensions/tools/team";
+import type { WorkspaceManager } from "../../services/workspace/workspace-manager";
+import type { CoreSessionConfig } from "../../types/config";
 /**
  * Internal structural alias for the lead-agent handle that
  * {@link BuiltRuntime.registerLeadAgent} hands off to
@@ -13,17 +14,18 @@ import type { CoreSessionConfig } from "../types/config";
  * dropped entirely per §3.5 row #2.
  */
 type LeadAgentHandle = {
-    addTools(tools: Tool[]): unknown;
+    addTools(tools: AgentTool[]): unknown;
 };
 export interface BuiltRuntime {
-    tools: Tool[];
+    tools: AgentTool[];
     hooks?: AgentHooks;
     logger?: BasicLogger;
     telemetry?: ITelemetryService;
     teamRuntime?: AgentTeamsRuntime;
     teamRestoredFromPersistence?: boolean;
     delegatedAgentConfigProvider?: DelegatedAgentConfigProvider;
-    completionGuard?: () => string | undefined;
+    extensions?: AgentConfig["extensions"];
+    completionPolicy?: AgentConfig["completionPolicy"];
     registerLeadAgent?: (agent: LeadAgentHandle) => void;
     shutdown: (reason: string) => Promise<void> | void;
 }
@@ -32,11 +34,12 @@ export interface RuntimeBuilderInput {
     hooks?: AgentHooks;
     extensions?: AgentConfig["extensions"];
     onTeamEvent?: (event: TeamEvent) => void;
-    createSpawnTool?: () => Tool;
+    createSpawnTool?: () => AgentTool;
     onTeamRestored?: () => void;
-    userInstructionWatcher?: UserInstructionConfigWatcher;
+    userInstructionService?: UserInstructionConfigService;
     configExtensions?: RuntimeConfigExtensionKind[];
-    defaultToolExecutors?: Partial<ToolExecutors>;
+    toolExecutors?: Partial<ToolExecutors>;
+    workspaceManager?: WorkspaceManager;
     logger?: BasicLogger;
     telemetry?: ITelemetryService;
 }
@@ -53,4 +56,3 @@ export interface SessionRuntime {
     poll(): Promise<string[]>;
 }
 export {};
-//# sourceMappingURL=session-runtime.d.ts.map

package/dist/runtime/{user-input-builder.d.ts → orchestration/user-input-builder.d.ts}

@@ -1,24 +1,15 @@
 /**
  * User-input / first-turn content assembler.
  *
- * @see PLAN.md §3.1 — moved from `packages/agents/src/utils/agent-input.ts`.
- * @see PLAN.md §3.2.4 — called from the `Agent.run/continue` facade via
- *                      the `buildInitialUserContent` helper.
- *
- * Pure port. Opens the first user ContentBlock[] for a turn, loading user
- * file contents via the injected `userFileContentLoader` (already
- * core-owned per §3.1 notes on `packages/core/src/transports/local.ts`).
+ * Opens the first user content array for a turn, loading user file contents via
+ * the injected `userFileContentLoader`.
  */
 import type * as LlmsProviders from "@clinebot/llms";
 export declare function buildInitialUserContent(userMessage: string, userImages?: string[], userFiles?: string[], userFileContentLoader?: (path: string) => Promise<string>): Promise<string | LlmsProviders.ContentBlock[]>;
 /**
  * Normalize a user message shape into a plain string when possible.
  *
- * @see PLAN.md §3.1 — exported from the user-input-builder module so
- *                    SessionRuntime can use it to sanitise ad-hoc input.
- *
  * Accepts either a string or a LlmsProviders.Message; returns the best-effort
  * concatenated plain-text body. Non-text content is ignored.
  */
 export declare function normalizeUserMessage(input: string | LlmsProviders.Message | undefined): string;
-//# sourceMappingURL=user-input-builder.d.ts.map

package/dist/runtime/{loop-detection.d.ts → safety/loop-detection.d.ts}

@@ -56,4 +56,3 @@ export declare class LoopDetectionTracker {
     inspect(call: LoopDetectionCall): LoopDetectionVerdict;
     reset(): void;
 }
-//# sourceMappingURL=loop-detection.d.ts.map

package/dist/runtime/{mistake-tracker.d.ts → safety/mistake-tracker.d.ts}

@@ -66,4 +66,3 @@ export declare function buildMistakeLimitStopMessage(input: {
     details?: string;
     stopReason?: string;
 }): string;
-//# sourceMappingURL=mistake-tracker.d.ts.map

package/dist/runtime/{rules.d.ts → safety/rules.d.ts}

@@ -1,7 +1,6 @@
-import type { RuleConfig, UserInstructionConfigWatcher } from "../extensions/config";
+import type { RuleConfig, UserInstructionConfigWatcher } from "../../extensions/config/user-instruction-config-loader";
 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;
 export declare function listEnabledRulesFromWatcher(watcher: UserInstructionConfigWatcher): RuleConfig[];
 export declare function loadRulesForSystemPromptFromWatcher(watcher: UserInstructionConfigWatcher): string;
-//# sourceMappingURL=rules.d.ts.map

package/dist/runtime/{subprocess-sandbox.d.ts → tools/subprocess-sandbox.d.ts}

@@ -3,6 +3,8 @@ export interface SubprocessSandboxOptions {
     bootstrapScript?: string;
     /** Path to a JavaScript file to execute via `node <file>`. Mutually exclusive with {@link bootstrapScript}. */
     bootstrapFile?: string;
+    /** Runtime executable for internal JavaScript helpers. Defaults to node/bun instead of packaged CLI binaries. */
+    runtimeExecutable?: string;
     name?: string;
     onEvent?: (event: {
         name: string;
@@ -12,6 +14,19 @@ export interface SubprocessSandboxOptions {
 export interface SandboxCallOptions {
     timeoutMs?: number;
 }
+export declare const CLINE_JS_RUNTIME_PATH_ENV = "CLINE_JS_RUNTIME_PATH";
+export declare function resolveSubprocessRuntimeExecutable(options?: {
+    env?: NodeJS.ProcessEnv;
+    execPath?: string;
+    runtimeExecutable?: string;
+}): string;
+export declare function buildSubprocessSandboxCommand(args: string[], options?: {
+    env?: NodeJS.ProcessEnv;
+    execArgv?: string[];
+    name?: string;
+    execPath?: string;
+    runtimeExecutable?: string;
+}): string[];
 export declare class SubprocessSandbox {
     private readonly options;
     private process;
@@ -26,4 +41,3 @@ export declare class SubprocessSandbox {
     private onMessage;
     private failPending;
 }
-//# sourceMappingURL=subprocess-sandbox.d.ts.map

package/dist/runtime/{tool-approval.d.ts → tools/tool-approval.d.ts}

@@ -7,4 +7,3 @@ export type DesktopToolApprovalOptions = {
     nowIso?: () => string;
 };
 export declare function requestDesktopToolApproval(request: ToolApprovalRequest, options?: DesktopToolApprovalOptions): Promise<ToolApprovalResult>;
-//# sourceMappingURL=tool-approval.d.ts.map

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

@@ -0,0 +1,64 @@
+import type { CoreSessionEvent, SessionPendingPrompt } from "../../types/events";
+import type { ActiveSession } from "../../types/session";
+import type { PendingPromptMutationResult, PendingPromptsDeleteInput, PendingPromptsUpdateInput } from "../host/runtime-host";
+export type PendingPromptDelivery = "queue" | "steer";
+export interface PendingPromptEntry {
+    id: string;
+    prompt: string;
+    delivery: PendingPromptDelivery;
+    userImages?: string[];
+    userFiles?: string[];
+}
+export interface PendingPromptQueueState {
+    pendingPrompts: PendingPromptEntry[];
+}
+export interface PendingPromptsControllerDeps {
+    getSession(sessionId: string): ActiveSession | undefined;
+    emit(event: CoreSessionEvent): void;
+    send(input: {
+        sessionId: string;
+        prompt: string;
+        userImages?: string[];
+        userFiles?: string[];
+    }): Promise<unknown>;
+}
+export interface PendingPromptEnqueueInput {
+    prompt: string;
+    delivery: PendingPromptDelivery;
+    userImages?: string[];
+    userFiles?: string[];
+}
+export interface PendingPromptConsumeResult {
+    entry?: PendingPromptEntry;
+    prompts: SessionPendingPrompt[];
+}
+export declare class PendingPromptService {
+    list(state: PendingPromptQueueState | undefined): SessionPendingPrompt[];
+    update(state: PendingPromptQueueState | undefined, input: PendingPromptsUpdateInput): PendingPromptMutationResult;
+    delete(state: PendingPromptQueueState | undefined, input: PendingPromptsDeleteInput): PendingPromptMutationResult;
+    enqueue(state: PendingPromptQueueState, input: PendingPromptEnqueueInput): SessionPendingPrompt[];
+    consumeSteer(state: PendingPromptQueueState): PendingPromptConsumeResult;
+    shiftNext(state: PendingPromptQueueState): PendingPromptConsumeResult;
+    requeueFront(state: PendingPromptQueueState, entry: PendingPromptEntry): SessionPendingPrompt[];
+    clear(state: PendingPromptQueueState): SessionPendingPrompt[];
+}
+export declare class PendingPromptsController {
+    private readonly deps;
+    private readonly service;
+    constructor(deps: PendingPromptsControllerDeps);
+    list(sessionId: string): SessionPendingPrompt[];
+    update(input: PendingPromptsUpdateInput): PendingPromptMutationResult;
+    delete(input: PendingPromptsDeleteInput): PendingPromptMutationResult;
+    enqueue(sessionId: string, entry: {
+        prompt: string;
+        delivery: "queue" | "steer";
+        userImages?: string[];
+        userFiles?: string[];
+    }): void;
+    consumeSteer(sessionId: string): string | undefined;
+    clearAborted(session: ActiveSession): void;
+    emitPrompts(session: ActiveSession): void;
+    scheduleDrain(sessionId: string, session: ActiveSession): void;
+    drain(sessionId: string): Promise<void>;
+    private emitSubmitted;
+}

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

@@ -1,5 +1,5 @@
 import type { AgentEvent } from "@clinebot/shared";
-import type { SessionAccumulatedUsage } from "../runtime/runtime-host";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
 import type { CoreSessionConfig } from "../types/config";
 import type { CoreSessionEvent } from "../types/events";
 import type { ActiveSession } from "../types/session";
@@ -31,4 +31,3 @@ export declare function extractAgentEventMetadata(event: AgentEvent): {
 };
 export declare function buildTelemetryAgentIdentity(context: AgentTelemetryContextOverrides): TelemetryAgentIdentityProperties | undefined;
 export declare function handleAgentEvent(ctx: AgentEventContext, event: AgentEvent, overrides?: AgentTelemetryContextOverrides): void;
-//# sourceMappingURL=agent-events.d.ts.map

package/dist/services/config.d.ts

@@ -1,3 +1,2 @@
 import type { CoreSessionConfig } from "../types/config";
 export declare function resolveWorkspacePath(config: CoreSessionConfig): string;
-//# sourceMappingURL=config.d.ts.map

package/dist/services/global-settings.d.ts

@@ -1,12 +1,34 @@
-import type { AgentConfig, Tool } from "@clinebot/shared";
-export interface GlobalSettings {
+import type { AgentConfig, AgentTool, ITelemetryService } from "@clinebot/shared";
+import { z } from "zod";
+export declare const GlobalSettingsSchema: z.ZodPipe<z.ZodObject<{
+    telemetryOptOut: z.ZodCatch<z.ZodDefault<z.ZodBoolean>>;
+    disabledTools: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
+    disabledPlugins: z.ZodOptional<z.ZodPipe<z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>, z.ZodTransform<string[] | undefined, string[] | undefined>>>;
+}, z.core.$strip>, z.ZodTransform<{
+    telemetryOptOut: boolean;
     disabledTools?: string[];
+    disabledPlugins?: string[];
+}, {
+    telemetryOptOut: boolean;
+    disabledTools?: string[] | undefined;
+    disabledPlugins?: string[] | undefined;
+}>>;
+export type GlobalSettings = z.infer<typeof GlobalSettingsSchema>;
+export interface WriteGlobalSettingsOptions {
+    telemetry?: ITelemetryService;
 }
 export declare function readGlobalSettings(): GlobalSettings;
-export declare function writeGlobalSettings(settings: GlobalSettings): void;
+export declare function writeGlobalSettings(settings: z.input<typeof GlobalSettingsSchema>, options?: WriteGlobalSettingsOptions): void;
+export declare function isTelemetryOptedOutGlobally(): boolean;
+export declare function setTelemetryOptOutGlobally(telemetryOptOut: boolean, options?: WriteGlobalSettingsOptions): void;
 export declare function resolveDisabledToolNames(disabledToolNames?: ReadonlyArray<string>): Set<string>;
+export declare function resolveDisabledPluginPaths(disabledPluginPaths?: ReadonlyArray<string>): Set<string>;
 export declare function isToolDisabledGlobally(toolName: string): boolean;
 export declare function toggleDisabledTool(toolName: string): boolean;
-export declare function filterDisabledTools<T extends Pick<Tool, "name">>(tools: ReadonlyArray<T>, disabledToolNames?: ReadonlyArray<string>): T[];
+export declare function setDisabledTools(toolNames: ReadonlyArray<string>, disabledValue: boolean): void;
+export declare function setToolDisabledGlobally(toolName: string, disabled: boolean): boolean;
+export declare function isPluginDisabledGlobally(pluginPath: string): boolean;
+export declare function setDisabledPlugin(pluginPath: string, disabledValue: boolean): void;
+export declare function filterDisabledPluginPaths(pluginPaths: ReadonlyArray<string>, disabledPluginPaths?: ReadonlyArray<string>): string[];
+export declare function filterDisabledTools<T extends Pick<AgentTool, "name">>(tools: ReadonlyArray<T>, disabledToolNames?: ReadonlyArray<string>): T[];
 export declare function filterExtensionToolRegistrations(extensions: AgentConfig["extensions"], disabledToolNames?: ReadonlyArray<string>): AgentConfig["extensions"];
-//# sourceMappingURL=global-settings.d.ts.map

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

@@ -1,4 +1,4 @@
-import { ProviderSettingsManager } from "../services/storage/provider-settings-manager";
+import { ProviderSettingsManager } from "../storage/provider-settings-manager";
 export interface ClineRecommendedModel {
     id: string;
     name: string;
@@ -17,4 +17,3 @@ export interface FetchClineRecommendedModelsOptions {
 }
 export declare const FALLBACK_CLINE_RECOMMENDED_MODELS: ClineRecommendedModelsData;
 export declare function fetchClineRecommendedModels(options?: FetchClineRecommendedModelsOptions): Promise<ClineRecommendedModelsData>;
-//# sourceMappingURL=cline-recommended-models.d.ts.map

package/dist/{llms → services/llms}/configured-provider-registry.d.ts

@@ -25,4 +25,3 @@ export declare class ConfiguredProviderRegistry {
     private require;
 }
 export {};
-//# sourceMappingURL=configured-provider-registry.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { AgentConfig, AgentModel, BasicLogger, ModelInfo } from "@clinebot/shared";
+export declare function resolveKnownModelsFromConfig(config: AgentConfig): Record<string, ModelInfo> | undefined;
+export declare function createAgentModelFromConfig(config: AgentConfig, logger: BasicLogger | undefined): AgentModel;

package/dist/{llms → services/llms}/provider-defaults.d.ts

@@ -4,6 +4,7 @@ import type { ModelCatalogConfig, ModelInfo, ProviderCapability, ProviderConfig
 export interface BuiltInProviderManifest {
     id: string;
     baseUrl: string;
+    modelsSourceUrl?: string;
     modelId: string;
     knownModels?: Record<string, ModelInfo>;
     capabilities?: Llms.CatalogProviderCapability[];
@@ -18,10 +19,10 @@ export interface ProviderDefaults {
     capabilities?: ProviderCapability[];
 }
 export declare const DEFAULT_MODELS_CATALOG_URL = "https://models.dev/api.json";
+export declare function clearPublicModelsCatalogCache(): void;
 export declare function getLiveModelsCatalog(options?: Pick<ModelCatalogConfig, "url" | "cacheTtlMs">): 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>;
 export declare function getProviderConfig(providerId: string): ProviderDefaults | undefined;
 export declare function resolveProviderConfig(providerId: string, modelCatalog?: ModelCatalogConfig, config?: ProviderConfig): Promise<ProviderDefaults | undefined>;
-//# sourceMappingURL=provider-defaults.d.ts.map

package/dist/{llms → services/llms}/provider-settings.d.ts

@@ -214,10 +214,10 @@ export declare const ProviderSettingsSchema: z.ZodObject<{
         international: "international";
     }>>;
     capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        reasoning: "reasoning";
         tools: "tools";
         streaming: "streaming";
         "prompt-cache": "prompt-cache";
+        reasoning: "reasoning";
         "computer-use": "computer-use";
         oauth: "oauth";
         vision: "vision";
@@ -231,9 +231,12 @@ export declare const ProviderSettingsSchema: z.ZodObject<{
     }, 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): ProviderConfig;
+export declare function toProviderConfig(settings: ProviderSettings, options?: ToProviderConfigOptions): ProviderConfig;
 export declare function createProviderConfig(input: unknown): ProviderConfig;
 export declare function safeCreateProviderConfig(input: unknown): {
     success: true;
@@ -242,4 +245,3 @@ export declare function safeCreateProviderConfig(input: unknown): {
     success: false;
     error: z.ZodError;
 };
-//# sourceMappingURL=provider-settings.d.ts.map

package/dist/{llms → services/llms}/runtime-config.d.ts

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

package/dist/{llms → services/llms}/runtime-registry.d.ts

@@ -17,4 +17,3 @@ export declare class DefaultLlmsSdk implements LlmsSdk {
     private applyConfig;
 }
 export declare function createLlmsSdk(config: LlmsConfig): LlmsSdk;
-//# sourceMappingURL=runtime-registry.d.ts.map

package/dist/{llms → services/llms}/runtime-types.d.ts

@@ -82,4 +82,3 @@ export interface LlmsSdk {
     isProviderConfigured(providerId: string): boolean;
     isModelConfigured(providerId: string, modelId: string): boolean;
 }
-//# sourceMappingURL=runtime-types.d.ts.map

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

@@ -1,8 +1,8 @@
-import type { AgentConfig, AgentHooks, ITelemetryService, Tool, ToolApprovalRequest, ToolApprovalResult, WorkspaceInfo } from "@clinebot/shared";
-import type { ToolExecutors } from "../extensions/tools";
+import type { AgentConfig, AgentHooks, AgentTool, ITelemetryService, ToolApprovalRequest, ToolApprovalResult, WorkspaceInfo } from "@clinebot/shared";
 import type { TeamEvent } from "../extensions/tools/team";
-import type { LocalRuntimeStartOptions, StartSessionInput } from "../runtime/runtime-host";
-import type { RuntimeBuilderInput } from "../runtime/session-runtime";
+import type { RuntimeCapabilities } from "../runtime/capabilities";
+import type { LocalRuntimeStartOptions, StartSessionInput } 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";
@@ -12,9 +12,8 @@ export interface PrepareLocalRuntimeBootstrapOptions {
     sessionId: string;
     providerSettingsManager: ProviderSettingsManager;
     defaultTelemetry?: ITelemetryService;
-    defaultToolExecutors?: Partial<ToolExecutors>;
+    defaultCapabilities?: RuntimeCapabilities;
     defaultToolPolicies?: AgentConfig["toolPolicies"];
-    defaultRequestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult>;
     /**
      * Host-level default `fetch` threaded into `ProviderConfig.fetch` so the
      * AI gateway providers can use a custom HTTP implementation.
@@ -25,7 +24,7 @@ export interface PrepareLocalRuntimeBootstrapOptions {
         payload?: unknown;
     }) => void;
     onTeamEvent: (event: TeamEvent) => void;
-    createSpawnTool: () => Tool;
+    createSpawnTool: () => AgentTool;
     readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
     writeSessionMetadata: (metadata: Record<string, unknown>) => Promise<void> | void;
 }
@@ -39,9 +38,8 @@ export interface LocalRuntimeBootstrap {
     extensions: AgentConfig["extensions"];
     hooks: AgentHooks | undefined;
     toolPolicies: AgentConfig["toolPolicies"];
-    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult>;
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
     pluginSandboxShutdown?: () => Promise<void>;
     runtimeBuilderInput: RuntimeBuilderInput;
 }
 export declare function prepareLocalRuntimeBootstrap(options: PrepareLocalRuntimeBootstrapOptions): Promise<LocalRuntimeBootstrap>;
-//# sourceMappingURL=local-runtime-bootstrap.d.ts.map

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

@@ -13,4 +13,3 @@ export declare function listPluginTools(input: {
     providerId?: string;
     modelId?: string;
 }): Promise<PluginToolSummary[]>;
-//# sourceMappingURL=plugin-tools.d.ts.map