55 commits

Author	SHA1	Message	Date
Haozhe	b3212fd9ab	fix(remote-control): pick credential slot and relay from login region (#3969) ... * fix(remote-control): pick credential slot and relay from login region Global login stores tokens in kimi-code-env-*.json and should use code-rc.kimi.ai; Remote Control always read kimi-code.json and code-rc.kimi.com. Resolve both from the persisted oauth ref. * fix(telemetry): skip the dead global collector and keep shutdown alive The global collector host has no DNS. Drop it from the region profile and skip the send instead of falling back to the mainland endpoint. Keep the shutdown timeout timer referenced so a failed flush cannot exit before the TUI hands the process to the foreground server. * fix(remote-control): require explicit relay origin and drop hardcoded .com defaults	2026-09-23 18:10:47 +08:00
liruifengv	bdf8f7975d	feat(cli): support audience targeting for startup banners (#3868) ... * feat(cli): support audience targeting for startup banners * feat(cli): rename the banner audience field to kfc_audience * chore: revert unintended oxlint autofixes introduced by the merge commit The lint-staged oxlint --fix pass applied warning-level unicorn autofixes to main's files during the merge (prefer-at, prefer-string-replace-all, toSorted, catch-error-name). The catch-error-name rename also renamed object shorthand properties (reason -> error), which no longer matches the declared types and fails tsc. Restore main's versions of these four files; committing with --no-verify so the same autofix does not re-apply. * refactor(cli): type the banner wire shape concretely * refactor(cli): narrow the banner audience fields to literal unions * fix(cli): classify 403 as anonymous and map REGION_OVERSEA in banner audience * refactor(cli): require banner_id for banner entries * fix(cli): drop the banner subtext indent when it cannot fit * fix(cli): avoid cache filename collisions across config endpoints * fix(cli): keep banner loading from rejecting when the token lookup fails	2026-09-23 12:26:43 +08:00
Kai	bb96d80748	perf: cut CLI startup time and memory in the native binary and config reads (#3975) ... * perf: cut CLI startup time and memory in the native binary and config reads Ship the single-file binary with a V8 code cache and a 16 MB semi-space (execArgv), lower dynamic import() to require() in the CommonJS bundle and fail the native build if any survives, and stop the engine from redoing work on every config read: env-bound sections are re-validated only when their env values change, the tool policy service caches the global tools section and refreshes it on section-change events, Ajv instances are built lazily, the macOS product version is read from SystemVersion.plist instead of spawning sw_vers, and the host time zone and date formatter are cached. Measured on the 100-round mock benchmark: CU 4.1-4.4 -> 3.0-3.2, CPU 2.6-2.8 -> 2.0-2.2 core-seconds, peak RSS 550-610 MB -> 370-465 MB, `kimi --version` 0.48 s / 401 MB -> 0.33 s / 311 MB. * fix(native): keep dynamic import() in the code-cached binary and cover plugin entries in smoke Lowering import() to require() broke `__plugin_run_node` (the bundler dropped the node:url binding, and require() cannot load file:// URLs or top-level-await modules), so every plugin MCP server that runs on Node failed under the native binary. The CommonJS SEA main script keeps a working import() with the V8 code cache on Node 24, so the lowering and the lexer guard go away and the native smoke now runs a plugin entry. Also assert that tool policy checks do not read the tools section, and drop the host time zone cache. * fix(agent-core-v2): key the env-bound config memo by section identity A domain re-registered by a different section definition could hit the memo entry left by the previous definition when the validated base and env values were unchanged, returning a value parsed by the old schema.	2026-09-22 16:57:39 +08:00
liruifengv	7d3f88faa4	feat(oauth): parse goods_version from the managed /me profile payload (#3921)	2026-09-19 13:18:31 +08:00
7Sageer	c5ad17f06a	feat(agent-core-v2): support api_key_env for provider credentials (#3762) ... * feat(agent-core-v2): support api_key_env for provider credentials Providers can declare api_key_env = "VAR" in config.toml to read their Bearer token from an environment variable instead of storing it inline. The value is resolved per request (rotation-friendly); an unset or empty variable fails with config.invalid naming the provider and variable. apiKey+apiKeyEnv and apiKeyEnv+oauth are rejected as conflicts. The /models refresh path resolves the same chain (inline apiKey -> apiKeyEnv -> env sub-table); a provider whose variable is unset lands in failed[] without affecting others, and open-platform providers keep the env declaration instead of persisting the resolved secret. Custom registries: applyCustomRegistryProvider consumes the api.json env field — imported providers get apiKeyEnv, the legacy inline apiKey is dropped, and a hand-edited apiKeyEnv survives refreshes (tracked via source.envKey). kimi provider add --api-key and the TUI registry token field are now optional so public registries import without a key. * docs: document api_key_env provider credentials * fix(oauth): preserve hand-edited apiKeyEnv on registry refresh and address review nits * fix(oauth): validate apiKeyEnv conflicts during refresh and address review nits * fix(oauth): mirror apiKeyEnv in the klient provider contract and harden refresh validation * fix(oauth): stop auto-binding registry env names to provider credentials * fix(oauth): preserve hand-edited apiKeyEnv across registry re-imports * fix(oauth): scope apiKeyEnv preservation to the owning registry * fix(agent-core-v2): preserve apiKeyEnv across models.dev catalog re-imports * fix(kap-server): drop apiKeyEnv when the provider update route receives a replacement key * fix(agent-core-v2): replace provider credential fields on TOML writeback * fix(kap-server): normalize whitespace-only api_key in the provider update route * refactor(oauth): unify provider credential rules into shared primitives A new provider-credential module in the oauth package owns the credential precedence chain, the mutual-exclusion conflicts, the user-facing messages, and the write-side tri-state reconciliation; the refresh orchestrator, agent-core-v2 (model-auth, catalog, auth readiness), and the kap-server provider routes compose it instead of re-deriving the rules per layer. applyOpenPlatformConfig now takes credential: {apiKey}|{apiKeyEnv} and merges onto the existing record, so open-platform refreshes no longer drop hand-written fields (customHeaders, the env sub-table) on the inline-key path either, and the refresh's write-then-undo block is gone. Registry imports converge on removeCustomRegistryEntries + applyCustomRegistryEntries (prior-snapshot provenance): the exported capture/restore helpers are gone, the CLI persists a re-import with a single setConfig instead of per-id removeProvider RPCs, and default_model/default_provider survive a re-import whenever they still resolve. kap-server's importCustomRegistry keeps the purge-then-rewrite two-phase replace the config service's raw-merging writeback requires. kap-server create/replace routes accept api_key_env (tri-state, mutually exclusive with api_key), and GET /config plus the provider catalog item expose the binding. A declared-but-unset api_key_env now fails readiness checks with config.invalid (was auth.token_missing), matching request-time behavior. Registry 401/403 without a key prints an authentication hint. * fix(cli): persist registry re-import removals on both harness generations The v2 harness's setConfig deep-merges per domain (retaining omitted keys and skipping undefined defaults), so a shrunk re-import left removed providers and aliases in config.toml and kept a cleared default dangling. The CLI and TUI registry flows now share persistRegistryImport: on v2 the removal phase and the rebuilt records go out as two atomic replaceConfigSections writes (the writeback merges alias fields from raw TOML, so the purge must be persisted first); on v1 the removeProvider RPC cascades the removals before one merge write. defaultModel/defaultProvider snapshots are captured before any removal so the restore works on both paths. * fix(oauth): reject oauth before the legacy env fallback and persist cleared thinking on re-import refreshProviderModels' env sub-table fallback now throws the same apiKey+oauth conflict the chat path rejects, instead of authenticating with the fallback key and rewriting the provider to drop oauth. persistRegistryImport writes the cleared thinking section through the replacement payload, and drops the v1 fallback branch — registry imports always persist through replaceConfigSections, so the removal phase no longer needs per-id removeProvider RPCs. * chore: consolidate provider credential changesets into one entry * chore: trim changeset to the api_key_env entry * fix: harden provider credential status and registry imports * fix(oauth): expose browser-safe provider credential rules * fix(node-sdk): replace serialized provider credentials * fix(oauth): reject credential conflicts during refresh * fix: harden custom registry re-imports Reject reserved provider collisions and credential endpoint drift before mutation. Replace registry-owned sections atomically with compare-and-set guards, and carry the replacement contract through klient and node-sdk. * refactor(registry): centralize custom registry import ownership Route CLI and TUI imports through the engine via the typed SDK and Klient operation. Keep registry replacement policy inside the engine and preserve credential edits made while fetching the registry. Cover the shared entry point with real configuration storage and memory/IPC transport tests. * test: trim redundant api_key_env and registry-import coverage * fix(cli): reuse the stored registry key on keyless re-import Both first-party clients encoded "no key given" as an empty string, but the engine's fallback chain (options.apiKey ?? registryKeyFromExisting) only reuses the key parked in the provider's source blob when the option is undefined. A keyless re-import of a private registry therefore went out without an Authorization header and failed with 401 from the CLI and the TUI dialog, while the kap-server REST route (which passes undefined) reused the stored key fine. Pass undefined from the CLI handler and the TUI import dialog instead of normalizing to ''. The dialog's result type now marks apiKey optional, matching the engine contract. * test: pin CAS rejection and credential-conflict behavior The coverage trim went past redundancy in three places, leaving the PR's headline guards untested. Restore the compare-and-set rejection path (guarded value changed on disk -> retry error, no write) and the absent-section guard normalization in config.test.ts, the apiKey+apiKeyEnv / apiKeyEnv+oauth conflict rejections at runtime resolution (modelAuth) and at the refresh orchestrator (discovery, with per-provider failure isolation), and the open-platform refresh through api_key_env proving the resolved secret never lands in the provider record. Also add the first direct unit tests for the shared declaredProviderCredential / reconcileProviderCredentialUpdate primitives. * refactor(oauth): share reserved provider id rules between import and refresh * Delete .changeset/registry-import-concurrent-credentials.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * test: trim cross-layer duplicate registry and credential coverage --------- Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-09-17 22:02:53 +08:00
7Sageer	31f1b6824d	fix(agent-core-v2): mark MCP servers needs-auth when a tool call returns 401 (#3846) ... * fix(agent-core-v2): mark MCP servers needs-auth when a tool call returns 401 * fix(agent-core-v2): cover retried MCP calls with unauthorized handling and recheck entry after close * fix(agent-core-v2): bind MCP unauthorized reports to the originating client * fix(agent-core-v2): invalidate rejected MCP OAuth tokens when entering needs-auth * fix(agent-core-v2): preserve concurrent MCP OAuth grants and recheck entry after credential awaits * fix(agent-core-v2): flip MCP servers to needs-auth before invalidating rejected tokens * fix(agent-core-v2): compare-and-clear rejected MCP OAuth tokens and tolerate cleanup failures * refactor(agent-core-v2): move rejected-grant handling into the MCP OAuth service * fix(agent-core-v2): compare MCP OAuth grant age with the scheduler clock * fix(agent-core-v2): reject future timestamps from the concurrent MCP grant window * fix(agent-core-v2): distinguish concurrent MCP grants from freshly rejected ones * fix(agent-core-v2): ignore application-level MCP errors in the unauthorized sniff * test(agent-core-v2): trim MCP unauthorized tests to the core contract * Delete .changeset/mcp-oauth-clear-if-current.md Signed-off-by: 7Sageer <sag77r@hotmail.com> --------- Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-09-17 11:12:20 +08:00
liruifengv	bb0c66a15b	feat(oauth): switch the managed usage payload to the quota model (#3787) ... The platform /usages payload now serves per-window used ratios (goods_version, a usages map of limit5h/limit7d/monthTotal/monthCode entries with used_ratio/reset_time, and boosterWallet) instead of absolute used/limit rows. - oauth: parse and fetch the quota model; keep the platform helpers - toolkit / agent-core-v2 / node-sdk: getManagedUsage returns the quota - kap-server: /oauth/usage passes the camelCase quota shape through (the legacy snake_case wire is gone) - TUI /usage: plan rows are presence-driven from the quota payload; the monthly row carries a kimi/code breakdown line - docs: server-api reference updated for the new response shape	2026-09-15 13:33:20 +08:00
Haozhe	9296e68770	feat: declare dynamically_loaded_tools for official models and add per-server MCP deferred disclosure (#3667) ... * feat(oauth): add the dynamically_loaded_tools capability from the official models endpoint * feat(agent-core-v2): support per-server deferred disclosure of MCP tools * feat(klient): mirror per-server deferred in the MCP config contract * fix(agent-core-v2): honor per-server deferred for the needs-auth MCP tool * fix(agent-core-v2): register select_tools regardless of the profile tool allowlist * feat(agent-core-v2): default MCP servers to inline tool disclosure unless deferred is enabled	2026-09-14 19:42:56 +08:00
Grapedge	260ac3faad	feat(cli): apply cloud-recommended default thinking effort (#3616)	2026-09-07 21:21:34 +08:00
Haozhe	bb16383aa1	refactor: remove the legacy agent-core v1 package (#3542) ... * refactor: remove the legacy agent-core v1 package Delete packages/agent-core (v1 engine) and migrate node-sdk fully onto agent-core-v2: - node-sdk owns its public contract (error protocol, KimiConfig schema and file IO, process-global logging facade, telemetry client interface); event and interaction types re-export from @moonshot-ai/protocol or agent-core-v2 - createKimiHarness is now the single harness factory, backed by the v2 client; the v1 SDKRpcClient is deleted - CLI and vscode run agent-core-v2 unconditionally; KIMI_CODE_LEGACY_FLAG and useAgentCoreV1 are removed - the wire.jsonl replay fold moves into agent-core-v2's replayBuilder (foldWireRecords), and the v2 journal now persists tool-call display so replay restores diff/todo displays - TUI engineV2 branches collapse to the v2 path * test(vscode): retry temp-dir teardown in replay-resume integration test	2026-09-07 11:17:51 +08:00
Haozhe	8f2c60b328	feat(agent-core-v2): support openai_responses protocol for kimi provider (#3375)	2026-08-31 14:51:21 +08:00
liruifengv	2bf7ed22d7	feat(auth): split model readiness from sign-in state in /api/v1/auth (#3293) ... * feat(auth): split model readiness from sign-in state in /api/v1/auth GET /api/v1/auth now reports models_ready (the default model resolves against the configured catalog, providerless and env-injected models included) instead of the compound ready flag, and no longer carries default_model — config values are served by /config alone. The v1 summary schema follows. OAuth managed-model refreshes now heal a lost default model: the refresh snapshot includes defaultModel, so an unchanged catalog with a missing default still lands the write-back branch and re-selects one. The refresh also rebases onto a fresh config read after the remote fetch, so a model or thinking change made during the fetch is no longer overwritten. The shared discovery refresh path (scheduler, POST /providers/{id}:refresh) heals the default the same way. Config changes are now published to WS clients on every write path: a debounced+trailing publisher bridges IConfigService section changes to ConfigChanged with camelCase changedFields and a full config projection, and the broadcaster forwards event.config.changed and event.model_catalog.changed (both previously published but never delivered). All three event types are registered in the event unions, so session_event parsing and AsyncAPI describe them. BREAKING CHANGE: GET /api/v1/auth drops the ready and default_model fields in favor of models_ready; event.config.changed's changedFields is now camelCase domain names instead of the raw snake_case request keys (v1 summary schema follows). * fix(kap-server): expose the session model in session list projections GET /api/v1/sessions hardcoded agent_config.model to '' and the v2 projection had no model field at all, so clients could only learn a session's model via the post-select /status read — which races the WS replay and often never lands. SessionFacts now carries the live session's model (same source as the snapshot route), toWireSession emits it, and the v2 activity domain gains a nullable model field. * fix(kap-server): gate prompt submission on the effective session model The submit gate called ensureReady() with no override, so it only ever validated config.default_model: a session with a bound model (or a prompt carrying one) was rejected with 40113 whenever default_model was missing or dangling. Pass the effective model (request model, then the agent profile's bound model, falling back to default_model inside ensureReady) on both the prompt submit and btw routes. * fix(agent-core-v2): honor defaultProvider in model readiness resolution resolveModelForReady stopped at the flat baseUrl fallback, so a model that omits provider/providerId and relies on the configured defaultProvider resolved at runtime (ModelCatalog.resolveProviderContext falls back to it) while /api/v1/auth reported models_ready:false and the send gate rejected the prompt. Mirror the runtime order (providerId -> provider -> defaultProvider -> flat baseUrl) and pass the configured default provider from both readiness callers. * fix(kap-server): redact inline model credentials from config responses toConfigResponse only redacted the providers section, so a model's inline apiKey/oauth rode GET /config verbatim and, via the new event.config.changed publisher, every WS connection plus the persistent event journal. Project the models section the same way: strip credential fields and report has_api_key. * fix(agent-core-v2): honor defaultProvider in ensureReady credential checks The readiness phase learned the defaultProvider fallback, but the credential phase right after still derived the provider only from the model's explicit fields: a model omitting provider/providerId passed readiness yet missed the default provider's apiKey/OAuth material and prompts failed with auth.token_missing. Mirror the same provider chain (providerId -> provider -> defaultProvider) when resolving credentials. * fix(kap-server): validate the model a profile bind will select at the prompt gate The gate validated the session's current model even for a prompt that switches profile without a model — but bind falls back to defaultModel in that case, so a stale session model drew a misleading 40113 before bind could run. Gate on bind's selection order instead: the request's explicit model, then the default on a profile switch, then the session's bound model. * fix(kap-server): redact inline service credentials from config responses The earlier redaction covered providers and models, but toConfigResponse still passed the services section through verbatim: inline or env-injected apiKey, oauth references, and credential-bearing customHeaders rode GET /config and, via the event.config.changed publisher, every WS connection plus the persistent event journal. Project services the same way: strip apiKey/oauth into has_api_key and report only the header names as custom_header_keys (the MCP envKeys/headerKeys convention). * fix(kap-server): keep unlisted config domains through event validation The config.changed broadcaster returned the zod-parsed config, which strips domains absent from configResponseSchema (mcp, identity, model_catalog, image, tools, token_counting): changedFields named them while the advertised full snapshot no longer matched GET /api/v1/config. Make the response projection passthrough (defineRoute validates only requests, so REST responses are unaffected). * fix(agent-core-v2): use the exact configured key for model readiness lookups resolveModelForReady trimmed the model id before the models-table lookup while ModelCatalog and ensureReady use the configured string as an exact record key: a whitespace-padded default_model was reported ready and then crashed the submit gate with an internal error instead of 40113, and a legitimate key containing spaces was reported dangling. Trim only rejects blank values now; the lookup always uses the raw key. * fix(protocol): keep unlisted config domains in the shared event projection The shared configResponseSchema stripped domains it does not enumerate (mcp, identity, model_catalog, image, tools, token_counting, subagent, secondary_model), so event.config.changed parsed through agentEventSchema named them in changedFields while omitting their values. Make the shared projection passthrough like the kap-server-local one. * fix(agent-core-v2): use the exact default_provider key in readiness checks The defaultProvider fallback trimmed the configured value before the providers-table lookup while ProviderService and ModelCatalog use the configured string verbatim: a whitespace-padded default_provider could build successfully yet report not-ready (40113), or report ready for a provider runtime resolution cannot find. Trim only rejects blank values; the lookup uses the raw key. * chore: sync web dist from code-app Rebuild the bundled web UI against this branch's /auth contract (models_ready, no ready/default_model): the previous bundle still read the old fields and stayed in the not-ready flow against this server. code-app: 000d2594ff3e95b553be326126bab3f939b62944 * Revert "chore: sync web dist from code-app" This reverts commit 9400a24a03863b3e8b780dda251540f824f02f3a. * fix(oauth): rebase the default selection after the refresh fetch A provider refresh snapshots the config before the remote catalog fetch; when the user selects a default model while the fetch is in flight, the stale snapshot's empty default made an otherwise unchanged catalog enter the write path and the self-heal persisted the generated default over the user's newer selection. Each branch now re-reads and rebases the default/thinking selection after its fetch, before cloning, comparing, or writing. * style(kap-server): pass optional custom_header_keys without conditional spread	2026-08-28 15:53:56 +08:00
liruifengv	7066950653	fix(oauth): show a cancelled state when authorization is denied on the web page (#3291) ... * fix(oauth): show a cancelled state when authorization is denied on the web page * chore: drop the changeset and the dist-web sync from this PR	2026-08-27 16:20:48 +08:00
7Sageer	d723cc47ee	feat(agent-core-v2): add the unified MCP management plane (#3002) ... * feat(agent-core-v2): add the unified MCP management plane Port the v1 MCP management plane (#2858) onto the v2 DI x Scope engine: - App-scope IMcpOAuthService shared by every workspace handler and session overlay: credential events, single-flight refresh, proactive refresh timers, OAuthTokenTransaction-serialized writes, offline tokenState, shutdown. Providers read tokens through the store so grants written or revoked by another process are honored immediately; http/sse transports ride the transaction fetch. - IMcpConfigStore: the single write point for the user-level mcp.json over the filesystem byte store, byte-identical to v1's format, with per-entry validation, name normalization, __proto__-safe parsing, a mutation tail, and an onDidWrite event. - IMcpRegistryService: the unified read view over the layered config files (with per-entry origins) and plugin manifests (full descriptors incl. disabled, with provenance); collisions stay visible and runtime resolution ranks an enabled plugin above the file layers. - IMcpManagementService: guarded CRUD, connection-test probes, the locator-addressed inspection/auth-status surface, and locator-addressed OAuth begin/complete/cancel/reset with ambiguity rejection. Engine services stay ungated; the mcp_management flag gates the edge exposure. - Workspace runtime aligns with v1 precedence (an enabled plugin entry wins over the file layers, shadows revive), and management writes reload immediately via onDidWrite instead of the watch debounce. - node-sdk v2 facade delegates to the engine service (deleting its in-process duplication); kap-server exposes /api/v2/mcp/* and klient gains global.mcp.*, both flag-gated. * fix(agent-core-v2): settle early and cancelled MCP OAuth callbacks * refactor(node-sdk): write session MCP persists through the engine config store * refactor(agent-core-v2): strip comments from the MCP management plane files * fix(agent-core-v2): harden MCP management readiness * test(node-sdk): cover offline MCP auth statuses * fix(agent-core-v2): isolate stdio MCP probes * fix(klient): normalize MCP OAuth errors * fix(mcp): honor workspace CRUD context and refresh timing * fix(mcp): drain OAuth refreshes during shutdown * fix(mcp): guard CRUD across registry collisions * fix(mcp): canonicalize trust and refresh scheduling * fix(mcp): close callback listener on setup failure * fix(mcp): preserve trust and oauth behavior * fix(oauth): retain refresh tokens after SDK saves * fix(oauth): stop proactive sweep during shutdown * fix: await MCP workspace reconciliation * fix: serialize MCP OAuth and trust cleanup * fix: reject persisted MCP plugin collisions * fix: reconcile MCP workspaces concurrently * fix(mcp): check project-layer trust at the queried cwd * fix(mcp): expire abandoned OAuth flows after an idle timeout * fix(mcp): keep mutable user entries writable past read-only collisions * fix(mcp): abort the auth::complete long poll on client disconnect * fix(mcp): map OAuth flow failures to wire code 40929 * docs(mcp): note probe credential effects and plane semantics * chore: add the SDK changeset for MCP management cwd params * feat(mcp): expose the management plane without the experimental flag * fix(mcp): preserve auth management semantics * fix(agent-core-v2): bound MCP OAuth auth-server requests and the shutdown drain * fix(node-sdk): restate engine MCP management errors as KimiError * fix(agent-core-v2): preserve shared OAuth flow lifetime * fix(agent-core-v2): close MCP OAuth cancellation and shutdown gaps - bound the authorization-code exchange with the request timeout and the flow/caller abort signals, and make shutdown abort hung begins and close their callback listeners immediately - keep token-transaction effect coalescing intact when durable tokens carry local stamps, and serialize the meta sidecar and tokens-saved event with the token write inside the lock - drain transport-driven grants, their trailing SDK save continuations, and interactive completions during shutdown, with a cancellable deadline * fix(agent-core-v2): harden MCP probe runtime resolution and path handling - resolve stdio probes against the containing workspace's runtimes and reject out-of-workspace probes for non-local runtime_id instead of silently falling back to a local-only transient registry - share one Windows-aware path canonicalization across the config loader, registry trust lookup, trust records, and workspace matching - keep a UTF-8 BOM fatal for the user-level mcp.json store, matching the workspace loader and v1 - validate completeServerAuth timeoutMs bounds at the engine boundary * fix(agent-core-v2): await workspace MCP reconciliation on plugin mutations Plugin install/enable/disable/remove now resolve only after reload listeners settle their waitUntil work, so a disabled plugin's MCP server cannot linger connected and an enabled one is visible to the next session, matching v1. The workspace MCP consumer joins the barrier while keeping its log-only failure tolerance; delivery is awaited outside the mutation queue to avoid self-deadlock through consumption reads. * fix(mcp): close the SDK, klient, and server edge gaps - register mcp.oauth_failed in the v1 error registry and restate unknown engine codes as internal instead of minting undeclared KimiError codes - route persisted session MCP adds through the same KimiError restating as the global management methods - give the klient IPC transport a per-call timeout so completeAuth's long poll outlives the 30s default, clamped to the Node timer ceiling, and align the contract timeoutMs upper bound with REST - await the MCP OAuth service shutdown directly in SDK and server close before scope disposal * fix(agent-core-v2): keep file-over-plugin MCP precedence and harden the plane - Revert the v1-style precedence flip: the workspace merge and resolveRuntimeTarget keep the file entry above plugins (v2's historical order; the divergence from v1 is deliberate and documented in AGENTS.md). - Guards follow each engine's winner: project-layer entries stay read-only, while plugin entries never block user-level writes, so a file entry may shadow a plugin and removing it revives the plugin. The parity suite pins the engine split for a persisted session add over a plugin-owned name. - inspectServers tolerates a wire-encoded null targets array: klient's ipc transport sends null for an omitted leading optional argument. - Fire the config store's onDidWrite after the mutation tail settles, so a write listener can re-enter the store without deadlocking the queue; concurrent-mutation and re-entrant-listener tests pin both contracts. * chore: condense the sdk MCP changeset to one sentence * test(node-sdk): pin verify:false auth-status parity and fix the sdk changeset	2026-08-22 18:22:37 +08:00
liruifengv	3d7762003a	feat(kimi-code): support two OAuth login endpoints (#2862) ... * feat(kimi-code): add China/International region selection for OAuth login - Add region profiles (cn/overseas) and resolver in @moonshot-ai/kimi-code-oauth: env override → persisted login host → install-channel marker → default cn - /login now offers Kimi Code (China) / Kimi Code (International); the CLI login entries (kimi login, kimi acp --login) accept --region cn|overseas - Update/plugin/site/telemetry endpoints derive from the selected region; plugin trust list covers both .com and .ai hosts - kap-server: POST /oauth/login accepts an optional region; new GET /oauth/region * fix(oauth): keep an explicit default-slot login ahead of the install marker A China login persists no oauthHost (the default credential slot carries no host trace), so after switching back from International the resolver fell through to a stale overseas install marker. Treat a persisted default-slot oauth ref (key === oauth/kimi-code) as an explicit-cn signal that outranks the marker; getRegion() on the v2 side mirrors it. * fix(agent-core-v2): thread the default-slot key through capability region resolution Capability installs resolved the region from the persisted oauthHost only, so an explicit China login (which persists no host) lost to a stale overseas install marker. Pass the oauth ref key through as well, matching getRegion(). Also move the region contract notes into the auth.ts file header per the package comment convention. * fix(agent-core-v2): honor the region-marker opt-out for the telemetry endpoint Hosts that set KIMI_CODE_REGION_MARKER=off (the desktop embedded server) skip the install marker in getRegion(), but the default telemetry endpoint still consulted it, so a stale overseas marker could split the reported region from the telemetry destination. * feat(cli): show region site domains in login platform selector * chore: reword oauth login changesets * fix: honor the region marker opt-out in the CLI and capability resolvers * refactor: rename login region values to mainland-cn and global * fix: keep the --region help text in English * fix: simplify the --region help text to site domains * feat: drop the suggested login platform order * feat: split a browser-safe region profile table out of the region resolver * Revert "feat: split a browser-safe region profile table out of the region resolver" This reverts commit a037b1143eeb8adcbb349264b5bd940f3ef9c0b3. * fix: read the install marker from the bootstrapped home directory * fix: resolve the server plugin marketplace from the active login region * feat: expose the login region option through the klient auth facade * fix: drop a comment from the v2 auth region test * fix: keep scoped base-only logins on their environment for a bare login * fix: invalidate the region cache on the provider-manager logout path * fix: route client-config fetches through the active region profile * fix: resolve the telemetry endpoint per flush so a login region switch applies in-process * test: expect the telemetry endpoint resolver in the CLI init assertions * fix: resolve the default telemetry endpoint from the bootstrapped home * chore: reword the oauth login changeset around the two login methods * chore: trim the oauth login changeset to the headline * feat: let hosts override the region marker env through the server bootstrap env bag	2026-08-20 11:24:02 +08:00
github-actions[bot]	13d86f8b7b	ci: release packages (#2881) ... Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2026-08-14 20:51:17 +08:00
liruifengv	4a93f70aa2	feat(oauth): add browser-safe ./device subpath export (#2885) ... * feat(oauth): add browser-safe ./device subpath export * fix(oauth): guard env override lookup for browser consumers * chore(oauth): add changeset for ./device subpath export * fix(oauth): resolve env overrides via globalThis for DOM-only consumers	2026-08-13 18:26:10 +08:00
7Sageer	6be26978b1	feat: auto-generate session titles via the managed chat_title tool (#2351) ... * feat: auto-generate session titles via the managed chat_title tool With the auto-title experimental flag on and a managed OAuth login, the session title is generated from the first prompt, replacing the truncated-prompt easy title. A custom title set by the user is never overwritten, and generation failures degrade silently to the easy title. - oauth: fetchChatTitle for the platform /tools chat_title method - agent-core (v1): fire-and-forget generation on the first prompt - agent-core-v2: sessionTitle domain watching the easy-title event - kap-server: POST /sessions/{id}/title/generate for manual regeneration * fix: harden auto-generated session titles * fix: preserve managed title request headers * Pair auto-title endpoint overrides with matching OAuth credentials * fix: preserve legacy custom session titles * fix: preserve automatic session title invariants * refactor: keep only the on-demand session title generation interface Drop the automatic wiring on both engines: the v1 (TUI) first-prompt trigger and the v2 easy-title event watcher. SessionTitleService's generateTitle() stays as the single on-demand entry point behind the auto-title flag, backing the kap-server title/generate route. The changeset goes away too: with no shipped consumer, the remaining surface is not user-perceivable. * feat: generate session title from the first recorded prompts Record up to three sanitized natural-language prompts in session metadata (skill / plugin activations excluded) and compose the chat_title input as order-labeled lines truncated to a 1000-char budget, falling back to lastPrompt for sessions without recorded prompts. * test: make session title race tests deterministic * Generate session titles from agent conversation history * fix: reject title generation without user prompts * fix: bound session title prompt history * feat: enable session title generation without an experimental flag * test: cover session title generation through the public REST path * feat: request session title generation from the TUI after each turn * Retry auto title generation for prompt-derived session titles * feat: record session title source and harden the generation lifecycle - persist titleSource (prompt/generated/custom); skip auto-generation over an already-generated title unless forced, and never over a custom one - plumb the force option from the core through klient and node-sdk to the REST title/generate endpoint - drop the title write-back when the session scope was superseded mid-flight, and retry once with a force-refreshed token on a 401 - stop closing sessions a concurrent public resume has handed out in the temporary resume paths (generateSessionTitle, renameSession) - accept session.meta.updated patches without lastPrompt in klient event validation, and emit exactly one metadata event per applied title - remove the retired prompts field heal and drop the changeset (the behavior is only perceivable on the experimental v2 engine) * chore: follow agent-core comment convention * fix: ignore stale session title callbacks * fix: preserve session title state invariants * refactor: seed session lifetime instead of querying the workspace handler The session title service must not depend on the Workspace-tier handler registry. The handler now seeds each session scope with an abort signal, fires it synchronously when a close begins, and the title service carries the signal on its request, drops the write-back once aborted, and drains an in-flight generation through the onWillCloseSession hook. * fix: honor the legacy custom title marker over a stale titleKind A v1 rename spreads the original state.json document, so an explicit isCustomTitle: true can travel with a stale titleKind. The explicit marker now wins on load, and every persist double-writes the derived isCustomTitle so released v1 builds keep recognizing the custom title. * fix: serialize session access and expose the session title state The temporary resume/rename/close paths and the public lifecycle operations now share a per-session queue, so a public resume can never receive a handle whose cleanup close is already in flight. Session summaries carry the canonical title state, letting the TUI skip title generation for sessions whose title was already generated or customized instead of re-asking after every turn. * chore: add session title changesets * fix: close the session lifecycle races around close and title generation A close/archive is now tracked in a closing registry from its first synchronous step until disposal: get/list hide the closing session and resume waits the close out instead of returning the doomed handle, and fork waits out an in-flight source close. The title service tracks the whole generateTitle call as the unit the close hook drains, and the generated-title write re-checks the lifetime signal inside the serialized metadata update so an abort landing while the update is queued still vetoes the write-back. * feat: project the session title state through the session index readSummary and the read-model mirror carry titleKind, so listSessions reports the same canonical title state as a resumed session's summary. * fix: serialize the remaining session access paths in the SDK forkSession and explicit-id createSession join the per-session queue, and the harness resume fast path skips a session whose close is in flight instead of returning the closing facade (which then failed every call with session.closed); its late onClose no longer evicts the fresh session either. The harness rename event now carries isCustomTitle so the TUI stops asking for a generated title after a local rename. * fix: detach the external abort listener once the chat title request settles * fix: harden the session close/archive and create/fork lifecycle The closing registry now records the operation kind: an archive arriving during a plain close waits it out and lands the archived flag on the persisted document instead of riding the close to success, and a failing close hook no longer strands a half-closed session — the teardown always completes while the hook error still reaches the caller. create and fork reserve their target id synchronously with the existence check, so a concurrent create/fork of the same id loses up front and can never tear down the winner's scope or directory. * fix: keep forced title regeneration independent and veto queued title writes atomically Plain generateTitle calls still coalesce onto one shared in-flight generation, but a forced regeneration always runs on its own so it is neither swallowed by a plain call's early exit nor shares its result; the close hook drains every active generation. The allowWhen veto now runs inside applyUpdate with no await between the check and the mutation, so an abort cannot slip into the gap. * fix: carry the title state through the session index and klient contract The klient session summary schema no longer strips titleKind, and the index readSummary honors a legacy isCustomTitle marker over a stale titleKind, so listSessions reports the same canonical title state as a resumed session. * fix: coalesce harness resumes, lock fork targets, and cover the title state end to end Concurrent public resumeSession calls now share one in-flight resume and one facade instead of building parallel facades over the same engine handle (a close on either would strand the other). forkSession takes the source and target queues in sorted order, so fork(A->X) is atomic against create(X) and fork(B->X) without an ABBA deadlock. The emitMetaUpdated patch type drops the redundant undefined union, and the SDK tests now cover facade coalescing and the title state across list and resume. * fix: serve the canonical title state from the session index and version the read-model cache readSummary now derives the title state with the same priority chain as the metadata document's canonical normalization (explicit custom marker, valid titleKind, legacy false marker, customTitle, plain title), so list and resume agree on legacy documents too. Read-model cache entries carry a summary version stamp and older-stamped entries are treated as cold misses, so an upgraded reader never serves a stale-shaped summary. * fix: let the newest title generation request win the write-back A forced regeneration could be followed on disk by an earlier plain call's slower backend response. Each generation now carries a monotonically increasing sequence (assigned only once a request actually proceeds to generation), and the serialized metadata write is vetoed unless the writer is still the newest request. * fix: fold archive into close and own the create/fork rollback An archive requested during a plain close is applied through the live metadata during the teardown (or lands on the persisted document when it arrives too late or the close fails), publishes the archived event, and works on cold sessions too. A resume waiting on a failed close retries instead of propagating the hook error, the teardown completes even when the agent drain fails, and the create/fork rollback only ever removes its own handle — a loser of the reservation race can no longer tear down the winner's live scope. * fix: key harness resume coalescing by the full input Concurrent resumes only share a facade when their inputs match — a caller passing different dirs, replay, profile, or kaos options gets its own resume instead of having its options silently dropped. * refactor(agent-core-v2): drop session close-awareness from title generation Auto title is best-effort: a generation racing session close no longer cancels its fetch or guards its write-back, so the per-session sessionLifetime AbortSignal seed, the onWillCloseSession drain, and the close-time invalidation go away. The newest-request-wins write-back predicate stays. * Delete .changeset/sdk-session-title-kind.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * refactor(session-title): drop the unused force regeneration path Nothing calls force: with it gone, plain calls always coalesce onto the shared in-flight generation, so the generation sequence and the caller-supplied allowWhen veto lose their only purpose and go with it. The title/generate REST route takes no body anymore. * refactor(agent-core-v2): drop the title state projection from the session index The listed-session titleKind had no consumer: the TUI's title-generation gate seeds from the resumed summary, which reads the live metadata document, and the kap-server REST wire never carried the field. Removing the projection also retires the read-model summary version stamp (the remaining shape is fully field-checkable) and the duplicate title-kind derivation that had to stay in lockstep with sessionMetadata. The klient list contract and the node-sdk list mapper drop the field with it; the resumed/live summary still reports the canonical title state. * refactor(agent-core-v2): inline the transcript live-tail merge into messageLegacy mergeContextTranscriptWithLive had a single caller; move the logic into messageLegacyService as the private mergeLiveTail and drop the export. * refactor(agent-core-v2): drop the closing registry from the session lifecycle Auto title no longer consumes close-awareness, so the machinery goes back to the simple forms: close/archive run straight through, resume no longer waits out an in-flight close, create/fork drop their target reservation, and a cold archive is a no-op again. Reverts the behavior of e7c397a7c and cd1cea0fd on top of the sessionLifecycle rename. * fix(agent-core-v2): complete the HostRequestHeaders migration in the title test The main merge reduced #/kosong/model/hostRequestHeaders to the pure port contract; define the test's headers as a plain value matching it and tidy the SDK test import grouping. * fix(node-sdk): mark resume telemetry field ignored * feat(tui): request the session title as soon as a prompt is accepted * fix(agent-core-v2): drop the numbered user prefixes from the title request input * refactor(tui): ask for the session title only once per session attach * refactor(tui): drop the automatic session title trigger Keep the capability only: the engine-side title generation service, the POST /sessions/{id}/title/generate route, and the SDK generateSessionTitle method stay; the TUI no longer requests a title on prompt accept or on session attach. The changeset now covers the SDK capability instead of a CLI-facing auto title. * Delete .changeset/session-title-generation.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * feat(agent-core-v2): add forced session title regeneration ISessionTitleService.generateTitle and the metadata write-back take an optional force flag that bypasses the custom/generated guards, so an explicit user request (the desktop/web rename field's Gen Title action) can overwrite any current title; the applied title is marked generated. Forced calls skip the in-flight coalescing, and a forced write is plain last-writer-wins. kap-server's POST /sessions/{id}/title/generate accepts an optional { "force": true } body; klient and the node-sdk plumb the option through (GenerateSessionTitleInput.force). Also renumber SESSION_TITLE_UNAVAILABLE to 40923: main assigned 40922 to PAGE_TOKEN_MISMATCH after this branch forked. * feat(agent-core-v2): selectable conversation excerpts for title generation generateTitle gains a source option alongside force: - user_prompts (default): the existing first-prompts window, unchanged. - first_turn: the opening user prompt paired with the first turn's final assistant text — strict, so a caller asking before the first reply lands simply gets unavailable and can retry at the next turn boundary. - digest: first prompt + latest prompt + the latest turn's final assistant text, tolerating a compacted window by using whatever segments survive; meant for explicit regeneration on multi-turn sessions. Assistant segments keep only natural-language text parts (tool calls, thinking, and media never contribute) and pass through the shared metadata sanitizer, which redacts secrets and long base64-looking runs; each segment is capped (user 300, assistant 600/400) so the composed chat_content stays within the 1000-char budget. The kap-server route, klient contract, and node-sdk plumb the option through. Excerpt extraction is covered against the real context memory (loop-event folding), and the REST surface gains a digest composition case. * feat(agent-core-v2): gate session title generation behind an experimental flag Registers the flag (off by default; env KIMI_CODE_EXPERIMENTAL_SESSION_TITLE, the master flag, or the [experimental] config section) and makes generateTitle report unavailable while it is off, so every entry point — the kap-server route, klient, node-sdk, and through them the clients' auto trigger and rename-field action — is inert unless the user opts in. * refactor(agent-core-v2): rename the title flag to auto_session_title Snake-case id matching search_worker / persistence_minidb_readmodel; env KIMI_CODE_EXPERIMENTAL_AUTO_SESSION_TITLE. * fix(agent-core-v2): land the merge resolution leftovers The main-merge commit captured pre-fix snapshots of four files; the actual resolutions only lived in my working tree: the LifecycleScope import move to #/app/scopes, the titleKind port of applyPromptMetadataUpdate, the Promise<void> pinning of the metadata update queue, and the reloadSession runSessionAccess closure. * test(node-sdk): enable the auto_session_title flag in the title suites Generation now reports unavailable with the flag off, so the two title-generation harnesses opt in through the written config's [experimental] section. * chore: changeset for the experimental web session titles * chore: scope the title changeset to the SDK package * chore: cover the internal packages in the title changesets --------- Signed-off-by: 7Sageer <sag77r@hotmail.com> Co-authored-by: liruifengv <liruifeng1024@gmail.com>	2026-08-13 17:59:57 +08:00
Liu Zhongnuo	504e6292ed	feat(mcp): inspect effective authorization state in v1 (#2856) ... * feat(mcp): inspect effective authorization state * test(agent-core-v2): register MCP auth coordinator fixture * fix(mcp): validate runtime names against full catalog * fix(mcp): reconnect after pending auth updates * docs(mcp): describe auth coordinator collaborator * fix(mcp): ignore disabled runtime name collisions * fix(mcp): serialize OAuth token refresh * test(mcp): await OAuth credential writes * fix(mcp): queue trailing credential reconnect * fix(oauth): preserve access-only refresh winners * fix(mcp): preserve legacy offline auth state * fix(mcp): redact inspection credentials * refactor(mcp): keep app inspection on v1 * fix(mcp): guard legacy auth status mutations * fix(mcp): avoid deterministic legacy auth probes * fix(mcp): cover initialization credential updates --------- Co-authored-by: 刘仲诺 <liuzhongnuo@dev.msh.team>	2026-08-13 12:00:04 +08:00
Kai	98ee35afd2	feat(agent-core-v2): add custom agent identity (#2573) ... * refactor(agent-core-v2): simplify context tags and shared copy Rename the context-injection tags to `<skill-loaded>` and `<plugin-instructions>`, drop the product prefix from the CronCreate tool description and the default agent description, and point the MCP OAuth callback page back to "your terminal" instead of naming one client. The callback page is shared by the ACP host, the web UI, and embedding hosts, so naming a single client was inaccurate there. The tags and the two descriptions read exactly the same without the prefix. Verified no runtime consumer matches the old tag names; the updated snapshots cover the tool descriptions that changed. * feat(agent-core-v2): add a switch for the product-documentation skills Five builtin skills document this CLI itself — `update-config`, `custom-theme`, `mcp-config`, `check-kimi-code-docs`, and `import-from-cc-codex`. Their names and descriptions sit in the system prompt on every turn, which is dead weight for runs that will never reconfigure the CLI. Add a top-level `builtin_product_skills` field (also settable through `KIMI_CODE_BUILTIN_PRODUCT_SKILLS`) to drop them. On by default, so nothing changes unless it is set; the trade when off is that the model loses the guided flows for those tasks. Filtering happens where the catalog is assembled — a later filter would leave the skills advertised to the model. The whole section is one scalar, so it exercises the section-level env binding branch and needs its own strip: `stripEnvBoundFields` only walks object fields, so an env override would otherwise be written back into `config.toml`. * feat(agent-core-v2): add custom agent identity Add an `[identity]` config section (`name`, optional `slug`, both also settable through `KIMI_CODE_IDENTITY_NAME` / `KIMI_CODE_IDENTITY_SLUG`) that sets the identity the agent presents: the name it calls itself in the system prompt, the `User-Agent` product token sent to third-party providers, and the client name announced to MCP servers. Leaving it unset changes nothing. Until now every one of these was fixed, which left no way to run the agent as part of another product — an internal deployment, a fork with its own branding, an embedding host. The identity resolves inside the engine rather than being seeded by each host, so it applies to every launch surface — including headless runs, which today seed no display name at all and fall through to the built-in default. Two deliberate asymmetries: - The display name is a filling value with a fallback chain (config > host-declared > the consumer's own default); the slug is a rewriting value with two states only, so with no identity configured the rewriting paths are equivalent to not existing. - The rewrite happens in the outbound header assembly, the one layer that knows which vendor it is building for. Vendors declaring `hostHeaders: 'full'` keep the host's own product token, which that header set is built around and which backends key on; the configured identity applies to the third-party path. Resolution is lazy throughout: config loads asynchronously, and a constructor snapshot would freeze the pre-load value under some startup orderings. Two input edges the resolver has to absorb, since both would otherwise reach the User-Agent builder and either break it or quietly rewrite the header: blank and whitespace-only values read as unset in the file just as they already did in the env, so a stray `name = ""` cannot claim an identity; and a name that folds away to nothing under slug normalization (a CJK-only name, say) falls back to a neutral token rather than producing a blank product, which the builder rejects. * fix(agent-core-v2): keep the file value when a scalar env binding fails to parse `config.ts` documents that an env value failing its binding's `parse` is ignored, and `applyEnvBindings` honors that for object fields by assigning only when the resolved value is defined. `applySectionEnv` returned the parse result straight through for whole-section scalar bindings, so a blank or mistyped variable resolved to `undefined` and cleared the configured file value instead of being ignored. Nothing hit this before: every existing section either binds object fields or is env-only. `builtin_product_skills` is the first whole-section scalar binding, where exporting an empty or misspelled `KIMI_CODE_BUILTIN_PRODUCT_SKILLS` would silently undo a configured `false`. * feat(agent-core-v2): extend the custom identity to discovery and global MCP Two outbound paths still announced the built-in product name under a configured identity: - `DiscoveryService` read the host User-Agent straight from bootstrap args when refreshing provider models, so custom registries — which are third-party endpoints — saw the original token while chat requests to the same class of endpoint saw the configured one. - `SDKRpcClientV2` builds its own global `McpOAuthService` plus a throwaway `McpConnectionManager` for server testing, neither of which goes through the workspace-owned manager that carries the resolver. Both now resolve the identity from the App scope. * refactor(agent-core-v2): neutralize remaining copy and align comments The synthetic MCP authentication tool description is injected into the model context and still named the product; it and the OAuth callback pages now use client-neutral wording. "Return to your terminal" was no improvement over naming a client — both assume what the host is, and that page serves the ACP host, the web UI and embedding hosts alike. Comments introduced by the identity work move into their module headers, per the domain convention. Interface field docs stay: the rule names functions, methods and statements, and field-level docs are established across the codebase. The new tests gain scenario headers and dispose the scoped hosts they create, and the `[identity]` docs state which engine reads the section. * fix(agent-core-v2): read the product-skill switch after config is ready `BuiltinSkillSource` is the lowest-priority skill source, so the workspace catalog loads it first — before `IConfigService` has finished loading — and keeps the contribution it returns for the life of the handler, with no reload path and no change event. Reading `builtin_product_skills` eagerly therefore stranded the startup configuration: an explicit `false` could be ignored for the whole process. `UserFileSkillSource` already awaits config readiness for exactly this ordering; this source now does the same. Also record the identity collaborator in the two module headers that gained the dependency without documenting it, and scope the `builtin_product_skills` docs to the engine that reads it, matching the note the identity section already carries. * fix(agent-core-v2): apply the product-skill switch to session-less listings `builtin_product_skills = false` only reached the scoped skill source. The SDK's `listWorkspaceSkills` and the server's `GET /workspaces/{id}/skills` both composed the raw `BUILTIN_SKILLS` constant, and the web app feeds its pre-session onboarding menu from that route — so the five product skills stayed listed until a session existed, then vanished from the session's catalog. Move the decision into `visibleBuiltinSkills(enabled)` next to the constant and route every consumer through it, reading the switch via the shared `builtinProductSkillsEnabled`. Keeping "what counts as a product skill" in one place is the point: three copies of the predicate would drift the next time a builtin is added. The SDK listing also awaits config readiness, which it did not do before. * fix(node-sdk): await config before materializing the global MCP OAuth provider `McpOAuthService` caches providers by store key and stamps the client name when it first builds one, and the preceding `globalMcpConfig.get()` reads `mcp.json` directly rather than through `IConfigService`. So a `beginGlobalMcpServerAuth` call made right after the harness is created could resolve the identity before config finished loading, pinning the built-in label for the rest of the process — including the OAuth dynamic registration a third-party MCP server records. `testGlobalMcpServer` already awaited config readiness for its own reasons; this path now does too. * refactor(agent-core-v2): drop the unused builtin-skill registrar `registerBuiltinSkills` stamped the raw constant into a catalog for "edge composition without a Session" — exactly the shape that now has to respect `builtin_product_skills`. It has no callers in v2 and is not exported from the package index, so it was dead code that also stood as an invitation to bypass the switch. v1 keeps its own copy. Every remaining path composes builtins through `visibleBuiltinSkills`. * fix(agent-core-v2): send the configured identity on custom-registry imports `:import_registry` fetched a user-supplied third-party URL with a hardcoded `kimi-code-kap-server` User-Agent, so the first request to a registry announced the product while every scheduled refresh of the same registry announced the configured identity. The hardcoded value was wrong on its own terms too: that token names the server, and this path also runs in the CLI. Both services now project the identity through `identityUserAgent`, which carries the two guards (no host header, or no identity) once instead of per caller. The model catalog keeps an inline copy on purpose — kosong is a foundational layer and must not import an app domain. Sweeping the remaining outbound User-Agent sources found no further gaps: WebFetch deliberately sends a Chrome-like UA, the models.dev catalog fetch sends none from the CLI, and kap-server's `user-agent` reads are inbound. * docs: scope the identity env vars and condense the changeset The environment-variable reference advertised all three new variables without noting that only the agent-core-v2 engine reads them; the configuration page already carried that note. Added in both locales. The changeset had grown into two paragraphs of implementation detail, which is what would land in the CLI release changelog. `gen-changesets` asks for one short sentence plus at most a one-line usage hint. * docs(agent-core-v2): describe the identity as what the agent calls itself The module headers had drifted into describing the feature by what it keeps off the wire rather than what it configures. Reworded so they state the capability: the identity is the name the agent uses for itself, and the unset case is a no-op rather than something "safe". The product-skill switch excludes skills rather than hiding them. Wording only; behavior and structure unchanged. * test(agent-core-v2): cover the identity on custom-registry imports The import path switched from a hardcoded `kimi-code-kap-server` token to the host User-Agent projected through the identity, but nothing asserted it. Two cases pin both halves: a configured identity reaches the request, and an unconfigured one leaves the host header intact — the second matters because a single case would also pass if one hardcoded value had simply replaced another. Both fail against the previous implementation. * fix(node-sdk): guard every global MCP OAuth path behind config readiness `McpOAuthService` caches providers by store key and stamps the client name when it first builds one, so any path that can materialize a provider has to run after config has loaded. `beginGlobalMcpServerAuth` awaited readiness, but `resetGlobalMcpServerAuth` reaches the same cache through `invalidate()` -> `getProvider()` without waiting: resetting auth right after the harness is constructed pinned the built-in client name, and the await added to the begin path could not help because it then reused that cached provider. Rather than add the missing await, the accessor is now async and holds the guard itself, so the service cannot be obtained before config is ready and a future entry point cannot forget. The remaining `configReady` in `testGlobalMcpServer` stays — that one is for its own `[mcp]` section read. * fix(agent-core-v2): send the configured identity on models.dev requests The directory fetch behind `listModelsDevProviders` / `getModelsDevProvider` still hardcoded a `kimi-code-kap-server` User-Agent, so browsing or importing from models.dev announced the built-in product — and claimed to be the server even when running in the CLI. Only the custom-registry import had been fixed. `getModelsDevCatalog` now takes the User-Agent from its caller: the module is plain module-level state with no container access, and the value depends on the host and the configured identity, which only the calling service can see. All four third-party fetches in that service share one helper. Where the host states no User-Agent, a neutral token stands in rather than dropping the header — these are directories the service chooses to call, so there is no host intent to preserve, unlike the provider requests the model catalog assembles. Both new tests fail against the previous hardcoded value. * test(agent-core-v2): assert the product-skill set literally The expected sets were derived from the same `productSpecific` field the production filter reads, so a builtin silently losing its marker would just move between sets and leave every assertion green — while staying visible to the model once the switch is off. The five names are now literal, with a test asserting the marked set matches them exactly. Dropping the marker from one skill now fails four tests instead of none. Also states the App scope in the identity contract header, per the domain's comment convention for contract files. * fix(agent-core-v2): normalize the host-declared display name too Blank and padded values were normalized on the config side but not on the host fallback, so an embedding host passing `displayName: " "` rendered "You are ," into the system prompt, and a padded name kept its padding. Same rule now applies to every source of the name. Also names `agentIdentity` as the collaborator in the request-headers adapter header, which described the value it obtains without saying which domain resolves it. The three new cases fail against the previous implementation. * fix(agent-core-v2): keep the configured slug when the host sends no User-Agent The neutral fallback added for hosts that state no `User-Agent` discarded a configured identity along with it: `identityUserAgent` returns `undefined` as soon as there is no host header to rewrite, so `?? DEFAULT_IDENTITY_SLUG` sent the literal `agent` even when `[identity].slug` was set — precisely the case that fallback exists to serve. The configured slug now stands on its own, with the neutral token reserved for having neither. The four combinations of (host header, configured slug) had three tests; the missing one is the one that was wrong. It now fails without this change. `outboundUserAgent` also awaits config readiness before reading the identity, so a browse issued right after bootstrap cannot send the pre-load value — the guard lives in the accessor rather than at its four call sites, matching how the same race is handled elsewhere in this branch. Both headers here and in `discoveryService` now name `agentIdentity` as the collaborator resolving that token. * test(acp-server): follow the renamed skill-activation tag `acp-server` arrived on main after the tag rename, so its two assertions still expected `kimi-skill-loaded` and failed once the branches met. Also updates the web app's CSS comment, which named the old tag from the start of this branch — a comment, so nothing ever failed on it. Found by CI: the merge verification only ran agent-core-v2's suite, and this package is neither a dependency nor a dependent of it. * fix(agent-core-v2): present the configured slug on registry refreshes too The previous round taught the import path to fall back to the configured slug when the host states no `User-Agent`, but left the scheduled refresh of the same registry on the bare projection — so one registry could see `acme` on import and the runtime default on refresh. Extracting `identityUserAgent` had made the two paths share a function without sharing the policy. The choice itself is now the shared piece: `identityUserAgentOrDefault` always yields a value, for the directories this process chooses to call, while `identityUserAgent` stays the form that rewrites only what the host already sends — what a provider request needs, where the host's silence is its own choice. * docs(agent-core-v2): move new member docs into the module headers The domain's comment convention is absolute — comments live solely in the top-of-file block — and I had read the "functions, methods, or statements" clause as leaving interface members out. It does not: only 25 of 734 v2 sources carry an indented block, so the members I documented were the exception, not the pattern. Seven members across six files move into their headers. `types.ts` had no header at all, so it gains one. * fix(agent-core-v2): connect session MCP overlays after config is ready The shared manager reaches `connectAll` through `initialize()`, which awaits the config domain first; `sessionOverlay` called it straight away. A session carrying ephemeral `mcpServers` created right after bootstrap therefore resolved the client name before config had loaded and initialized under the built-in one. The blast radius is wider than that one connection: a remote server sends the overlay through `hasTokens()`, which materializes an OAuth provider on the *shared* service and caches it by store key — so the early name outlives the connection that raced. The overlay now connects behind `mcpConfig.ready`, leaving the returned readiness promise unchanged. * fix(agent-core-v2): reload builtin skills when their switch changes The workspace catalog keeps each source's contribution for the life of the handler, so a `builtin_product_skills` toggle never reached an existing handler's sessions. That was harmless while every surface read the same constant — but routing the session-less listings through the config made the two views disagree, since those read the switch on every call. Follows `ExtraFileSkillSource`: subscribe to the owning section and fire `onDidChange`, which the catalog already turns into a source reload. The test asserts an unrelated section does not trigger it. * fix(agent-core-v2): apply the identity to self-configured web services `[services.moonshot_search]` and `[services.moonshot_fetch]` name their own `base_url`, so both services can point at an endpoint the user chose — but each forwarded the host request headers verbatim, sending the built-in product token there under a configured identity. Only the services-config path is rewritten; the managed OAuth path keeps the host headers as they are, being the endpoint the session authenticated against. The distinction is the same one the model catalog draws per vendor. `identityHeaders` carries the rewrite across a whole header set, so this is the fourth caller sharing the projection rather than repeating its guards. A pair of tests pins both halves. My earlier sweep classified these two as official by their names instead of asking who chooses the URL, which is why they were missed. The contract header is also condensed here, per the convention below. * docs(agent-core-v2): condense the identity headers to their contracts The comment convention is one sentence with two halves — comments live only in the top-of-file block, *and* that block states the module's role without narrating implementation. Moving the member docs up last round satisfied the first and broke the second: the headers ended up spelling out the slug folding algorithm, the strip mechanics, and the load order. Kept what a caller or the next editor would get wrong without it (why the value is read rather than snapshotted, what `undefined` obliges a consumer to do, why this source waits for config). Dropped what the code already says. 22/12/12/13 lines, against 53 in `catalogService.ts` — length was never the problem. * fix(agent-core-v2): rebuild active prompts when the builtin skills change Reloading the catalog on a `builtin_product_skills` toggle left existing agents holding the old listing: `AgentProfileService` refreshes the prompt only for the plugin source, so a disabled switch kept advertising skills that were gone, and enabling it left them missing until an unrelated refresh. The plugin source is special because it also contributes prompt sections (#2314), and the file-backed sources are left out for cost — their fs watches would rebuild every agent's prompt on each edit. The builtin source has no watch: it changes only when its config switch is toggled, so it belongs with the plugin source rather than with the file ones. Subscribing to the catalog rather than the config section is load-bearing. The catalog fires after the contribution is replaced, whereas a config subscription would race the reload, and `resolveSkillListing` only awaits the catalog's *initial* readiness — so the rebuilt prompt could read the listing it was meant to replace. The source id is a named constant now, so the subscription does not match on a bare string. * refactor(agent-core-v2): freeze the agent identity for the process lifetime The identity is announced outward (MCP initialize, OAuth registration, provider request logs) and cannot be re-announced, so mid-process changes could only ever apply partially. Resolve it once when config first loads and hold it for the life of the process: IAgentIdentity now hands out a frozen snapshot via resolved()/current(), carrying finished products (outbound User-Agent variants, rewritten header set) so call sites stop composing host headers with the slug themselves. The kosong host-headers port carries two finished layers and the catalog only picks one; consumers gain no invalidation obligations because the value can never change after the freeze. [identity] edits take effect on the next start (documented). * fix(agent-core-v2): locate the User-Agent header case-insensitively HTTP header names are case-insensitive, but the snapshot builder looked up 'User-Agent' by exact key: an embedding host spelling it 'user-agent' got no third-party UA and kept its own product token on the services path even with an identity configured. The builder now locates every case variant and rewrites each in place, keeping the host's spelling. Also corrects the two web-service headers that still described both paths as sending the bootstrap headers, naming agentIdentity as the collaborator behind the config path, and documents that a resumed session keeps its recorded system prompt. * fix(agent-core-v2): attribute header provenance from the finished third-party layer Inspection reconstructed the non-full host layer from the raw headers with an exact-case 'User-Agent' lookup, so a host spelling the header 'user-agent' got a resolved User-Agent with no provenance entry even though the runtime sends the rewritten value. buildModel now captures the port's finished third-party layer in the trace and attribution reads it, keeping inspect() on the same resolution pass as get(). Also condenses the identity contract header to its external role, and documents that an existing MCP OAuth authorization keeps the client registration it was granted under (reset the server's auth to register under the new identity). * fix(agent-core-v2): keep web tool backends from racing the identity freeze An env-configured [services] endpoint is visible before config finishes loading, and FetchURLTool / WebSearchTool materialized their backends at construction — so a fast bootstrap could hit the identity snapshot's pre-freeze guard during agent creation, and the composed backend pinned config and login state for the agent's lifetime against the service's documented per-call resolution. Both tools now resolve their backend per invocation, the WebSearch activation gate checks presence alone through the new hasWebSearchProvider() (no provider composition, no identity read), and bind() awaits the identity freeze before materializing the model, whose resolution reads the identity through the host-headers port.	2026-08-04 22:35:15 +08:00
liruifengv	ea81c9a3c5	feat(kap-server): expose the managed-account profile at GET /oauth/userinfo (#2363) ... * feat(kap-server): expose the managed-account profile at GET /oauth/userinfo * refactor(oauth): serve the userinfo profile as the camelCase domain type end to end * style(agent-core-v2): drop the method-local comment on getManagedUserInfo * chore: drop the userinfo endpoint changeset * test(kap-server): pass the required host identity in the userinfo route test	2026-07-30 15:05:55 +08:00
github-actions[bot]	bc28e9d802	ci: release packages (#2342) ... Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2026-07-30 14:56:30 +08:00
liruifengv	40172c7ca9	feat: unify the host identity across OAuth, telemetry, and kap-server (#2382) ... * refactor(oauth): make X-Msh-Platform an explicit host identity field X-Msh-Platform was hardcoded to kimi_code_cli in createKimiDeviceHeaders, so non-CLI hosts could not state their own platform and the desktop had to patch the header after the fact. KimiHostIdentity now carries a required platform (every host declares its own value; the CLI constant stays the fallback only for direct createKimiDeviceHeaders callers), and userAgentProduct is renamed to productName so the transport identity uses one name everywhere. All in-repo identity constructions pass platform explicitly; the wire value for CLI and VS Code hosts is unchanged (kimi_code_cli). * feat(agent-core-v2): carry the host identity in the bootstrap snapshot Replace the flat clientVersion field with a required clientIdentity (KimiHostIdentity) so every consumer reads the same host identity object: OAuthToolkitService now passes it to the OAuth toolkit, which means the OAuth device-flow endpoints (device authorization, token polling, refresh) on the kap-server path finally send the full X-Msh-* device headers instead of none, and the telemetry cloud appender reads client_version from the same source. A built-in CLI fallback keeps bare bootstrap() calls in tests working; composition roots must pass their own identity. The session export manifest grows an optional desktopVersion field (payload plumbed through; filled by kap-server in a follow-up). * feat(agent-core): thread the host identity into the managed auth facades The v1 managed auth facade constructed its OAuth toolkit without an identity, so token refreshes from inside the core went out without any X-Msh-* device headers. createManagedAuthFacade now takes an optional KimiHostIdentity and every call site supplies one: CoreProcessService._defaultOAuthTokenResolver forwards the core process's options.identity (the same source _defaultKimiRequestHeaders uses), and the DI-held services (oauth / auth summary / model catalog) read it from a new optional identity field on IEnvironmentService. The library-level "no identity, no device headers" contract is unchanged. * feat(kap-server)!: require the host identity and derive request headers from it ServerStartOptions.hostIdentity is now a required ServerHostIdentity (KimiHostIdentity + optional prompt display fields), replacing both the old optional HostIdentityOverrides (renamed to PromptIdentityOverrides, its productName field now displayName) and the version option (renamed to serverVersion — it is the engine version reported as server_version, while the host product version travels in hostIdentity.version). The server now feeds bootstrap's clientIdentity from hostIdentity and derives the default outbound headers (User-Agent + X-Msh-*) from it via createKimiDefaultHeaders, so kap-server-hosted OAuth flows and model / WebSearch requests carry the real host identity instead of a hardcoded kimi-code-cli fallback UA. Explicit header seeds still win as an escape hatch. Session export manifests record the host product version: kimiCodeVersion now carries hostIdentity.version (the engine version no longer appears), and desktop exports (desktop: true) are additionally stamped with a desktopVersion field. The instance registry keeps its host_version wire field for compatibility (kimi-inspect reads it); only the in-memory name changed to serverVersion. * feat(cli): wire the CLI host identity into the kimi web server kimi web now passes createKimiCodeHostIdentity(version) as the server's hostIdentity, so web-UI OAuth flows and the engine's outbound requests carry the explicit CLI identity (productName + version + platform). The explicit hostRequestHeadersSeed is dropped — kap-server derives the same headers from hostIdentity — and buildKimiDefaultHeaders goes away with its only consumer. * test(klient): drop clientVersion from the bootstrap contract parity list * chore: add changesets for the host identity unification * feat(cli): tag kimi web requests with a (web) User-Agent suffix kimi web shares the CLI product token and platform, so its outbound requests were indistinguishable from direct CLI runs upstream. Its host identity now carries userAgentSuffix 'web', putting web-UI traffic at kimi-code-cli/<version> (web) while X-Msh-Platform stays kimi_code_cli. * fix(klient): keep the env() clientVersion wire field after the bootstrap identity switch The bootstrap snapshot replaced the flat clientVersion scalar with clientIdentity, which broke klient's env() fan-out (RPCError: method not found). The wire surface keeps clientVersion — now sourced from clientIdentity.version — and bootstrapService gains a clientIdentity read (registered in envContract with an object schema) for consumers that want the full identity. * feat(oauth): send the product User-Agent on OAuth requests The OAuth endpoints used to receive only the X-Msh-* device headers (undici's default UA otherwise), which left the OAuth host unable to distinguish runtime surfaces — notably kimi web, whose platform matches the CLI and whose only distinguishing mark is the (web) UA suffix. The toolkit now feeds the full identity headers (User-Agent + X-Msh-*) into every device authorization, token polling, and refresh request; the request-header type widens from DeviceHeaders to OAuthRequestHeaders. * feat(vscode): report kimi_code_vscode as the extension's platform The VS Code extension inherited the CLI's hardcoded X-Msh-Platform value; with platform now an explicit identity field it declares its own, so the managed endpoints and OAuth host can tell extension traffic apart from CLI runs. * refactor(agent-core-v2)!: require the client identity at the composition root The bootstrap fallback identity fabricated a kimi-code-cli/unknown host for any caller that forgot to pass one — the same silent-misreport pattern this series set out to remove, and it made "required" a lie. BootstrapInput.clientIdentity is now required, so a missing identity fails at compile time instead of being papered over. Test and example callers pass a shared fixture (klient examples and test engines get one each); the node-sdk v2 client asserts its host identity with the oauth helper. Also folds DeviceHeaders from an interface into a type alias so it stays assignable to the widened OAuthRequestHeaders record. * feat(oauth)!: require and validate the platform in device headers Drops the quiet CLI fallback in createKimiDeviceHeaders (the same silent-misreport pattern removed from the bootstrap identity): platform is now a required option, validated with the same required-ASCII rule as the version — empty or all-non-ASCII values throw instead of emitting a blank X-Msh-Platform, and header-unsafe characters are stripped rather than sent raw. * fix(node-sdk): seed the host request headers on the v2 client path The interactive v2 engine path (experimental flag) bootstrapped without a hostRequestHeaders seed, so managed vendor calls went out with the SDK's default User-Agent (OpenAI/JS) and no X-Msh-* at all — v1 passes the full identity headers on the same requests. The v2 client now seeds the headers from its asserted host identity, and a test pins the seed. * chore: simplify the CLI changeset wording	2026-07-30 13:45:41 +08:00
liruifengv	b0f43aea28	feat(oauth): return structured managed usage rows (#2300) ... * feat(oauth): return structured managed usage rows Stop formatting plan-usage labels and reset hints into English strings at the oauth layer. The parser still absorbs backend field drift, but now emits a stable structured row (name / window{duration,unit} / used / limit / resetAt) that kap-server passes through and clients localize themselves: - window: normalized from duration/timeUnit (minute/hour/day/week), whole-hour minute windows fold to hours, unnamed summaries are the weekly limit - resetAt: absolute ISO timestamp; relative reset_in/ttl seconds are converted at parse time - TUI /usage panel formats labels and reset hints locally * refactor(oauth): parse managed usage strictly to the current payload shape Drop the defensive drift tolerance (alternate reset-time spellings, reset_in/ttl seconds, remaining-derived used, title/scope names, top-level duration/timeUnit, fuzzy time-unit matching) and parse only what the platform actually sends: numeric strings, resetTime, nested detail/window records, TIME_UNIT_* enums. * fix(node-sdk): update managed usage smoke example and facade tests for structured rows	2026-07-28 15:03:25 +08:00
liruifengv	bfecd0128f	feat: refresh model list for API-key providers at the managed endpoint (#1824) ... * feat: refresh model list for API-key providers at the managed endpoint * docs: simplify changeset wording * docs: add kimi-code/k3 to the default config example * fix: clear stale default model when a refresh drops its alias * fix: clear refresh defaults via replace; set(undefined) cannot delete * docs: drop the auto model refresh paragraph from providers page * docs: simplify changeset wording	2026-07-17 17:17:58 +08:00
qer	b53e00db91	fix(oauth): include the transport root cause in connection error messages (#1808) ... * fix(oauth): include the transport root cause in connection error messages * chore: add changeset for oauth connection error diagnostics	2026-07-17 14:45:16 +08:00
7Sageer	1294a0e1ad	fix(agent-core-v2): keep invalidated OAuth flows observable during login (#1663) ... * fix(agent-core-v2): keep invalidated OAuth flows observable during login invalidateFlows() deleted flows outright when the provider configuration changed, including terminal ones. That voided the TERMINAL_RETENTION_MS window and, worse, left the status guards in handleSuccess / finalizeAuthentication blind when the invalidation landed in the microtask gap after toolkit.login resolved: setTerminal then wrote 'authenticated' onto an orphaned state the client could never observe, so the login hung after a successful browser authorization. Transition affected pending flows to a visible 'cancelled' terminal status instead, mirroring abortExisting(). Also normalize the KIMI_CODE_BASE_URL env override at the source in kimiCodeBaseUrl(): provision persists it verbatim while the model refresh rewrites it normalized, and the deep-equal diff between the two shapes fired a spurious providers-changed event mid-login. * style(agent-core-v2): drop non-header comments from the oauth login fix * chore: cover agent-core-v2 in the oauth login fix changeset	2026-07-14 12:16:28 +08:00
7Sageer	d601847f22	fix: send the product User-Agent on provider registry and catalog fetches (#1597) ... * fix: send the product User-Agent on provider registry and catalog fetches Registry (api.json) and models.dev catalog fetches only carried the runtime default User-Agent while every other outbound request sends kimi-code-cli/<version>. Thread an optional userAgent through fetchCustomRegistry / fetchCatalog and the shared refresh host, pass the product UA from the CLI, TUI, and both daemons, and seed a default product UA in kap-server that hosts can override via opts.seeds. * refactor: use options for registry fetches	2026-07-13 17:45:34 +08:00
_Kerman	bc8eb1e417	chore: drop #/ import array fallbacks and custom resolution plugins (#1594)	2026-07-13 16:37:35 +08:00
Haozhe	cc03816ee0	feat(oauth): parse support_efforts/default_effort in custom registry import (#1564) ... * feat(oauth): parse support_efforts/default_effort in custom registry import - parse support_efforts / default_effort from api.json model entries - map them onto model aliases as supportEfforts / defaultEffort - treat both fields as upstream-owned in CUSTOM_REGISTRY_MODEL_FIELDS so refreshes sync and stale values are dropped	2026-07-12 13:27:50 +08:00
liruifengv	b91099ed7a	feat: display Extra Usage fuel pack balance in /usage and /status (#1501) ... * feat(oauth): parse boosterWallet extra usage from /usages * feat(oauth): expose extraUsage on AuthManagedUsageResult * feat(kimi-code): render Extra Usage section in /usage panel * fix(kimi-code): address Task 3 review feedback for extra usage section * feat(kimi-code): render Extra Usage section in /status panel * feat(kimi-code): wire extraUsage into /usage and /status commands * chore(extra-usage): address final review findings for fuel pack feature - Update changeset to cover both kimi-code and kimi-code-sdk packages - Add parser clamp tests and toolkit null-case test - Replace 'as never' casts in usage-panel tests - Wrap long import line in status-panel * chore: temporarily log /usages raw response for debugging * fix(oauth): accept BOOSTER balance type and drop debug log * fix(oauth): drop reset hint from Extra Usage and revert periodEnd parsing * fix(oauth): treat missing amountLeft as zero extra usage and drop debug log * revert: keep missing amountLeft defaulting to 0 (fully used) * feat(extra-usage): show monthly cap usage bar and balance in /usage and /status * fix(extra-usage): show balance and unlimited marker when no monthly cap * fix(extra-usage): show monthly used with unlimited marker and balance * fix(extra-usage): label Used and use English Unlimited * feat(extra-usage): render balance, monthly used and monthly limit as labeled rows * fix(extra-usage): move Balance row to the bottom * fix(extra-usage): format currency values with two decimals for column alignment * fix(extra-usage): right-align currency values so numbers line up * fix(extra-usage): align currency symbol and decimal point in usage rows	2026-07-09 17:44:59 +08:00
liruifengv	c070fbedde	feat: add model alias overrides (#1262) ... * feat: add model alias overrides Preserve user model overrides across provider catalog refreshes and resolve effective model metadata for runtime, TUI, protocol, and ACP consumers. * fix: apply model display name overrides Show overridden model display names in the footer, welcome panel, status output, and model switch confirmations. * fix: pass through kimi effort when undeclared Keep support_efforts authoritative when declared, but pass requested Kimi thinking effort through when the model does not declare support_efforts. * fix: honor model overrides in effort commands Use effective model metadata for /effort choices and for always_thinking clamping when resolving thinking effort.	2026-07-01 19:57:13 +08:00
liruifengv	108299be3c	refactor!: overhaul thinking config and effort resolution (#1132) ... * feat: support multi-level thinking effort switching - kimi provider: emit thinking.effort in the new wire format; keep reasoning_effort mirrored during the transition - model catalog: thread support_efforts / default_effort from oauth through to /models - config schema: add supportEfforts / defaultEffort on model aliases - TUI: multi-segment thinking control in /model, new /effort command, footer effort display - switch status uses displayName and distinguishes model vs effort-only changes * docs: add thinking effort design plans - thinking-effort-switching.md: implemented multi-level effort switching - thinking-model-overhaul.md: follow-up refactor plan for the thinking state model * docs: collapse thinking overhaul plan into a single PR * refactor!: overhaul thinking config and effort resolution Replace default_thinking and thinking.mode with a single [thinking] enabled/effort table. ThinkingEffort is now an open string ('off' | 'on' | model-declared effort); effort levels come from each model's support_efforts instead of a fixed enum. Centralize default and always_thinking clamp logic in resolveThinkingEffort/defaultThinkingEffortFor, and honor an explicitly configured effort when an always_thinking model is forced back on. TUI keeps a single thinkingEffort field instead of the boolean + level pair; 'on' is normalized to the model default at the UI boundary. BREAKING CHANGE: default_thinking and thinking.mode are removed from config; migrate to [thinking] enabled/effort. * refactor: rename residual thinking level wording to effort Rename comments, error messages, parameter names, the SetThinkingPayload wire field (level -> effort), and TUI local variables so the thinking effort naming is consistent throughout. No behavior change. * refactor: rename remaining camelCase thinking level identifiers to effort Rename liveLevel/prevLevel/levelChanged/commitLevel/effectiveLevel to liveEffort/prevEffort/effortChanged/commitEffort/effectiveEffort in the TUI model picker and config commands. * refactor: eliminate remaining thinking level wording in comments and tests Rename levelLabel -> effortLabel, EffortSelectorOptions.levels -> efforts, and 'effort level(s)' / 'default level' / 'requested level' wording in comments, error messages, slash-command description, and test titles to effort. Also restore the withThinking(effort) parameter rename in the Kimi provider that was accidentally reverted. * fix: address codex review feedback on thinking effort handling - OpenAI thinkingEffortToReasoningEffort and Anthropic clampEffort now normalize 'on' / unrecognized efforts instead of throwing, so boolean non-Kimi models no longer crash on session start. - ACP resolveCurrentThinkingEnabled treats a non-empty thinking.effort as enabled, matching agent-core's resolveThinkingEffort. - REST promptThinkingSchema accepts any non-empty effort string so model-declared efforts are not rejected at the API boundary. * test: align kimi e2e expectations with supportEfforts-gated reasoning_effort The kimi provider now sends reasoning_effort only when the model declares support_efforts; boolean models (no support_efforts) send only thinking.type. Update the kimi e2e tests to drop the stale reasoning_effort expectation for the boolean test model. * test: cover [thinking] effort parsing in config.test Add effort = "high" to the documented [thinking] table in the config parse test and assert config.thinking.effort is resolved, so the new [thinking] effort field has direct parse coverage. * docs: add thinking test coverage gap analysis Capture the explore agent's test coverage review for the thinking overhaul PR, including P1/P2 gaps and the two open design questions, for follow-up test additions. * feat(oauth): parse nested think_efforts from /models response The /models endpoint now returns effort levels under a nested think_efforts object ({ support, valid_efforts, default_effort }). Parse it preferentially in both managed-kimi-code and open-platform model parsing, falling back to the legacy flat support_efforts / default_effort fields for older servers. * refactor(oauth): only read nested think_efforts; gate on support=true Drop the legacy flat support_efforts / default_effort fallback. The think_efforts object is now the single source, and its support flag gates the whole object — when support is not true, valid_efforts and default_effort are ignored entirely. * chore: remove unused parseStringArray import in open-platform * docs: finalize thinking effort release notes Downgrade the changeset to minor with an English summary, drop the version-specific 'added in 1.0.0' info block, and present the deprecated config fields as a table (field / deprecated in 0.21.0 / description). * refactor: drop temporary refresh toggles and kimi reasoning_effort mirror Remove the always-true REFRESH_MODELS_ON_PICKER_OPEN / REFRESH_PROVIDER_MODELS_ON_STARTUP toggles and their stale re-enable TODOs, and stop sending reasoning_effort from the kimi provider (thinking.effort is the only wire field now). * fix(tui): avoid persisting "on" as thinking effort * fix: preserve persisted thinking effort across login and provider setup * fix(tui): show actual thinking effort in /status and footer * test(tui): align message-flow expectations with effort persistence and /status display * fix(vis): rename thinkingLevel to thinkingEffort in config.update analysis	2026-06-30 22:34:13 +08:00
Haozhe	14d9e98903	feat(server): auto-refresh provider model catalog and push change events (#1207) ... * feat(server): auto-refresh provider models and push change events - add scheduled provider-model refresh in the daemon (configurable interval + refresh-on-start) plus manual endpoints: POST /providers:refresh and POST /providers/{id}:refresh - publish global event.model_catalog.changed when a refresh changes the catalog so connected clients can resync - extract the refresh orchestrator into @moonshot-ai/kimi-code-oauth so the CLI and server share managed/open-platform/custom-registry logic - wire the web daemon client to the new refresh endpoints * chore: add changeset for provider model auto-refresh * fix(web): reload model and provider caches on catalog change events When the daemon's scheduled refresh changes the catalog, the pushed event.model_catalog.changed only advanced the websocket sequence, leaving the web composer's model/provider refs stale until an unrelated reload. Reload both caches when the event arrives. * test(sdk): cover event.model_catalog.changed in event exhaustiveness	2026-06-30 12:29:10 +08:00
Kai	821847cb4b	feat(managed-kimi-code): route anthropic protocol via beta api (#1186) ... * feat(managed-kimi-code): route anthropic protocol via beta api - kosong: add betaApi option to use client.beta.messages.create - agent-core: thread alias betaApi into the anthropic provider config - oauth: route managed models on the anthropic protocol through the beta Messages API * feat(providers): add KIMI_CODE_CUSTOM_HEADERS support - Add KIMI_CODE_CUSTOM_HEADERS env var for custom outbound LLM headers - Send User-Agent to non-Kimi providers - Forward Kimi identity headers to model catalog fetches - Support defaultHeaders in Google GenAI provider * feat(agent-core): add protocol attrs to turn and api error telemetry - Add type/protocol/alias to api_error for per-protocol error attribution - Add turn_ended event with reason/duration/mode/type/protocol - Add type/protocol to turn_interrupted * chore(oauth): remove hardcoded internal dev endpoint from shared OAuth base URLs --------- Co-authored-by: haozhe.yang <yanghaozhe@moonshot.ai>	2026-06-29 14:24:01 +08:00
Haozhe	cf558cd742	feat(managed-kimi-code): support Anthropic-compatible protocol (#1170) ... * fix(agent-core): recover from context overflow 413 - track provider-observed effective context limit after overflow - compact with the reduced limit before retrying the turn - treat large plain 413 responses as recoverable context overflow - add CLI patch changeset * feat(managed-kimi-code): support Anthropic-compatible protocol - switch managed provider to anthropic when models declare anthropic protocol - add base64 video content blocks to the kosong anthropic provider - downgrade unsupported media parts to text placeholders by capability - pass prompt cache key as Anthropic metadata.user_id for session affinity * feat(agent-core): add protocol/type to request and video upload telemetry - turn_started now carries `type` (configured provider wire type) and `protocol` (effective transport, i.e. alias.protocol ?? provider.type) - new video_upload event reports mime type, size, latency and success/failure, plus type/protocol/model context - ResolvedRuntimeProvider gains `type` and `protocol` fields	2026-06-28 13:04:03 +08:00
7Sageer	e736349a7c	feat(feedback): support attaching logs and codebase (#1120) ... * feat(feedback): support attaching logs and codebase Add an attachment picker to /feedback (none / logs / logs + codebase). Codebase uploads scan the working directory with sensitive files excluded and are sent through a new multipart upload API on the oauth/node-sdk layers. * fix(feedback): fall back to logs when codebase scan fails * tiny fix * fix(feedback): make diagnostic uploads partial-safe * refactor(feedback): reuse harness session export and normalize upload url types * docs(slash-commands): note optional feedback attachments * refactor(feedback): reorganize feedback upload modules Move the attachment orchestration out of tui/commands/info.ts into a dedicated feedback/feedback-attachments.ts, and split the former codebase-upload/attach.ts into a generic multipart uploader (feedback/upload.ts) and an archive lifecycle module (feedback/archive.ts). Both session and codebase archives now flow through a single upload lifecycle, which also removes the temp-dir leak that occurred when codebase packaging failed. Rename FeedbackCodebaseArchive to FeedbackArchive and the codebase-upload/ directory to codebase/ so module boundaries match their actual responsibilities (scan + package only).	2026-06-26 16:15:08 +08:00
liruifengv	b51e13538d	ci: run unit tests on windows (#1037) ... * ci: run unit tests on windows * fix(migration-legacy): align workdir bucket key with agent-core computeWorkdirBucket used a local node:path-based resolve that yields backslash-separated paths on Windows, while agent-core's encodeWorkDirKey uses pathe (forward slashes on every platform). The SHA-256 inputs diverged, so migrated sessions were written to a bucket that the session picker never reads, making them invisible on Windows. Alias computeWorkdirBucket to encodeWorkDirKey so both sides stay byte-identical, drop the local slugify copy, and update the workdir-bucket test reference accordingly. * test(acp-adapter): expect platform-native separators in e2e-fs path The e2e-fs test asserted the fs/readTextFile wire path as the raw POSIX targetPath, but AcpKaos.toClientPath converts '/' to '\' when the inner LocalKaos reports pathClass 'win32' (Windows). On Windows the wire path became '\Users\test\x.ts' and the assertion failed. Mirror toClientPath in the test: expect backslash separators on win32 and the raw path otherwise. Implementation is unchanged. * test(sdk): normalize workDir and skillDir paths in session tests SessionStore.create/list and the skill loader normalize paths through pathe (forward slashes). The SDK tests compared the resulting workDir and skill loaded-dir against raw mkdtemp / node:path strings, which use backslashes on Windows (and node:fs realpath also returns backslashes for the skill dir), failing three toMatchObject assertions. Build the expected paths with agent-core's normalizeWorkDir so they match the internal pathe representation on every platform. The skill dir keeps its realpath() (the loader realpaths the root) and only normalizes separators. * test(skill): normalize realpath to forward slashes in scanner tests resolveSkillRoots normalizes every root.path through fs.realpath followed by replacing backslashes with forward slashes (scanner.ts). The scanner tests compared root.path against node:fs realpath directly, which returns backslashes on Windows, so twenty assertions failed (toEqual / toContain / toHaveLength) even though the resolved paths were identical. Wrap realpath at the top of the test file to mirror the implementation's normalization, so every comparison uses the same forward-slash form on every platform. * test: skip Unix-only permission tests on Windows The Unix file-permission assertions (mode bits like 0o600 / 0o700 and chmod 000 making a path unreadable) have no equivalent on Windows, which uses ACLs; fs.chmod there can only toggle the read-only bit. These six tests failed on Windows with mismatched mode values or a missing 40411. Skip them on win32 via it.skipIf(process.platform === 'win32'): oauth FileTokenStorage (0600 file, 0700 dir), agent-core BackgroundTaskPersistence (0700 tasks dir), agent-core createPerIdJsonStore (0700 subdir), migration-legacy atomicWrite (0600 file), and server fs:browse (chmod 000 -> 40411). * test(tui): make platform-sensitive assertions cross-platform The TUI implementations are already platform-aware (pathe-style paths, pathToFileURL, quoteShellArg cmd/POSIX quoting, Alt+V on Windows for paste expansion), but the tests hard-coded POSIX expectations and failed on Windows. Align the assertions with the implementation's platform behavior: footer-goal-badge matches the '[goal' badge prefix instead of /goal/ (toolbar tips contain '/goal'); tool-call expects backslash relative paths on win32; plan-box builds the file:// URL via pathToFileURL; custom-editor sends Alt+V on win32 for paste expansion; file-mention-provider normalizes the expected description to forward slashes; kimi-tui-startup builds the resume command with quoteShellArg; kimi-tui-message-flow builds the expected install path with resolve(). * test: align path assertions with pathe on Windows Several test suites asserted paths produced by node:path/node:os/node:fs against values that agent-core, node-sdk and kaos normalize through pathe (forward slashes). On Windows the two forms diverge (backslashes vs forward slashes), failing about 19 assertions. Mirror the implementation's normalization in the assertions via a local toPosix helper (or agent-core's normalizeWorkDir), so expected paths use forward slashes on every platform: kaos LocalKaos, node-sdk export/list/resume/config/transport sessions, cli FileMentionProvider, and agent-core skill-session. * test(native): build path expectations with node:path.resolve paths.mjs builds every path with node:path.resolve, which yields backslash-separated absolute paths on Windows. The path-helpers tests asserted against template strings that mixed the backslash appRoot with forward-slash segments, so Object.is failed on Windows even though the strings looked identical. Build the expectations with the same resolve(appRoot, ...) helper so the separators match on every platform. * fix: make Windows CI tests pass across all packages Fix the remaining Windows CI failures so the Windows test job can go green. The changes fall into a few categories: - Path separators: agent-core/node-sdk/kaos normalize paths via pathe (forward slashes); align test expectations and a couple of implementations (native cache base, workspace registry) with that. - Platform-only services: skip launchd/systemd manager suites on win32 (Windows uses schtasks). - Process/signal lifecycle: skip or relax tests that rely on POSIX signals / SIGTERM semantics that Windows does not support. - Hook shell syntax: rewrite hook test commands from POSIX shell (single quotes, semicolons, stderr redirects, if/then/fi) to node -e / .cjs files that run under cmd.exe. - CRLF: make Bash tool description stripping tolerate CRLF line endings. - Misc: realpath short-name divergence, port-retry timing, telemetry spawn, fs-watch timing, snapshot path normalization, etc. * fix: remove unused basename import in workspaceRegistryService Fix lint error (no-unused-vars): basename from node:path is no longer used after switching to posixBasename from pathe. * fix: align resume harness pathClass and wait for banner state on Windows Two more Windows CI fixes: - createResumeNoSideEffectKaos now reports pathClass 'win32' on Windows so tool descriptions (e.g. Glob's Windows note) match the live agent in expectResumeMatches, fixing usage/description deep-equal drift. - kimi-tui-startup once-banner test now waits for writeBannerDisplayState to land before asserting, since the atomic write can lag behind the render on Windows. * fix: resolve remaining Windows unit test failures Make the new Windows CI job green across agent-core, kaos, node-sdk and server: - Align the resume harness kaos pathClass with the live agent so platform-conditional tool descriptions (Glob's Windows note) match in expectResumeMatches instead of drifting on win32. - Rewrite hook commands in agent-core tests as cross-platform node one-liners; single-quote echo, >&2 and ';' do not work under cmd.exe. - Add .gitattributes enforcing LF so raw-imported templates (e.g. the compaction instruction) produce byte-identical token counts on Windows and POSIX. - Terminate the full process tree on Windows in both the hook runner and kaos (taskkill /T /F) so grandchildren cannot outlive their parent and keep the cwd locked. - Normalize workDir path separators in two kimi-sdk session tests to match the stored canonical form. - Avoid cmd.exe arg-quoting pitfalls in the kaos cmd.exe test, and run the Windows process-tree kill test from a script file with the pid path passed via argv. - Give the first fs-git e2e test more time on Windows and retry the temp-dir cleanup; skip the fs-watch overflow-burst assertion on Windows where fs-event coalescing prevents the single-window spike. * ci: retrigger checks * fix: resolve remaining Windows failures after merging main - Terminate the spawned git/gh process tree on Windows in FsGitService (taskkill /T /F on timeout) so a timed-out 'gh pr view' cannot leave a grandchild holding the workspace cwd, which made the fs-git e2e cleanup fail with EPERM. - Give the fs:git_status e2e suite a longer timeout on Windows and retry the temp-dir cleanup longer to ride out the slower child-process teardown. - Make the third-party plugin install trust test assert the resolved install path via node:path so it matches the Windows-resolved path (D:\tmp\...) as well as the POSIX one. * fix: align workspace registry roots and harden fs-git cleanup on Windows - workspace-registry test: compare normalized (forward-slash) roots, since the registry and session index both store workDir via pathe.resolve (forward slashes on every platform). realpath() yields backslashes on Windows and diverged from the stored root. - fs-git e2e: bump the temp-dir cleanup retries and the afterEach timeout, since Windows child-process teardown after server.close() is asynchronous and can keep the workspace cwd locked for several seconds. * test: stub openUrl in kimi-tui-message-flow feedback tests The /feedback command falls back to openUrl(FEEDBACK_ISSUE_URL) when submission fails, which spawned a real browser window on every test run. Mock #/utils/open-url (matching the existing login/message-replay/server test convention) so the suite never opens a browser. * test: harden fs-git e2e cleanup against Windows cwd locks On Windows, git/gh child processes and the session core process can outlive server.close() and keep the temp workspace as their cwd, so rmSync fails with EPERM even after a long retry. Add rmSyncRobust that retries and, if the cwd is still locked, swallows EPERM/EBUSY on Windows — the OS reclaims the temp dir and a cleanup hiccup must not fail an otherwise-passing test. * test: harden server e2e cleanup against async teardown races server.close() does not fully await the server's asynchronous teardown, so on a loaded CI runner the temp home/workspace dirs can still be held or written to when the afterEach rmSync runs, failing with EPERM (Windows) or ENOTEMPTY (Linux). Use a rmSyncRobust helper (retry + swallow EPERM/EBUSY/ENOTEMPTY) in the fs-git and question e2e cleanup. Also fix a leftover `throw err` (renamed to `throw error`) that broke the typecheck.	2026-06-26 11:56:41 +08:00
7Sageer	843a731097	fix: classify OAuth token refresh errors by cause (#838) ... Map OAuth token-fetch failures to distinct public error codes instead of collapsing them all to auth.login_required: - missing/revoked tokens or 401/403 from the refresh endpoint -> auth.login_required - transport failures and 429/5xx after internal retries -> provider.connection_error - anything else is rethrown as-is (surfaces as internal) rather than guessed The refresh helper already retries internally, so the agent loop does not re-retry these. Both the managed provider and the standalone SDK provider share the same mapping.	2026-06-17 18:34:42 +08:00
liruifengv	5306fd70c5	feat(update): roll out automatic updates in staged batches via CDN manifest (#691) ... * feat(update): roll out automatic updates in staged batches via CDN manifest * chore: remove changeset * refactor(update): single-source the CDN latest file names * refactor(update): reuse the CDN latest URL constants in update checks * refactor(update): drop the test-only CDN base override * fix: preserve first launch attribution * fix: use refreshed rollout manifest for telemetry * fix: abort hung cdn update checks * fix: preserve update cache with bad manifest * chore: remove review report from branch	2026-06-15 16:52:44 +08:00
Haozhe	d1ba14562b	feat(providers): sync custom registry providers on startup refresh (#675) ... * feat(providers): sync custom registry providers on startup refresh - group registry providers by URL and retry available API keys\n- automatically add new providers and remove disappeared ones\n- coalesce duplicate source URLs to avoid false config-change reports\n- clear defaultThinking when default model is removed\n- update docs and add tests for registry sync scenarios * fix(tui): only show provider refresh status for added models Skip removed / metadata-only provider updates when reporting model list changes.\n\n add: test to enforce the behavior.	2026-06-12 17:08:40 +08:00
7Sageer	c1191f5794	test: redact internal endpoint fixtures (#688)	2026-06-12 15:05:26 +08:00
liruifengv	596cadd465	feat: support always-thinking models via supports_thinking_type (#662) ... Map the /models three-state supports_thinking_type field ('only' / 'no' / 'both', taking precedence over the legacy supports_reasoning boolean) onto the existing always_thinking capability: - oauth: parse the field in both /models parsers; 'only' emits always_thinking alongside thinking, 'no' suppresses thinking even when supports_reasoning is set, absent falls back to the legacy boolean. Default thinking selection is forced on for 'only' (and off for 'no') models during login and provider refresh - TUI: render the thinking control with a fixed On/Off layout — locked models show a greyed-out "Off (Unsupported)" segment, and non-thinking models mirror the style with "On (Unsupported)" - agent-core: clamp thinkingLevel at the getter so a stale thinking-off config can never reach the request builder, status events, or subagent inheritance - acp-adapter: derive alwaysThinking from capabilities, collapse the thinking select to a single locked "on" entry, and ignore off requests for locked models while re-emitting the snapshot	2026-06-11 23:16:02 +08:00
github-actions[bot]	12d062d48e	ci: release packages (#390) ... Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2026-06-04 21:45:01 +08:00
7Sageer	232ed874d4	fix: scope managed OAuth credentials (#399) ... * fix: scope managed OAuth credentials * refactor: centralize managed OAuth auth resolution	2026-06-04 13:14:18 +08:00
github-actions[bot]	14cd8d098b	ci: release packages (#296) ... Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2026-06-02 22:54:57 +08:00
Haozhe	7284f30479	fix(oauth): fix multi-provider custom registry import losing providers (#335) ... - Add `applyCustomRegistryEntries` helper to apply all entries in-memory before a single write - Update CLI Add Platform flow to use it, replacing interleaved in-memory mutations with removeProvider RPCs - Add regression tests for repeated imports and provider field refreshing	2026-06-02 20:05:00 +08:00
github-actions[bot]	121a6dd2a1	ci: release packages (#237) ... Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2026-06-02 10:22:31 +08:00
Haozhe	42bb9141d8	feat(tui): add /provider command, custom registry import, and tabbed model selector (#264) ... * feat(tui): add /provider command, custom registry import, and tabbed model selector - add "/provider" slash command for managing AI providers with CRUD UI - add custom registry import via api.json URL and Bearer token - introduce tabbed model selector grouped by provider - add fetchCustomRegistry and applyCustomRegistryProvider in oauth package - replace deprecated "/connect" command with unified "/provider" flow - update provider and slash-command documentation * feat(tui): background provider model refresh at startup - add `refreshAllProviderModels` utility supporting managed OAuth, open platforms and custom registries - wire background refresh into `KimiTUI` startup via `AuthFlowController` - add `providerSwitchHint` option to `ModelSelector` and enable it in `TabbedModelSelector` - update `TabbedModelSelector` hint wording from "switch" to "provider"	2026-06-01 18:46:40 +08:00
qer	a1dfbfeb16	fix: clarify Kimi Platform login copy (#274)	2026-06-01 18:43:01 +08:00