**Status: draft. Latest implementation is pushed through `aa14b75d`. The
onboarding flow has been manually verified with Ollama by selecting a
configured local model.**
## Motivation
Interactive local-provider setup had several gaps:
- Ollama / LM Studio setup could ask for an API key but not the endpoint
users actually need to configure.
- Keyless local providers were blocked or confusing in UI paths even
though the flag path could already save base URLs.
- Onboarding could not manually enter a model ID when the provider
returned no models.
- Onboarding model lookup did not consistently use the saved local
provider endpoint, so live Ollama models could be missing.
- Cloud providers were showing editable base URLs too broadly because
the UI inferred editability from the existence of a default base URL.
## Current architecture
### Provider config projection belongs to core
`@clinebot/core` now owns the UI-facing provider config projection
through `getProviderConfigFields(providerId)` in
`packages/core/src/services/providers/local-provider-service.ts`.
- OAuth providers return `{ authMethod: "oauth", fields: {} }` and route
to OAuth login.
- API-key providers return `apiKey`.
- Built-in editable base URLs are intentionally limited to
endpoint-style providers: `ollama`, `lmstudio`, and `litellm`.
- User-added/custom providers with saved endpoints still expose
`baseUrl`, so custom OpenAI-compatible providers remain editable.
- Fields are not marked runtime-required; provider/upstream errors
remain the source of truth.
### Settings-to-runtime conversion stays canonical
The CLI no longer has a custom `ProviderSettings -> ProviderConfig`
projection for model lookup.
- `toProviderConfig(settings, { includeKnownModels: false })` was added
in core.
- `ProviderSettingsManager.getProviderConfig(providerId, options)` now
forwards that option.
- Model lookup paths can keep saved auth/base URL/routing settings while
avoiding bundled `knownModels` that would pollute live local discovery.
### Local model discovery is live-first
Ollama / LM Studio use public keyless model fetchers in
`packages/core/src/services/llms/provider-defaults.ts`.
- Ollama fetches `${baseUrl without /v1}/api/tags`.
- LM Studio fetches `${baseUrl}/models`.
- Public fetchers run even when no config object is passed, falling back
to the provider default base URL.
- When a public fetcher returns models, those results override generated
catalog entries so local pickers show what is actually
installed/available.
### CLI UX updates
The CLI provider-change and onboarding flows now consume the core
projection.
- Bring-your-own-provider onboarding renders `baseUrl` only when core
says it should.
- Base URL is focused first for endpoint-style providers; cloud
providers see only API key.
- The model picker supports manual model ID entry even when models are
present.
- The onboarding model picker also supports manual model ID entry when
the fetched list is empty.
- Existing configured-provider detection treats meaningful saved
endpoint/model/API-key settings as configured for non-OAuth providers
and requires an OAuth access token for OAuth providers.
## Main files changed
| Path | Change |
|---|---|
| `packages/core/src/services/providers/local-provider-service.ts` |
Adds provider config field projection and base URL editability policy |
| `packages/core/src/services/providers/local-provider-service.test.ts`
| Covers cloud, local/proxy, OAuth, unknown, and custom-provider config
field behavior |
| `packages/core/src/services/llms/provider-defaults.ts` | Adds/uses
public Ollama and LM Studio model fetchers with live-first merge
behavior |
| `packages/core/src/services/llms/provider-settings.ts` | Adds
`includeKnownModels` option to canonical `toProviderConfig` |
| `packages/core/src/services/storage/provider-settings-manager.ts` |
Exposes provider config conversion options through the settings manager
|
| `apps/cli/src/tui/components/dialogs/provider-picker.tsx` | Renders
configure fields returned by core |
| `apps/cli/src/tui/components/model-selector/model-selector.tsx` |
Allows manual typed model IDs in the regular model picker |
| `apps/cli/src/tui/components/searchable-list.tsx` | Supports synthetic
searchable rows for typed custom values |
| `apps/cli/src/tui/hooks/use-model-selector.tsx` | Uses saved config
without pre-seeded known models for lookup refresh |
| `apps/cli/src/tui/views/onboarding/*` | Adds BYO base URL config and
manual model ID entry to onboarding |
| `apps/cli/src/utils/provider-auth.ts` | Keeps provider auth helpers
small; no custom provider-config projection |
## Verified
- Pre-commit hook on `aa14b75d` ran:
- `bun run types`
- `bun biome check --no-errors-on-unmatched --files-ignore-unknown=true`
- Additional focused verification run locally:
- `bun -F @clinebot/core test:unit --
src/services/storage/provider-settings-manager.test.ts
src/services/providers/local-provider-service.test.ts`
- `bun -F @clinebot/cli typecheck`
- `bun -F @clinebot/cli test:unit`
- `git diff --check`
- Manual verification: onboarding worked with Ollama and showed the
available local model.
## Notes / residual risk
- TUI keyboard/focus behavior is covered mostly through typecheck/unit
coverage and manual verification rather than deep e2e coverage.
- The base URL allowlist is intentional product policy. Additional
providers such as Requesty can be added later, but should be explicit
rather than inferred from a default endpoint.
- `includeKnownModels: false` is deliberately scoped to lookup flows;
normal runtime config still includes known model metadata for
cloud/catalog providers.
## Out of scope
- VS Code webview parity for `getProviderConfigFields`.
- Custom-provider creation UX.
- Richer retry/error UI when local servers are unreachable.
- Multi-field provider-specific setup forms, such as SAP AI Core.
## Screenshots
<img width="615" height="290" alt="Screenshot 2026-05-01 at 7 00 49 PM"
src="https://github.com/user-attachments/assets/2a5dc945-2204-4263-abb8-eee24fcc1a33"
/>
<img width="619" height="209" alt="Screenshot 2026-05-01 at 7 00 53 PM"
src="https://github.com/user-attachments/assets/eb5e0d38-3442-470f-8916-25d2f919876e"
/>
<img width="541" height="220" alt="Screenshot 2026-05-01 at 7 01 08 PM"
src="https://github.com/user-attachments/assets/1b828c35-c815-44f2-a199-4d0ac32d3861"
/>
<img width="544" height="248" alt="Screenshot 2026-05-01 at 7 01 18 PM"
src="https://github.com/user-attachments/assets/b42853f0-b45d-4901-ae85-31ea5886be40"
/>
## Problem We Are Solving
The current SDK architecture makes client-owned interactive behavior too
easy to implement twice: once for the local runtime path and once for
the hub-backed runtime path.
Examples:
- `ask_question` works in CLI because CLI passes a direct
`defaultToolExecutors.askQuestion` callback.
- In hub mode, capability-backed tools are proxied through
`capability.requested` / `capability.respond`.
- VS Code and Code App currently create hub-backed `ClineCore`
instances, but do not register `askQuestion` / `submit` local executors,
so the core hub transport fix alone is not enough to show app-native
dialogs.
- Code App has separate hub approval plumbing for `approval.requested`,
while local mode uses `requestToolApproval`.
This split causes repeated app work, inconsistent behavior, missed
feature wiring, and bugs where a feature works in local mode but not in
hub mode.
## End Goals
1. App teams implement client-local runtime features once.
2. The same implementation works for local, shared hub, and remote hub
routing.
3. Apps should not need to manually handle hub transport events such as
`capability.requested` unless they are intentionally building a raw hub
client.
4. Core owns transport adaptation:
- local mode invokes handlers directly;
- hub mode advertises handlers and replies to hub capability requests;
- routing uses hub `sessionId`;
- semantic context still carries `conversationId`, `agentId`,
`iteration`, etc.
5. Approval UI and client-local tools should follow the same pattern
where possible, so we do not maintain parallel local/hub UI paths.
## Refactor Standard And Foundation Goals
This codebase is still WIP and does not have production consumers or
real external users depending on legacy behavior. Optimize for a clear,
scalable foundation over compatibility-preserving workarounds.
When making this change:
- Prefer the clean architecture we want long term, even if it requires
updating all call sites.
- Do not keep confusing APIs, duplicated paths, or transitional shims
just because they currently exist.
- If a current abstraction does not make sense, remove it and rebuild
the right one.
- Avoid fixes that only patch the immediate symptom while leaving
local/hub feature duplication intact.
- Future-proofing matters: design the capability layer so future
client-owned features can plug into one path instead of adding another
local/hub special case.
- Keep transport concerns inside core transport layers; keep app UI
behavior in app-owned capability handlers.
- Document any intentional boundary so future contributors understand
where new features should be added.
The goal is not just to fix `ask_question`. The goal is to set up a
maintainable runtime capability foundation for the whole SDK.
<img width="1141" height="737" alt="image"
src="https://github.com/user-attachments/assets/11a50846-28aa-43d1-a663-c823ab84b03a"
/>
## Summary
This fixes regressions introduced across the recent session/history
changes:
- #325 / `917a3ab7` reverted the manifest fallback from #317, so CLI
history could list Code app / VS Code sessions but could not reliably
load their records or messages. Restore manifest-backed `get()` and
`readMessages()` in the local runtime host.
- #296 / `406defe5` added VS Code post-send hydration after live
streaming, which replayed persisted user/assistant messages on top of
the live messages. Remove that replay path.
- The hub/runtime interactive lifecycle from #196/#203 left completed
interactive sessions persisted as `running`, then later cleanup rewrote
them as `cancelled`/hub `aborted`. Mark each interactive turn terminal
when it finishes while keeping the in-memory session available for
future sends.
- Fix hub terminal event suppression so clients receive one
result-bearing `run.completed`, not a duplicate terminal event race.
## Testing
- `bunx vitest run packages/core/src/transports/local.test.ts
packages/core/src/transports/hub.test.ts
apps/cli/src/session/session.test.ts
apps/cli/src/commands/history.test.ts`
- `bun run types`
Note: `packages/core/src/hub/server/boundary.test.ts` could not run here
because `node:sqlite` is unavailable before the changed code is
exercised. X
<img width="2056" height="1298" alt="image"
src="https://github.com/user-attachments/assets/f5d1b353-c428-4279-9fda-1158f03d7976"
/>
In Code App: Expose sidecar commands to set disabled tools and plugins,
read global
settings when listing configs, and return accurate enabled state for
built-in and plugin tools.
Update the rules UI to toggle tool and plugin availability directly so
users can manage active instruction sources from the configuration view.
Add same feature to clite config view
Add sidecar restore handling for persisted session payloads, including
runtime options, tool policies, checkpoint config, and session creation
events.
Remove legacy checkpoint helper logic from chat-session so restore state
is derived through the shared session flow.
List CLI and sidecar history with hydrate disabled to avoid loading full
session details when only summary rows are needed. Update session
helpers and tests to pass the new hydrate option, and replace sidecar
fallback listing with lightweight manifest/store aggregation.
Resolve the fork start configuration before stopping the active session
so forks can be created from either the source session or current
config. Reuse the resolved config when starting the fork and store it
for the new session.
## Summary
- allow updateLocalProvider to recover providers that exist in settings
but are missing from models.json
- seed a minimal local provider registry entry from saved
settings/request fields before continuing the existing update flow
- add regression coverage for settings-only providers
## Background
Surfaced in Kanban when editing a custom OpenAI-compatible provider
(e.g. litellm, mistral) via the Edit Provider dialog. The error
`provider "litellm" does not exist` was returned to the UI.
The out-of-sync state occurs because Kanban writes provider settings
directly via `saveSdkProviderSettings` /
`ProviderSettingsManager.saveProviderSettings` — for example when the
user selects a provider from the settings panel without going through
the Add Provider flow. That path writes to `providers.json` but never
touches `models.json`. So a provider can legitimately have a settings
entry with no registry entry, and `updateLocalProvider` would hit the
missing-entry guard on the next edit attempt.
The same state can also arise from settings imported or migrated from
another Cline install (e.g. VS Code extension).
## Tests
- bun -F @clinebot/core test:unit --
src/services/providers/local-provider-service.test.ts
- bun -F @clinebot/core typecheck
## Notes
- The normal pre-commit hook runs repo-wide `bun run types` and is
currently blocked by unrelated @clinebot/code type errors involving
`source` properties in provider metadata. The core package test and
typecheck pass for this change.
Add pending prompt mutation support across core, hub, and desktop.
- Introduce action-based pendingPrompts API for list/update/delete
- Wire pending prompt commands and events through hub transports
- Add desktop sidecar handlers for editing, steering, and removing
queued prompts
- Add chat queue UI controls for Edit and Undo
- Cover pending prompt mutation behavior in transport tests
Add v0 provider and support provider model overlays
Register v0 as a built-in OpenAI-compatible provider with generated
catalog models and V0_API_KEY documentation.
Extend provider metadata with source tracking and register custom
providers from providers.json so non-built-in OpenAI-compatible
providers are available through the runtime registry. Also allow
models.json entries to overlay models onto existing providers without
requiring full provider metadata.
Refresh generated model catalogs and add tests for v0 registration,
built-in model o
---------
Co-authored-by: Copilot <copilot@github.com>
Add support for detecting and killing stale `code-sidecar` processes in
the `doctor` command. This includes:
- New `listStaleSidecarPids()` function using `pgrep` to find stale
sidecar processes by path pattern `/src-tauri/bin/code-sidecar`
- `staleSidecarPids` field added to `DoctorStatus` type
- `sidecarProcesses` kill count included in `--fix` output report
- Sidecar PIDs displayed in human-readable doctor output
- `--fix` flag now kills stale sidecar targets alongside hub/CLI procs
- Updated hint message to mention stale sidecars when applicable
- Full test coverage for the new sidecar detection and kill behavior
1. Agents package becomes a thin, **stateless** agentic-loop executor
that exports only `AgentRuntime`, `createAgentRuntime`, `AgentRunInput`,
`AgentEventListener` plus type re-exports from `@clinebot/shared`.
2. Everything stateful (conversation store, session identity,
OAuth/connection refresh, loop-detection counters, consecutive-mistake
tracking, team/delegated-agent orchestration, message-builder caches,
hook-file glue) moves to `@clinebot/core`.
3. Every hook, event, and log message that the old package emits must
still fire after the swap
4. `@clinebot/shared` becomes the single source of truth for every type
both packages need; the `packages/agents/src/types.ts` re-export
indirection is deleted.
---------
Co-authored-by: consumer-migrator <consumer-migrator@cline.bot>
Co-authored-by: cline <cline@bot>
Co-authored-by: migration-lead <lead@team.local>
Co-authored-by: impl-consumer-migrator <impl-consumer-migrator@team.local>
Co-authored-by: impl-core-architect <impl-core-architect@team.local>
Co-authored-by: impl-runtime-porter <impl-runtime-porter@team.local>
Co-authored-by: impl-session-fixer <impl-session-fixer@team.local>
Co-authored-by: Copilot <copilot@github.com>
Absorb @clinebot/hub into @clinebot/core/hub. The hub package was a thin
facade plus two client wrappers that all depended on @clinebot/core, so
consolidating eliminates a duplicate spawn path and ~1100 lines of
package overhead.
Moved into packages/core/src/hub/:
- defaults.ts (endpoint defaults + env resolution)
- daemon.ts (spawnDetachedHubServer, ensureDetachedHubServer,
prewarmDetachedHubServer) using the real daemon entry file instead of
the weaker node -e bootstrap that client.ts had inlined
- daemon-entry.ts (CLI arg parsing + startHubWebSocketServer), exposed
as the new @clinebot/core/hub/daemon-entry subpath export
- connect.ts (connectToHub, resolveHubUrl, sendHubCommand,
probeHubConnection), renamed from client.ts to avoid colliding with the
existing NodeHubClient module
- session-client.ts (HubSessionClient)
- ui-client.ts (HubUIClient)
- start-shared-server.ts (startHubServer, ensureHubServer shared-owner
wrappers around startHubWebSocketServer / ensureHubWebSocketServer)
- moved tests: daemon.test.ts, connect.test.ts, ui-events.test.ts
Collapsed the two spawn paths: packages/core/src/hub/client.ts no
longer defines spawnDetachedLocalHub / buildDetachedHubBootstrapCode /
parseLocalEndpointOverride / isBunExecutable / resolveHubModuleUrl.
ensureCompatibleLocalHubUrl now spawns via the unified
spawnDetachedHubServer (real daemon-entry file with --cwd, log file,
port-0 fallback, bun --conditions=development) while keeping its own
build-ID-aware waitForCompatibleHubUrl so ClineCore still rejects
mismatched builds.
## Purpose
This PR hardens the persisted session messages artifact as a canonical
replay/export contract for downstream ATIF conversion. The intent is
that successful replay/export flows can rely on `messages.json` alone
without requiring `hooks.jsonl` for usage/model correlation.
## Context
A real Harbor trial showed normalized content blocks present in
persisted messages, but replay correctness still depended on combining
artifacts in some paths. Existing tests validated helper logic, but not
the full persisted-file contract end-to-end.
## What changed
### 1) Core runtime contract coverage (new)
- Added a **LocalRuntimeHost e2e** test that runs a real turn and reads
the actual persisted artifact from disk.
- The test asserts persisted replay-critical content and metadata:
- message parts: `thinking`, `tool_use`, `tool_result`, final assistant
`text`
- assistant `modelInfo` on turn messages
- assistant `metrics` on terminal turn message with:
- `inputTokens`
- `outputTokens`
- `cacheReadTokens`
- `cacheWriteTokens`
- `cost`
File:
- `packages/core/src/transports/local.e2e.test.ts`
### 2) Explicit failure-path contract coverage (new)
- Added a transport test for failure before assistant output.
- Confirms persisted snapshot remains valid and **does not fabricate
synthetic assistant usage/model metadata** when no assistant output
exists.
File:
- `packages/core/src/transports/local.test.ts`
### 3) Retry/recovery success-path metadata assertion (strengthened
existing test)
- Expanded the auth retry test to assert that after forced refresh +
successful retry, persisted assistant message still contains full
`modelInfo` and `metrics` (including cache token fields).
File:
- `packages/core/src/transports/local.test.ts`
### 4) Sidecar metadata extraction completeness
- Extended sidecar usage metadata extraction to include cache token
fields from persisted `metrics`.
- This keeps sidecar/history adapters aligned with the canonical
persisted metrics shape.
File:
- `apps/code/sidecar/session-data/messages.ts`
### 5) Contract docs clarification
- Updated app docs to explicitly state:
- `~/.cline/data/sessions/<sessionId>/<sessionId>.messages.json` is the
canonical replay/export artifact
- `hooks.jsonl` is auxiliary observability/debug data and not required
for normal replay/export
File:
- `apps/code/README.md`
### 6) Temporary live contract script (kept for dev validation)
- Added an opt-in script that runs:
- `bun run build`
- headless CLI turn
- persisted messages artifact validation for canonical fields
File:
- `scripts/tmp/e2e-headless-messages-check.sh`
## Why this is the right scope
- Strengthens contract guarantees where they matter (core persisted
artifact path).
- Adds end-to-end protection without changing canonical writer schema.
- Avoids introducing dual-authoritative artifacts.
- Keeps hooks as observability/debug rather than replay dependency.
## Validation performed
- `bun test packages/core/src/transports/local.e2e.test.ts`
- `bun test packages/core/src/transports/local.test.ts -t "does not
synthesize assistant usage metadata when a turn fails before assistant
output"`
- `bun test packages/core/src/transports/local.test.ts -t "force
refreshes and retries once when turn fails with auth error"`
- `bun run typecheck` (from `apps/code`)
- `scripts/tmp/e2e-headless-messages-check.sh`
## Non-goals
- No Harbor-specific logic.
- No ATIF exporter implementation in sdk-wip.
- No canonical schema migration.
## Follow-up (optional)
If desired, the temporary CLI contract script can be promoted from
`scripts/tmp` into a first-class CI/live check once the team settles on
cadence and environment gating.
---------
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
Rewrites the apply-patch executor to natively support the documented
GPT-5 freeform patch grammar without requiring shell wrappers. The
legacy `apply_patch <<"EOF"` shell wrapper form is still tolerated for
backward compatibility with older prompts.
Key changes:
- Replace `stripBashWrapper` with `normalizePatchInput` that detects and
handles both freeform and legacy wrapped patch inputs
- Add `NormalizedPatchInput` interface for cleaner internal typing
- Improve validation to reject incomplete patch sentinels early
- Add comprehensive test coverage for all three input variants: freeform
patch body, legacy shell wrapper, and invalid input
- Remove rpc and scheduler packages -Add `packages/hub` as a first-class
workspace package
- Move Scheduling Into The Hub
- Rewire schedule-triggered runtime execution so the hub assigns work to
spokes instead of delegating through RPC services
- Replace RPC schedule CRUD and execution APIs with hub-native command
handlers and shared schedule/event types.
- Replace RPC-first runtime selection with `local` / `hub` / `remote`
runtime modes in `@clinebot/core`
- Clients can attach to a running session from the hub
Introduce a `RuntimeHost` boundary in `@clinebot/core` that unifies
local and RPC-backed execution under a single contract.
- Add `RuntimeHost`, `LocalRuntimeHost`, `RpcRuntimeHost`, and
`createRuntimeHost` as primary exports replacing generic session
host/manager types
- Update ARCHITECTURE.md with new section 2a "Runtime Host Boundary"
describing the concrete implementations and design implications
- Renumber "Session Startup Bootstrap" from 2a to 2b
- Update Local In-Process and RPC-Backed runtime flow steps to reflect
the runtime-host factory pattern
- Add runtime boundary notes to DOC.md clarifying ownership of local
execution, RPC translation, and host selection responsibilities
- `ClineCore` now delegates uniformly to `RuntimeHost` without branching
on local vs RPC behavior; transport-specific logic lives inside concrete
host implementations
- Implement persistent input history navigation using up/down arrow keys
in the interactive TUI.
- Add capability to delete history items in the session list view.
- Refactor hook logging configuration to utilize the
CLINE_HOOKS_LOG_PATH environment variable for improved path management.
- store global hooks audit logs in centralized logs directory
- remove storing per session audit logs
Per-session hook log removed:
SessionArtifacts.sessionHookPath() removed
SessionArtifactPaths.hookPath removed
hookPath removed from StartSessionResult, RootSessionArtifacts,
RpcChatStartSessionArtifacts, ActiveCliSession, SessionRecord output
readHooks() removed from SessionManager interface,
DefaultSessionManager, rpc-session-host, ClineCore
HookSessionContext.hookLogPath removed — hook workers no longer receive
a per-session path hookLogPath removed from HookRuntimeOptions and
createPayloadBase createHookAuditHooks no longer takes hookLogPath
buildEffectiveConfig no longer takes hookPath param registerSession in
rpc-runtime.ts no longer takes hookPath Global log
(~/.cline/data/logs/hooks.jsonl):
ensureHookLogDir default changed from hooks/ → logs/ dir
CLINE_HOOKS_LOG_PATH sandbox env var updated to logs/hooks.jsonl All
audit writes (createHookAuditHooks, appendSubagentHookAudit, stale
session shutdown, appendHookAudit in CLI) now write to
CLINE_HOOKS_LOG_PATH or default logs/hooks.jsonl readSessionHooks in
sidecar reads global log and filters by sessionContext.rootSessionId /
sessionId / taskId Hook events include sessionContext.rootSessionId and
taskId so per-session filtering still works DB backward compat:
hook_path column still written as "" — no migration needed.
- Add /team command for always starting a task as agent team task
- Extracted TUI components for config and history
Wrap /team prompts in user_command tags and render them as slash
commands
- make /team work by default in interactive and non-interactive CLI
flows
- store team prompts as <user_command slash="team">...</user_command>
- strip user_command wrappers before sending user text to the model
- add shared prompt helpers for parsing, normalization, and display
formatting
- render wrapped team prompts as /team ... in CLI, desktop, and code UI
surfaces
- update tests and CLI docs for the new team command behavior
Changes:
- Change CLI session backend resolution to prefer `backendMode: "auto"`
by default so the core layer can connect to or start the RPC runtime
instead of defaulting to direct local SQLite access.
- Keep `--yolo` and `--sandbox` on the local backend by explicitly
forcing local session mode for those runs.
- Add structured CLI logging for the selected session backend (`rpc` vs
`local`) to make backend choice visible in logs.
- Update focused CLI session tests to cover the new default behavior,
forced-local overrides, and backend selection logging.
- Fixed byte-tracking bug in packages/core/src/input/mention-enricher.ts
This PR replaces the Tauri Rust WebSocket bridge and host/ Bun backend with a single TypeScript sidecar process (sidecar/) that imports @clinebot/core directly, serving the Next.js frontend over HTTP+WebSocket. The Rust shell is dramatically simplified to just spawn the sidecar binary/script and proxy its ws_endpoint.
* refactor: unify session message files
- subagents and main agents should have the same file structure
- they should be stored within the same session directory
- fixed issues where not all assistant message includes mettrics data
* moved files
* hide warning
* node 22 required
* refactor: migrate to AI SDK backed handlers for all providers
- Implement an internal gateway-based handler creation pattern to standardize provider runtime behavior.
- Integrate AI SDK-backed execution into the handler flow.
- Update project documentation across `AGENTS.md`, `ARCHITECTURE.md`, `DOC.md`, and `README.md` to reflect the new registry-based architecture.
- Clean up obsolete progress logs in `TESTING.md`.
* refactor
* formatter
* format
* cost total
* default
* cline model list
* lazy-loading
* apply feedback
- Anthropic no longer gets thinking: { type: "adaptive" } unless reasoning was actually requested.
- Explicit upstream cost 0 is now preserved instead of being treated as “missing” and replaced by catalog-pricing fallback.
* revert error output
* check missing env
* feat: add checkpoint restoration and message copying
- Introduce checkpoint restoration logic to allow reverting chat sessions to previous states.
- Implement copy message functionality to enable users to copy text to the clipboard.
- Update the `ChatMessages` component to support these new UI actions.
- Extend `runtime-bridge` to parse and read checkpoint history from session metadata, facilitating the restoration process.
* Fixed the P1 leak by deleting the source live session after a successful restore
* refactor(@clinebot/llms): consolidate subpath imports into main entry point
Simplify imports across the workspace by removing deep imports from `@clinebot/llms/models`, `@clinebot/llms/providers`, and `@clinebot/llms/runtime` in favor of the main `@clinebot/llms` package.
- Update `tsconfig.json` to remove redundant path mappings for LLM sub-modules.
- Update imports in `apps/desktop` and `apps/code` to use the consolidated entry point.
- Refactor provider handler resolution logic to use family-based factories and manifest-driven defaults.
* clean up public interface
* clean up repo path
* update examples
* apply feedback
* feat: checkpoint wip
Introduces the `onBeforeAgentStart` hook to the agent lifecycle. This hook triggers after user input is accepted but before the agent's loop enters its first iteration, facilitating session-scoped setup and preparation.
- Registered `onBeforeAgentStart` in lifecycle handlers.
- Defined `AgentHookIterationStartContext` for the hook payload.
- Added unit tests to verify dispatch timing and context.
- Updated checkpoint tests to include the hook in the execution flow.
* Checkpoint is usable now from the CLI.
* history list now renders a compact pill
* history panel
* chore: trimming stale runtime code
## Summary
This refactor makes `@clinebot/llms` substantially smaller and cleaner without changing its functional role for `agents` and `core`.
The main change is moving `llms` toward the same boundary shape used in `sdk/gateway`:
- one grouped model/provider catalog
- one slimmer runtime registry
- fewer barrel files and duplicate surfaces
- less dead code in handlers and model loading
## What Changed
### Models and provider catalog
- Replaced the old per-provider `models/catalog/providers/*` layout with a single grouped catalog in [packages/llms/src/models/provider-catalog.ts](/Users/beatrix/dev/cline-packages/packages/llms/src/models/provider-catalog.ts)
- Removed the old generated provider-loader path and its script
- Simplified the model registry to use the grouped catalog directly
- Trimmed the exported model surface to the pieces actually used by the repo
### Runtime and provider setup
- Extracted configured-provider state into a dedicated runtime registry helper
- Reduced duplicated provider/model registration logic
- Switched provider defaults/auth/openai-compatible runtime helpers to consume the shared grouped catalog
- Derived built-in provider lists from the catalog instead of maintaining parallel lists
### Public surface cleanup
- Removed stale query modules and oversized barrel files
- Deleted unused top-level catalog shims and public re-export wrappers
- Kept the `@clinebot/llms/models`, `@clinebot/llms/providers`, and `@clinebot/llms/runtime` entrypoints working for current `agents` and `core` usage
### Handlers cleanup
- Removed dead handler wrappers and unused exports
- Deleted the unused `r1-base` handler
- Kept the remaining handler boundaries where they still reflect real protocol/runtime differences
## Why
Before this change, `llms` had multiple overlapping sources of truth for:
- provider metadata
- model catalogs
- configured-provider state
- built-in provider/runtime mapping
That duplication made the package larger and harder to reason about. This refactor collapses those layers into fewer authoritative modules and removes files that only existed to support the older structure.
## Validation
Verified with:
- `bun run build` in `packages/llms`
- `bun tsc -p packages/agents/tsconfig.json --noEmit`
- `bun tsc -p packages/core/tsconfig.json --noEmit`
Targeted `llms` tests around runtime/config/catalog behavior also passed.
* fix: import paths unification
* flatten types export
* fix: normalize provider IDs for consistent model resolution
- Introduced `normalizeProviderId` utility to ensure consistent identification across chat and routine model components.
- Updated `FALLBACK_PROVIDER_MODELS` and `FALLBACK_PROVIDER_REASONING_MODELS` to use `openai-native` instead of `openai`.
- Updated provider resolution logic in `ModelSelector` and `RoutineSchedulesContent` to leverage normalized IDs, ensuring better fallback behavior and improved model selection persistence.
This change prevents discrepancies in provider lookups and ensures that user model selections are correctly resolved even if provider identifiers vary.
* fix: flush code app messages
* fix: code app messages & abort
Now each time a tool call starts, the assistant message ID is cleared. Any subsequent chat_text chunks will create a new assistant message. This gives the correct interleaved layout.
* feat: surface LiteLLM private models in provider catalog listings
**Description**
## Summary
Fixes a regression in the new SDK provider catalog flow where LiteLLM private models were only available during handler creation, but did not appear in the user-visible model listing path.
## Root cause
The new `llms` stack had two separate model resolution paths:
- `createHandlerAsync()` used `resolveProviderConfig()`, which can fetch and merge auth-gated private models
- the provider catalog UI used `getModelsForProvider()`, which only returned static/generated registry models
That meant LiteLLM private models worked at runtime once a handler was created, but were missing from the model lists users browse in settings and related RPC paths.
## Changes
- merge runtime-resolved private models into the provider catalog/model listing path in `@clinebot/core`
- use persisted provider config when resolving models for:
- `listLocalProviders()`
- `getLocalProviderModels()`
- desktop `list_provider_models` command
- CLI `getProviderModels` RPC action
- add regression tests covering LiteLLM private models in both direct model listing and provider catalog listing
- fix host typing/lint issues by:
- updating the stale core `.d.ts` signature for `getLocalProviderModels`
- replacing an explicit `any` cast with `RpcProviderCapability[]`
## Verification
- `bun -F @clinebot/core test:unit -- local-provider-service.test.ts`
- `bun -F @clinebot/core typecheck`
- `bun -F @clinebot/cli typecheck`
- `bun -F @clinebot/code typecheck`
* lazy load providers
listLocalProviders() in local-provider-service.ts (line 265) no longer calls getLocalProviderModels() for every provider, so it no longer triggers private-model fetches during the catalog load. It now only returns provider metadata plus a static registry-based model count. The detailed model list, including LiteLLM private models, is still resolved on demand through getLocalProviderModels() when the UI opens a provider detail view, which matches the existing lazy behavior in settings-view.tsx (line 262).
- Streamlined pure helper functions (e.g., `resolveVisibleApiKey`, `createLetter`) for improved readability.
- Simplified logic flow in `addLocalProvider` by using ternary operators and more concise object assignments.
- Cleaned up type definitions and reduced code verbosity to improve maintainability.
Updated package structure so the model catalog and model types are named by responsibility instead of generic folders:
packages/llms/src/models/providers -> packages/llms/src/models/catalog/providers
packages/llms/src/models/schemas -> packages/llms/src/models/types
I also moved provider settings out of the generic types folder:
packages/llms/src/providers/types/settings.ts -> packages/llms/src/providers/config/provider-settings.ts
test moved to packages/llms/src/providers/config/provider-settings.test.ts
Also fixed session history format issue
This commit introduces a `maxConsecutiveMistakes` option for agents to prevent them from getting stuck in failure loops. If an agent fails to make progress (e.g., due to repeated tool call errors or invalid model output) for more than the specified number of turns, it will stop execution with a new `mistake_limit` finish reason.
Additionally, the error handling for chat turns has been improved across the `code` and `desktop` apps. If a turn fails for any reason, the session's message state is now reverted to the last successfully persisted state. This ensures the UI remains consistent and doesn't lose the context of previous successful turns after an error occurs.
- Implement handling for `notice` event types in the CLI and TUI.
- Introduce `displayRole` and `messageKind` metadata to support specialized message rendering (e.g., recovery notices, system status, errors).
- Update message hydration logic in both TypeScript and Rust cores to preserve and merge notice-related metadata.
- Ensure recovery notices are filtered out when deriving prompts from message history to avoid polluting model context.
Saoud Rizwan