84 commits

Author	SHA1	Message	Date
github-actions[bot]	472192c34c	ci: release packages (#4220) ... Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2026-10-14 23:25:04 +08:00
grapedge	afd95f64a5	feat(tui): unify skill prompts and steering (#4165)	2026-10-13 12:17:14 +08:00
7Sageer	cbd754049a	chore: remove unused kaos package and MCP kaos executor option (#4184) ... * chore: remove unused kaos package and MCP kaos executor option * chore: update nix pnpmDeps hash after kaos removal * chore: harden resume coalesce key against legacy kaos arguments and condense changesets * chore: strip legacy kaos options before forwarding session RPCs * chore: drop ssh2 overrides left unused by kaos removal	2026-10-12 18:43:56 +08:00
Kai	c15638b0a1	fix: cancel in-flight video uploads when media reads are interrupted (#4183)	2026-10-12 17:02:18 +08:00
Grapedge	3cc6b2a330	feat(kimi-code): carry turn trace id and copilot stats in rating surveys (#3907)	2026-09-18 19:49:19 +08:00
STAR-QUAKE	5acc863ae6	feat(agent-core-v2): make select_tools failures actionable (#3885) ... Co-authored-by: starquakee <starquakee@users.noreply.github.com>	2026-09-18 16:27:23 +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	da31c472a2	feat(agent-core-v2): add skill scopes and mark custom-theme as tui-only (#3843) ... * feat(agent-core-v2): add skill scopes and mark custom-theme as tui-only Builtin skills can now declare a scopes whitelist (tui | web); skills without scopes stay visible everywhere. The value is carried through SkillSummary, the klient RPC contract, and the kap-server REST wire, and the TUI slash commands filter by it. HTTP clients (code-app) drop skills whose scopes exclude their own UI mode, so TUI-only skills like /custom-theme no longer leak into app/web. * fix: filter scoped skills from the acp and vscode palettes ACP slash commands and the VS Code GetSlashCommands handler also project SkillSummary lists; both now drop skills that carry a scopes restriction so tui-scoped skills stay out of non-tui clients.	2026-09-16 19:14:22 +08:00
7Sageer	5653c739b9	feat(agent-core-v2): upload images as file references for Kimi models (#3784) ... * feat(agent-core-v2): upload images as file references for Kimi models * fix(agent-core-v2): scope media upload cache by endpoint and recognize SDK auth error status * fix(agent-core-v2): restore the stripped /v1 for kimi files uploads on the anthropic route * feat(agent-core-v2): omit oldest media when accumulated inline media exceed the request budget * fix(agent-core-v2): key the media upload cache by the stable JWT subject * fix(agent-core-v2): harden media request recovery * fix(agent-core-v2): correct image memo accounting * feat(agent-core-v2): include saved paths in dropped media placeholders * docs: drop the saved-path re-read guarantee from the media budget note The guarantee does not hold for inline data-URL media (no persisted path exists), and the runtime warning already conveys path availability when it applies. Addresses the codex P2 review suggestion by removal.	2026-09-15 21:32:42 +08:00
7Sageer	f2f9162dc1	refactor(agent-core-v2): clarify human-layer names (#3727) ... * refactor(agent-core-v2): clarify human-layer names * refactor(agent-core-v2): name provider-holding members after their role - LlmRequestConfig/LlmRecoveryContext/adapter Model: credentials -> credentialProvider - requester/provider convertError option -> classifyError (matches LlmErrorClassifier) - kimiOAuthCredentialProvider -> createKimiOAuthCredentialProvider - ModelCatalog.buildCredentials -> buildCredentialProvider * refactor(agent-core-v2): rename the format-layer error hook to classifyErrorHook threads the requester's classifyError option through under a matching name * refactor(agent-core-v2): finish the human-layer naming pass - turn.failure.classified -> turn.failure.recovery.evaluated - recovery proposal beforeRetry -> beforeNextAttempt - llmRequester currentCredentials/credentialsForTurn -> currentCredentialProvider/credentialProviderForTurn - unexport ProtocolTraitsByName (only backs ProtocolTraitFor) * refactor(agent-core-v2): shorten the turn failure event to turn.failure.evaluated	2026-09-15 20:09:27 +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
Haozhe	4623395379	refactor(agent-core-v2): fold the prompt queue into the agent loop service (#3747) ... * refactor(agent-core-v2): fold the prompt queue into the agent loop service Delete AgentPromptService/IAgentPromptService: prompt submit/queue/steer/ abort now ride the agent machine queue through IAgentLoopService's extended surface (submitPrompt/submitSteerPrompt/enqueuePrompt/steerPrompts/ abortPrompt/drainPrompts/injectPrompt/retryPrompt/promptQueue plus hooks.onBeforeSubmitPrompt and the promptAdmission reservation slot). Durable prompt.* event classes move to agent/prompt/promptEvents.ts and keep their registrations; promptAdmissionKey keeps its fold. Dead assets go away: promptResolutionKey, PROMPT_ALREADY_COMPLETED (kap-server 40903 path), promptLaunchingKey and clear(). Compaction gating (queue while compacting, resume on finish) moves into the loop reservation drain. The 'agentPromptService' wire name keeps its shape: a thin AgentPromptChannel facade (same decorator id) forwards submit/submitSteer to the loop, so klient memory/ipc/debug transports and the kap-server dispatcher are unchanged. * test(agent-core-v2): re-pin prompt queue semantics on the loop service Rewrite promptService.test.ts (25 cases, count unchanged) against the real AgentLoopService with the scripted-LLM harness, fold the launch-window reservation out of promptQueue().pending to match the old snapshot contract exactly, and update the debug-channels pin to the facade's submit/submitSteer surface. * refactor(agent-core-v2): lint-align the loop prompt queue surface * fix(agent-core-v2): settle prompt completions on the turn-result chain Match the deleted service's microtask position: prompt.completed/aborted and the completion deferreds fire from a result.then chain attached at bind time instead of synchronously inside endTurn, so wire/emit ordering with post-turn producers (tool unregister, next-prompt launch) stays identical to the baseline snapshots. Steered children move onto the reservation so the chain can settle them after the active turn is gone. * refactor(agent-core-v2): move the prompt-submit gate into the agent machine * refactor(agent-core-v2): keep image compression captions inline in prompt messages * refactor(agent-core-v2): drop the durable prompt admission facility * refactor(kap-server): resolve prompt auth at turn runtime instead of submit time * refactor(agent-core-v2): teach the agent machine queue metadata, multi-id steer, gate rewrite, and pause * refactor(agent-core-v2): converge prompt submission on machine queue user entries * refactor(agent-core-v2): replace loop prompt records with a waiter registry fed by machine events	2026-09-14 15:07:18 +08:00
7Sageer	18f77efad6	refactor(agent-core-v2): plug llm credentials in through request config (#3682) ... * fix(agent-core-v2): honor request-level toolMessageConversion in openai formats The requester already forwarded LlmRequestConfig.toolMessageConversion into formatRequest, but the openai chat and openai-responses formats only read the trait hook, so the explicit request config was silently ignored. Resolve the mode as request config, then trait default, then the protocol default, and pass the resolved value into lowering. * refactor(agent-core-v2): split the protocol trait into per-protocol dialects and provider connection The ProtocolTrait interface bundled endpoint/headers connection config, model capability, message/params conversion hooks, and error classification into one bag, and every format received the whole bag whether or not it consumed each hook — hooks a protocol ignores were accepted by the type system and silently dead at runtime. Split it by consumer: - ProviderConnection (protocol/connection.ts): endpoint env declaration and default headers, still resolved per request inside generate. - Per-protocol typed dialects (OpenAIDialect, OpenAIResponsesDialect, AnthropicDialect, GoogleGenAIDialect): only the customization points each protocol actually consumes; data-shaped hooks (reasoningKey, toolCallIdPolicy, toolMessageConversion, strictThinkingValidation) are data fields, and message/history hooks use the protocol wire types instead of Record<string, unknown>. - convertError moves to a requester option, capability to a provider variant field. Dialects are bound when the format is created (createOpenAIFormat and siblings), so FormatRequestInput and the stream parser carry request data only; ProtocolTrait is deleted. The thinking hook returns the kwargs and the preserveThinking flag together as ThinkingApplication, and the kimi dialect emits the final thinking params directly instead of routing them through an extra_body flatten in buildParams. The llm-adapter layer is migrated to the same {connection, dialect, convertError} assembly. * refactor(agent-core-v2): compose format stages and dialect hooks in the requester pipeline * refactor(agent-core-v2): rename protocol dialects to traits * fix(agent-core-v2): include the system message in openai mergeHistory input * refactor(agent-core-v2): enforce the format/trait contract boundary - move CONTEXT_MANAGEMENT_BETA into anthropic/contract and have the kimi trait import wire types from each protocol's contract.ts instead of format/lower; export the four contract modules from human/index.ts and guard the boundary in check-import-boundaries - rename protocol/trait.ts to protocol/thinking.ts and move TraitContext to protocol/base.ts; clean up the remaining dialect-era test variable - type extractUsage as OpenAIRawUsage / OpenAIResponsesRawUsage instead of Record<string, unknown> and drop the requester-side casts * refactor(agent-core-v2): thread the request config by spread and drop dead format types - the four requesters spread LlmRequestConfig into the plan input instead of hand-enumerating fields, so a new cross-protocol config field cannot be silently dropped per protocol - ProtocolFormat loses the phantom TRequest/TResponse type parameters; the dead OpenAIRawResponse/AnthropicRawResponse/GoogleRawChunk contract types go with them - the thinking test now names the extra_body flatten behavior explicitly * refactor(agent-core-v2): keep protocol format modules internal to the requester pipeline - drop the four format barrels (and openai/reasoning-key) from human/index.ts; each base's public seam is now exactly contract / trait / requester - stop re-exporting contract wire types from format/lower modules so the neutral vocabulary has a single home; move the *LoweredMessage staging types out of contract into the owning format module - guard the seam in check-import-boundaries: only llm/requester/bases code and tests may import format/lower/patterns/reasoning-key * refactor(agent-core-v2): plug llm credentials in through request config Replace the withAuth/withAuthUpload requester decorators with a credential contribution point on LlmRequestConfig: the llm machine's request actor (machine path) and ModelRequesterImpl (direct path) resolve credentials per attempt, and a recoverable 401 is recovered by invalidating and re-resolving — emitted as llm.recovering on the turn machine's credentials branch. * fix(agent-core-v2): surface request-actor failures as llm.failed.remote A rejection inside the llm machine's detached request actor (credential resolution, message resolvers, or a throwing requester) could not reach the machine, leaving the turn stuck in thinking. Convert it to an llm.failed.remote event so the turn lands in its failed state. * docs(agent-core-v2): attribute retry/recovery to the turn machine in llm.md * refactor(agent-core-v2): unify credentials in human/credentials, turn-owned 401 recovery * fix(agent-core-v2): credential recovery for direct paths, abort guard, turn-snapshotted credentials * feat(agent-core-v2): IModelCatalog.generate with stream credential recovery * refactor(agent-core-v2): inline credential recovery at call sites Remove the attemptWithCredentialRecovery/streamWithCredentialRecovery helpers from human/credentials; the single-retry recovery is now written out at each direct call site (catalog ping/generate, full compaction, media upload) so the control flow reads linearly without a wrapper hop. The credentials module keeps only the provider factories and the credential application helpers; recoverability and invalidation stay on the LlmCredentialProvider itself. * fix(agent-core-v2): settle the queued turn when a machine turn settles before gating When the llm machine fails before requester.generate() runs — for example when OAuth credential resolution rejects — the loop cleared the pending machine turn marker on turnSettled without ever binding or settling the queued reservation, leaving the submitter's ready/result promises and settled() hanging. The loop now settles the unbound reservation explicitly: cancelled on abort, failed otherwise, mirroring the evaluateSettle error propagation. * fix(agent-core-v2): bind and end pre-gate failures through the normal turn lifecycle The direct settlement resolved turn.result without endTurn(), so no TurnPrompt/TurnStarted/TurnEnded/AgentErrorEvent was published and the next queued reservation was never launched. The unbound reservation is now bound via beginActiveTurn and ended via endTurn (failed, or cancelled on abort), chained onto afterChain when the previous turn is still settling, so pre-gate failures get the same lifecycle events and queue progression as any other failed turn. * fix(agent-core-v2): settle seeded turns on pre-gate failure, preserve coded credential errors, close steps on recovering - Notification-seeded machine turns that fail before gating now bind a seeded reservation and end through endTurn like queued ones, instead of leaving the nudge pending and settled() hanging - The llm machine's request actor attaches the raw error to llm.failed.remote and the turn machine prefers it for its terminal failure, so coded errors (e.g. auth.login_required) survive to endTurn's error payload - projectMachineEvent now closes the current machine step on recovering exactly as it does on retrying, keeping step.begin/step.end balanced when credential recovery re-enters the request * fix(kap-server): add generate to IModelCatalog test fakes * fix(klient): migrate examples to the credentials API * test(agent-core-v2): drop credential recovery coverage * refactor(agent-core-v2): fold kimi-oauth credential adapter into credentials/ * refactor(agent-core-v2): pair credential refresh with invalidate, optional Model.credentials, abort-safe request actor - oauthCredentials.invalidate() now starts the forced refresh eagerly and hands the pending token to the next resolve(), so the force signal can no longer leak into or be consumed by unrelated resolves - Model.credentials becomes optional, dropping the {} as never / staticCredentials(undefined) filler in test fakes - the llm machine request actor swallows abort outcomes instead of reporting llm.failed.remote, so an aborted turn settles as aborted rather than failed * refactor(agent-core-v2): credentials recovery strategy chain, shared credential-recovery executors, single-proposal failure triage * fix(agent-core-v2): settle message-less notifications on pre-gate failure, recover credentials in media resolver uploads * test(kap-server): add the IModelCatalog.generate stub to the history suite	2026-09-10 20:39:22 +08:00
Kai	9f7e68e8bd	fix(mcp): preserve original attachments omitted from model output (#3688) ... * fix(mcp): preserve original attachments omitted from model output * test: register session media storage in agent lifecycle fixture * fix(mcp): retain media originals and bound attachment details * fix(mcp): resolve session attachments and honor cancellation * test: check concrete media references in provider requests * fix(media): read session attachments from their owning storage * fix(media): preserve attachment access across runtime and history changes * fix(mime): recognize structured application text attachments	2026-09-10 10:37:31 +08:00
Haozhe	56ed9549c6	refactor(agent-core-v2): remove AgentActivityView and project v1 agent phase at kap-server edge (#3678)	2026-09-09 17:18:36 +08:00
Haozhe	68f8984a7c	refactor(agent-core-v2): single producer for turn and step ids (#3662) ... - the human agent state machine now assigns turn ids and echoes the drained queue item in turn.started; the facade adopts machine ids instead of reserving its own - the turn machine produces the step ordinal and surfaces it via a first-class step.started fact; the llm requester layer stays step-agnostic - turn.prompt wire records carry an explicit turnId; turnKey and transcript foldFacts read it directly with a counting fallback for legacy records - queued prompts are addressed by promptId: cancel(turnId) is active-turn only, cancelQueued targets queue entries, Turn.id resolves once the turn starts - drop PromptPayload.disabledTools and its klient/node-sdk pass-through (no client consumer)	2026-09-09 15:24:02 +08:00
Kai	80480c01d2	feat(agent-core-v2): accept HEIC, HEIF, and BMP images for Kimi models (#3649) ... * feat(agent-core-v2): accept HEIC, HEIF, and BMP images for Kimi models Key the accepted image MIME set by the provider the agent is bound to instead of a single global allowlist: Kimi accepts PNG/JPEG/GIF/WebP plus BMP/HEIC/HEIF, every other provider keeps the baseline set. The provider image policy lives in the human layer (`llm/media/image-formats`) so both the agent-side gates and the Anthropic protocol lowering share it. - thread the provider type through every ingestion gate: ReadMediaFile, prompt entry, MCP tool results, session media references, kap-server prompt/skill routes; expose it via IAgentProfileService.getModelProviderType - ReadMediaFile sends accepted formats it cannot re-encode locally inline up to the provider's per-image budget (5MB for Kimi, 3.75MB otherwise) and points at a conversion command above that; full_resolution uses the same provider budget - acp-server no longer gates formats itself and leaves the decision to the engine prompt pipeline, which knows the bound provider - the Anthropic lowering allowlist follows the bound provider so Kimi over the Anthropic-compatible protocol no longer rejects HEIC client-side * fix(agent-core-v2): resolve the image format policy on the production paths Follow-ups from review of the provider-aware image formats: - the Anthropic lowering read the policy from `LlmModel.provider`, which the adapter registry sets to the route id (`anthropic`) rather than the model's provider type, so Kimi over the Anthropic-compatible protocol still rejected HEIC client-side; the accepted set now comes from a `ProtocolTrait.acceptedImageMimes` hook that the Kimi traits implement, and the test goes through the real trait with the routed provider id - kap-server prompt ingestion gated media against the currently bound model even when the same request selected another model; the profile service now resolves the provider type for a requested alias - the session media memo served a cached inline image to a provider that does not accept its format; memo hits are re-judged against the current provider before being returned - the media tools registrar keyed ReadMediaFile only by alias and capabilities, so a reload that changed the alias's provider type or protocol kept the stale tool; both now take part in the key * test(kap-server): keep the optional chain the lint autofix dropped	2026-09-08 19:28:23 +08:00
Haozhe	9188d03c99	refactor(protocol): remove package and relocate wire types into agent-core-v2 (#3646)	2026-09-08 17:41:41 +08:00
Haozhe	14cc78611d	refactor(agent-core-v2): replace interaction DI services with a global human singleton (#3644) ... * refactor(interaction): replace per-agent InteractionService with human-native session facade - add human/interaction: global interaction machine + tag-query facade (enqueue/respond/findAll/findOne/wait) - add session-scope SessionInteractionService owning one interaction actor per session - rewire approval/question/userTool/sessionActivity to the session facade and delete features/interaction * refactor(interaction): rewire kap-server, klient and node-sdk to the session interaction facade - kap-server routes, ws broadcaster and transcript binding read ISessionInteractionService (tags replace origin) - klient memory dispatcher delegates to the session service; zod contract mirrors origin -> tags - node-sdk session wiring subscribes the session service directly - register interaction wire events in their new home and regenerate the wire manifest * refactor(agent-core-v2): replace interaction DI services with a global human singleton resolve rebase conflicts	2026-09-08 17:39:16 +08:00
Haozhe	324774d812	test: stabilize the full suite on macOS developer machines (#3643) ... - scrub all ambient KIMI_CODE_* env vars in the agent-core-v2 and kap-server test setups so developer shell env cannot leak in - drop the load-sensitive stepRetry fake-timer cases and the three FSEvents-based skill catalog watch cases - give node-sdk, klient and the vscode extension project an explicit 15s testTimeout matching their integration-test nature - retry temp-dir removal in taskManager teardown to absorb async terminal-effect writes	2026-09-08 16:21:16 +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	485594f65e	refactor(agent-core-v2): absorb the human layer and replace the agent loop with a facade over its turn state machine (#3580) ... * refactor(agent-core-v2): absorb the human layer into src/human and rename vendored kosong to llm-adapter * feat(agent-core-v2): preserve media attachment names in human message contract * refactor(agent-core-v2): remove llm-adapter code duplicated in human/llm * refactor(agent-core-v2): replace the agent loop with a facade over the human turn state machine * refactor(agent-core-v2): rename the loop adapter layer to loop/machine * test(acp-server): implement gateway resolve in the scripted provider stub * refactor(agent-core-v2): restore v2 batch semantics in the loop machine tools adapter - delegate each step's tool calls to the v2 tool executor as one whole batch: beginBatch arms the expected call set from the llm.done entry, per-actor execute calls collect into a pending barrier, and the full batch is submitted in tool-call order once complete - drop the serial batchChain/batchStopped/skipped approximation so the executor's prepare-stage stopBatchAfterThis skip, veto short-circuit, and ToolScheduler access-based concurrency apply natively again * fix(build): update flake pnpmDeps hash for the post-absorb lockfile * fix(agent-core-v2): align loop facade reservations with the machine queue by id * fix(agent-core-v2): drain persisted wire records before turn end * fix(agent-core-v2): route executor-level tool errors to the loop error path and backfill aborted tool results on forced abort * fix(agent-core-v2): keep turn step retrying in the facade step numbering space	2026-09-06 22:26:35 +08:00
Haozhe	ae7a6dc6fb	refactor(acp): remove the legacy acp-adapter package (#3434)	2026-09-01 23:59:20 +08:00
Haozhe	9c37feb473	perf(agent-core-v2): fork sessions without materializing the target (#3421) ... * fix(agent-core-v2): persist plan.revision as agent-relative key - replace the session-scoped `path` field in durable plan.revision records with an agent-relative `key`, resolved to a display path at read and projection time against the current agent/session scope - migrate legacy `path` records during wire restore and rewrite the journal once migration succeeds, emitting low-cardinality `wire_plan_revision_migrated` telemetry - tolerate journal truncation during the migration rebuild and keep the legacy `path` display in cold transcript folds for unmigrated records - keep external transcript marker `path` and meta `reviewPath` projections unchanged * perf(agent-core-v2): fork sessions without materializing the target - copy session files byte-for-byte (wire.jsonl included, parallel file writes) and append the forked marker per agent instead of parsing and rewriting every wire journal - write the forked session's state.json, agent registry, and session index entry directly without creating a live session or agent scopes; fork returns SessionMeta and SessionForkedEvent drops the scope handle - keep turnIndex truncation on the per-record path - kap-server fork/createChild routes, the klient facade and wire contract, and the node-sdk forkSession resume the forked session through the normal resume path when a live handle is needed - stop healing truncated source wires during fork; the forked session repairs its own copy lazily on resume - add the `kimi fork [--cwd] [-y]` CLI command	2026-09-01 19:46:35 +08:00
Haozhe	15bf58555b	refactor(agent-core-v2): replace agent runtime with agent-scoped DI services (#3402) ... * refactor(agent-core-v2): migrate todo domain to agent-scoped DI service * refactor(agent-core-v2): migrate skill domain to agent-scoped DI service * refactor(agent-core-v2): migrate reminder domain to agent-scoped DI service * refactor(agent-core-v2): migrate interaction domain to agent-scoped DI service * refactor(agent-core-v2): migrate cron domain to agent-scoped DI service * refactor(agent-core-v2): migrate dateChange domain to agent-scoped DI service * refactor(agent-core-v2): migrate goal domain to agent-scoped DI service * refactor(agent-core-v2): remove agent runtime infrastructure * docs(agent-core-v2): rewrite agent domain standard as agent-scoped DI service * fix(agent-core-v2): restore actor services on late feature re-provide and order agent-created events after metadata registration	2026-08-31 22:53:29 +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
Haozhe	f4dc9ba1ae	refactor(agent-core-v2): migrate skill domain to agent runtime (#3202) ... - define the AgentSkill contract and SkillRuntime (activate / promptWithSkills / recordModelToolActivation) with a lazy, non-durable provider; recordActivation dispatches SkillActivated directly and the skillKey / SkillActivate relay is gone - allow agent runtime descriptors to omit logic (durable definitions still require it), making skill the first pure-API domain - featurize the skill domain: app/skillCatalog, workspace/workspaceSkillCatalog, session/sessionSkillCatalog, agent/skill, and agent/tools/skill move under src/features/skill; the static Skill tool registration and the AgentSkillService are gone - resolve the runtime at the edge: kap-server routes and node-sdk activateSkill go through IAgentLifecycleService.resolve, and the klient dispatcher keeps the agentSkillService wire name over a per-agent view	2026-08-24 18:53:04 +08:00
Haozhe	9a715820c4	refactor(agent-core-v2): featurize todo/cron/interaction and migrate goal to agent runtime (#3184) ... * refactor(agent-core-v2): featurize todo/cron/interaction and migrate goal to agent runtime * refactor(agent-core-v2): move cron scheduling helpers into features/cron/internal	2026-08-23 23:03:51 +08:00
Haozhe	368b4b7400	refactor(agent-core-v2): migrate agent domains to agent runtime architecture (#3175)	2026-08-23 17:36:59 +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
7Sageer	f6736d7c0d	feat(agent-core-v2): add a fork parameter to the Agent tool (#3007) ... * feat(agent-core-v2): add a fork parameter to the Agent tool Spawning with fork: true starts the subagent from a one-time snapshot of the calling agent's completed conversation history — same profile, tool set, and model — instead of zero context. The seed trims the trailing open tool exchange (the in-flight Agent call itself) before appending into the child's context memory, and the first prompt carries an inheritance notice framing the seeded history as reference material. Fork rejects resume, a different subagent_type, or a model override as tool errors, and skips the subagents allowlist since a self-inheritance is not a delegation. * fix(agent-core-v2): bind the stale-todo reminder only into the main agent Subagents share the session todo list but no longer receive the stale-todo nudge — the reminder injector now registers only on the main agent, so delegated and forked agents are not prompted to maintain a list they do not own. * fix(agent-core-v2): inherit the caller's live binding and label fork launches correctly Review follow-ups for the Agent tool fork mode: - overlay the caller's live profile.data() via applyBindingSnapshot after the catalog re-bind, so ephemeral addActiveTool deltas, the rendered system prompt, and runtime model/subagents updates survive the fork; skip the profile prompt prefix since the caller's prefixed first prompt is already part of the seeded history - resolve the fork activity label and approval-rule subject from the caller's own profile instead of falling back to the default subagent type, so an Agent(<other profile>) rule cannot approve a fork * fix(agent-core-v2): close inherited in-flight tool calls instead of trimming them Fork seeding now answers the source's trailing open tool calls with a synthetic in-flight result instead of cutting the whole trailing exchange: the seeded history stays protocol-valid, keeps the source's final step visible as reference, and no longer confuses side-question (btw) agents forked while the main agent is mid-turn. The close helper is shared by the Agent tool fork and IAgentLifecycleService.fork. Fork launches also stop requiring the caller's profile to still exist in the session catalog: the child is created unbound and overlaid with the caller's live binding snapshot, matching the lifecycle fork path, and now records forkedFrom provenance. * refactor(agent-core-v2): route Agent tool forks through agentLifecycle.fork * feat(agent-core-v2): add a fork parameter to the AgentSwarm tool * fix(agent-core-v2): seal partial assistant forks * fix(agent-core-v2): align fork parameter descriptions * fix(agent-core-v2): drop the main-only registration gate from goal tools * fix(agent-core-v2): disclose dates via reminders to keep the system prompt byte-stable * docs: condense the fork changesets to single sentences * docs(agent-core-v2): frame the tool-contribution when gate as a fork parity trade-off * test(agent-core-v2): plug fork coverage gaps and decouple swarm tests from spawn internals * docs(agent-core-v2): keep the when-gate guidance in the contribution JSDoc only * fix(agent-core-v2): contribute cron tools to every agent for fork prefix-cache parity CronCreate/CronList/CronDelete were registered directly into the main agent's tool registry by SessionCronServiceImpl, bypassing the AgentToolContribution seam and keying on per-agent identity — so a forked agent rebuilt a tool surface three tools shorter than its caller and the inherited prompt prefix missed the cache. Register the three tools through registerAgentToolService like the goal tools do (no when gate, identical surface for every agent) and enforce the main-agent restriction at execution time instead. Also fall back to DEFAULT_CRON_CONFIG when the config section is absent, since the service can now be constructed after the main agent exists. * feat(agent-core-v2): track the fork parameter in the subagent_created event * fix(agent-core-v2): gate tower orchestration tools at execution time TowerInit/TowerPlan/TowerSpawn/TowerMerge/TowerTeardown were contributed with a when predicate keyed on agentId === 'main', so a forked agent rebuilt a tool surface missing TowerInit (always present for the default profile) plus the rest of the tower set once it was enabled — breaking prompt prefix-cache parity with the caller. Contribute the tools with no when gate (profile policy still controls visibility) and reject non-main callers at execution time instead. * test(agent-core-v2): expect the fork field in the subagent_created mirror assertion * test(agent-core-v2): cover fork subagent first-request prefix parity * refactor(agent-core-v2): share the main-agent-only tool refusal across cron and goal tools Goal tools rejected subagent callers by throwing GOAL_UNSUPPORTED_AGENT from the service, which the executor wrapped as a resolution failure; cron tools returned a clean refusal but each tool open-coded the same identity check. Centralize the check and both messages in agent/tools/mainAgentOnly.ts and use it from all seven tools, keeping AgentGoalService.assertSupportedAgent as the coded boundary for RPC and SDK callers. * refactor(agent-core-v2): keep the goal main-agent gate at the tool layer only * fix(agent-core-v2): preserve the fork tool surface when inheriting user tools * Revert "refactor(agent-core-v2): keep the goal main-agent gate at the tool layer only" This reverts commit fc09a8fa32de43bb6223bf96fcab9a7b200ac051. * test(agent-core-v2): complete fork lifecycle stub * Delete .changeset/btw-inflight-tool-calls.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * Delete .changeset/todo-reminder-main-only.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * Delete .changeset/swarm-fork-context.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * Add optional 'fork' parameter to subagent tools Signed-off-by: 7Sageer <sag77r@hotmail.com> * docs(agent-core-v2): drop the fork JSDoc comments * feat(agent-core-v2): add prompt_cache_probe telemetry for forked agents * feat(agent-core-v2): gate the subagent fork parameter behind an experimental flag --------- Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-08-20 21:50:44 +08:00
Haozhe	a09d904140	refactor(agent-core-v2): migrate agent domains to model-as-container architecture (#3103)	2026-08-20 16:06:59 +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
Haozhe	16499408d5	refactor(agent-core-v2): extract externalHooks into a scope-organized feature (#2805) ... Move the external hook services out of app/externalHooksRunner, session/externalHooks, and agent/externalHooks into features/externalHooks, assembled as the ExternalHooksFeature unit: - services live under per-scope subdirectories (app/, session/, agent/); shared pure helpers (types, hook matching/dispatch, process spawn, prompt result rendering) live under internal/ - the runner and the two observers are contributed through the Feature seams (ScopeUnits materialization); the hooks config section stays on the static import=register channel - update the package entry leaf exports, the plugin domain imports, the kap-server events-zod import, and the affected tests; regenerate the state manifest	2026-08-19 16:52:51 +08:00
Luyu Cheng	01eeacb59b	feat(kimi-code): specialize the WaitFor tool's transcript display (#3066) ... * feat(kimi-code): specialize the WaitFor tool's transcript display * feat(agent-core-v2): emit status progress while WaitFor is pending * fix(kimi-code): route WaitFor dimming through the TUI theme * feat(kimi-code): support replaceable status updates in tool progress * fix(kimi-code): forward status progress to subagent activity surfaces * fix(agent-core-v2): drop the redundant undefined from ToolUpdate.replace * fix(kimi-code): honor replace semantics in the subagent live status path * test(agent-core-v2): drive the WaitFor progress test through a manual tick * fix(kap-server): mirror ToolUpdate.replace in the ws event schema * refactor(agent-core-v2): expose the WaitFor progress scheduler as a public seam * fix(kimi-code): pass child wait statuses without the trailing newline * feat(agent-core-v2): tick the WaitFor progress status every second * feat(agent-core-v2): format WaitFor progress durations as 1m 15s * feat(agent-core-v2): omit zero seconds and minutes in WaitFor durations	2026-08-19 14:15:38 +08:00
7Sageer	95cede82b4	fix(agent-core-v2): stop the legacy video resolver from shadowing the media resolver (#3053) ... #2593 replaced AgentVideoResolverService with the image+video AgentMediaResolverService and reduced videoResolverService.ts to a pure deprecated alias with no DI registration. #2909's squash merge restored the pre-#2593 file wholesale, bringing back the legacy class and its registerScopedService call. Both classes then registered the same token ('agentVideoResolverService') at the Agent scope and the legacy video-only resolver won on the production import order, so image kimi-file:// references reached the provider unresolved. Gateways reject the unknown scheme with a 400 ("unsupported image url"), the media-strip fallback then hid the image from the model, and pasted images only worked on undo-resend via the inline base64 fallback. Delete the legacy alias files and their index exports, drop the stale alias assertion, and pin the behavior with a klient e2e regression: a kimi-file image prompt part must reach the provider as a data: URL, never verbatim.	2026-08-18 22:18:49 +08:00
Luyu Cheng	d6021fa036	feat(kap-server): accept bundled skill activations on the prompt submission route (#2982) ... * feat(kap-server): accept bundled skill activations on the prompt submission route The bundled-submission capability was only reachable through the in-process klient transports; the App talks to kap-server over /api/v1. The submit-prompt route now accepts an optional non-empty skills field and delegates to IAgentSkillService.promptWithSkills — same validation, events, and single bundled user message as the TUI path — skipping its own prompt-metadata update (the engine owns it there) and mapping skill.not_found / skill.type_unsupported onto the skills route's codes. To return the submission's queue identity, the engine's promptWithSkills now resolves with prompt_id / user_message_id / created_at / state (plus turn_id once launched), mirrored through the klient contract. * refactor(agent-core-v2): slim the promptWithSkills result contract Drop the user_message_id field (it is always the same identity as prompt_id — the route duplicates it) and narrow state to the running/queued/blocked vocabulary, mapped at the engine edge instead of exposing the internal seven-state PromptState on the wire. * fix(kap-server): harden bundled skill submissions against review findings - Validate bundled skill names and types before any media materialization or control override, so a rejected bundle leaves session state untouched (the engine still re-validates authoritatively). - Declare the 40415/40912 outcomes on the submit route so the generated API documentation includes them. - The klient output schema no longer tolerates a missing promptWithSkills result (a transport-level absence now raises instead of resolving undefined), and a failed launch surfaces as an error rather than a successful running result. - Add the changeset for the new public API field. * fix(kap-server): preflight bundled skills before agent materialization and stabilize listed content - Skill preflight now runs on the session's catalog before the main agent is resolved, so a rejected bundle cannot mutate session metadata by registering main (regression test on a cold session without an agent). - The prompts list projection strips the stored skill blocks from a bundled prompt, so GET /prompts returns the same caller-only content as the submit response. * fix(kap-server): reject bundled prompt_id combos at preflight and clean queued staging - The skills + prompt_id incompatibility rejection now runs at the initial bundled preflight, before the main agent is materialized or any override binds (previously a yolo override could bind before the 40001). - Queued bundles no longer skip staging cleanup forever: the discard is deferred to the bundle's prompt.completed / prompt.aborted lifecycle event, mirroring the plain path's launch-raced cleanup. * fix(kap-server): clean queued bundle staging on the steer path too A queued bundle steered into the active turn is consumed at steer time, but the engine publishes prompt.completed/aborted only for the parent — the deferred cleanup never fired and its subscription leaked. The prompt.steered event (matching promptIds) now counts as the child's intake-completion signal. * fix(agent-core-v2): materialize daemon-ref media on the steer and inject paths startNext materializes daemon file references into the session media store before a prompt's turn, but steer() and inject() enqueued the same references without that intake, leaving the staging upload as the only copy — any staging cleanup at steer time would delete the media the turn is about to consume. Both paths now run the same intake before the SteerStepRequest is created, so prompt.steered is a truthful intake-complete signal. * fix(kap-server): defer staging cleanup to turn settlement, never to steer time Prompt-intake materialization is best-effort: when it degrades, the daemon upload is the request-time resolver's fallback source. Discarding staging at prompt.steered could therefore delete the only readable copy before the parent's request ran. Cleanup is now uniformly event-driven — the bundle's own prompt.completed/aborted, or the steer parent's — so the upload always outlives the request it feeds. * fix(kap-server): install settlement tracking before bundled enqueue A hook-blocked bundle completes synchronously inside the submission call, and an exceptionally fast launch can settle just as early — a post-call subscription misses the only settlement event and leaks both the staging blob and the listener. The tracker now subscribes before enqueueing, buffers lifecycle events, and settles against the returned prompt id (or its steer parent's). * fix(kap-server): scope settlement tracking to the owning agent and dispose on rejection - The tracker now subscribes through the agent-scoped IEventBus instead of the App-scoped IEventService: prompt lifecycle events from other sessions never reach it, so a colliding client-chosen prompt id cannot trigger a foreign settlement (and the steer re-target only follows this agent's parent). - A bundled submission that rejects after the tracker was installed now disposes it on the error path instead of leaking a permanent listener. * fix(agent-core-v2): keep steered prompts queued until their media intake finishes Materializing a steered prompt's daemon-ref media awaits a file copy during which the active turn may finish. Records are now spliced out of the queue only after that copy completes, and when the turn is gone by enqueue time they are restored to pending so startNext can launch them as fresh prompts — their handles always launch or settle. * fix(agent-core-v2): revalidate the queue and active turn after steer media intake The daemon-ref copy yields, so settle/abort can consume selected records and the active turn can rotate meanwhile. Only records still pending are steered, and only into the turn that was active at entry; records that vanish from the queue are left to their own launch path, and a missing turn restores them to pending instead of splicing an unrelated tail prompt. The intake/queue-preservation contract is documented in the module header. * fix(agent-core-v2): steer only the surviving records and keep their media truthful - The steered content is rebuilt from the records that are still pending after the media intake, so an aborted or concurrently consumed record's text is never injected (or injected twice) alongside the surviving handles. - The enqueue is wrapped so an activeTurnOnly rejection restores the records to pending (the loop throws instead of resolving a missing turn, which made the previous rollback unreachable). - The merged origin now carries the union of every record's bundled skillActivations, and prompt.steered publishes the caller-only content, so the skill instructions reach the model with their metadata intact while the event projection stops leaking internal skill markdown. * fix(agent-core-v2): harden steer rollback and register bundled prompt ids * fix(agent-core-v2): strip bundled blocks from prompt.queued and reject partial steers * fix(kap-server): update session metadata for bundled prompts routed to subagents * fix(agent-core-v2): restart queue after raced steer rollback and prefix skill blocks in merged steer * fix(agent-core-v2): block queue advancement during steer admission * chore: drop the changeset for server-only protocol plumbing	2026-08-18 14:57:13 +08:00
Haozhe	2265305e81	refactor(agent-core-v2): replace defineOp/Model with Event2 dispatch and replayable states (#2909) ... * refactor(agent-core-v2): replace defineOp/Model with Event2 dispatch and replayable states - replace defineOp/Op/OpDescriptor/toEvent and defineModel/defineCheckpointedModel with Event2 subclasses: durable classes declare static durable + schema, serialize() keeps the wire record shape byte-frozen, transient classes stay off the journal - define states via defineState(...).replayable(...).on(Event2, fold): immer produceWithPatches folds with atomic prepare/commit, .undoable() trait drives prompt-submit checkpoints and context.undo, ephemeral kv keys keep imperative set - degrade IWireService to a journal adapter; the agent event dispatcher owns the pipeline (fold -> set -> appendRecord -> publish) and silent restore - align downstream event surfaces: kap-server WS envelope timestamp from event.time, klient event schemas gain time, node-sdk/acp-server/print wiring updated - rewrite gen-wire-manifest/gen-state-manifest for the unified registry and replace the op-uniqueness lint with event-uniqueness * fix(ci): repair Event2 prompt and media projections - restore prompt admission and session media materialization - align transcript, WS, SDK, and replayable media state projections - update affected tests and generated state manifest * fix(ci): update prompt event and projection expectations - update snapshots for the durable prompt.accepted event - normalize prompt.steered media in transcript projections	2026-08-17 17:38:50 +08:00
7Sageer	d833a1a893	feat: engine-native image references via kimi-file:// media resolver (#2593) ... * feat: engine-native image references via kimi-file:// media resolver * fix(agent-core-v2): regenerate state manifest for media resolver rename * feat(agent-core-v2): add audio MediaKind and tag/ref fold helpers to media ref contract * fix(agent-core-v2): synthesize image path tag when degrading bare file references * fix(agent-core-v2): scrub dangling alias re-exports in contract type generator * feat(transcript): project paired media tag+ref as single attachments in read models * fix(kimi-code): fall back to inline image when cache write fails after upload * fix(agent-core-v2): pair media path tags with refs by adjacency and path, keep unpaired tags * fix(kap-server): fold media tag+ref pairs out of prompt snapshot projection * fix(kap-server): list attachment-only prompts as empty user messages * fix(kap-server): keep live attachment ids across transcript overlay and heal * fix(kap-server): keep promptAttachments off the legacy session event wire * fix(kap-server): inherit the backfilled turn header on mid-turn terminal projection A projector that attached after turn.started built the terminal turn.upsert with an empty header, and the whole-header replace downstream wiped the backfilled origin / prompt / attachmentIds — only the debounced best-effort heal could restore them. Fall back to the producer store's seeded header (via a new optional ProjectorLookups.turn) when currentTurn misses, and cover the mid-turn attach path with a service-level regression test. * refactor(agent-core-v2): move media ref contract out of kosong into agent/media The kimi-file:// daemon reference grammar, media path tags, and the tag/ref fold are engine-internal conventions, not provider-wire contract; keep src/kosong untouched. Root exports and SDK re-exports are unchanged. * feat(agent-core-v2): materialize prompt media into the session media dir Pasted and uploaded media now materialize under the session's own media/ dir instead of the shared cache, so the copies follow the session's lifecycle: fork carries them along, session deletion cleans them up. A new Session-scope ISessionMediaStore owns the dir: atomic tmp+rename materialization with a unified extension policy, and canonical-vs-hint display-path resolution. The persisted ?path= is a write-time snapshot — readers prefer the session-canonical location, so fork and home relocation never hand the model a dead path. Prompt intake normalizes every daemon reference through the single enqueue funnel (REST edge, SDK prompt/steer, gateway), serialized in arrival order to keep the FIFO across the async file I/O. The kap-server edge materializes through the same store with a shared-cache fallback, and the request-time resolver refreshes stale persisted and memoized path tags; a claimed video reference degrades to its tag alone instead of duplicating it. * fix(agent-core-v2): take prompt media intake off the enqueue critical path The record now joins the FIFO synchronously and its daemon-ref intake runs as a per-record promise, awaited by the launch and steer paths before the message is consumed — queue order, list/abort visibility, and prompt submission latency no longer wait on file I/O, and a slow intake no longer head-of-line blocks later prompts. The launching record is tracked so abort and clear stay reachable inside the launch window; startNext re-checks cancellation after every await (intake race, hook, turn admission), a cancelled record is never re-queued, and a compaction requeue waits for onDidFinishCompaction instead of busy-looping the scheduler. * fix(agent-core-v2): record the claiming ref in the media path-tag pairing pairMediaPathTagRefs now exposes claimingRefByTagIndex, and claimingRefIndex reads it instead of recovering the claimer by path equality — which mis-attributed a tag when two different fileIds carried the same path in an interleaved sequence, breaking the pair and leaking the tag as user text. Also covers the memoized-video-tag claimed-drop branch. * fix(transcript): fold upload pairs in user-slash turns and pin pairing parity The cold rebuild's user-slash branch now folds the turn-opening input like any user turn (claimed tag out of the prompt text, one attachment entity), matching the live projection. The ref extraction is consolidated into the contract module (daemonFileRefFromPairingPart, the mirror of the engine's daemonFileRefFromPart) and the mirror carries the new claimingRefByTagIndex map. A new kap-server parity test imports both implementations and asserts identical pairings over shared fixtures, so the engine/mirror pair can no longer drift silently. * fix(kap-server): fold upload media tags out of the search index The global search indexer concatenated every text part of a persisted user message, so the upload pair's <image path> tag made pure-image prompts searchable and wrote the materialization path into the index — breaking the module's documented pure-image invariant and diverging from the live route. textOfContent now folds the pair like every other read model (with a fold-safe coercion for malformed wire parts). Also pins the prompt-media cache-dir fallback with a read-only session media dir test (skipped as root). * feat(node-sdk): re-export the media fold helpers and cover the v1 uploadFile rejection foldMediaPathTagRefs and matchSingleMediaPathTag join the daemon file-reference helper re-exports so hosts can fold the upload tag+ref pair without importing agent-core-v2; the v1 harness's uploadFile not_implemented rejection is pinned by a test. * fix(kimi-code): fold upload pairs in replay/export and keep media tags atomic in steer input Resumed-session replay rendered the upload pair raw — the <image path> tag as user text and the kimi-file:// url as an XML-ish reference — and the markdown export leaked the tag into both the turn body and the overview topic. contentPartsToText and the exporter now fold the pair, and daemon references render as a bare [image]/[video] placeholder. combineSteerInput moves to tui/utils/steer-input and no longer merges a standalone media tag into adjacent text, which would have broken the engine-side pairing for steered image messages. * fix(kimi-code): drop the steer separator before a leading media tag A queued pure-image message opens with a standalone `<media path>` tag, which combineSteerInput keeps atomic. With the previous item ending in a media part, the '\n\n' separator landed as a stranded whitespace-only text part between the media part and the tag, normalizePromptInput rejected the steer, and the already-cleared queue lost the messages. Treat a leading standalone tag as media so the separator is dropped there. * fix: clean staged media lifecycle * refactor(agent-core-v2): narrow the mediaRef root exports and drop a deprecated alias * fix: keep staged media alive through turn * fix(agent-core-v2): reject non-upload ids at the session media store A daemon reference's fileId becomes a storage key in the session media store, but only the file domain validated the id shape — a crafted kimi-file://<id> reaching the request-time resolver's canonical-read fallback could traverse out of the session media dir. Share the file domain's id regex and guard every store entry point: reads miss, materialize declines, and the display path falls back to the hint. * fix(kap-server): project steered prompt content without leaking daemon refs prompt.steered published the raw engine content parts — kimi-file:// refs carrying the absolute materialization path plus the paired <media path> tag — to both the legacy session_event wire (whose schema declares the protocol content shape) and the transcript prompt entity. Route both through one shared prompt-content projection: the upload pair folds into a single {kind:'file'} part, matching the REST prompt list and the no-path-leak rule every sibling surface already follows. * refactor: align daemon-ref naming and drop a duplicate re-export The deprecated videoResolverService alias also re-exported mediaResolvedKey, which made the package root's star exports ambiguous and silently dropped the name. The new transcript contract mirror now uses the canonical daemon-ref vocabulary instead of the deprecated kimi-file spelling. * test(agent-core-v2): pin image abort rethrow, video canonical read-through, release-once Mirror the video abort contract on the new image path (an aborted read cancels the request instead of degrading to a tag), cover the video fallback that uploads the session-canonical bytes after the transient upload is released, and assert the staged-upload release fires exactly once on the intake success path. * fix(kimi-code): bind goal-steer staging leases to the running turn sendMessageInternal read the turn context only after beginSessionRequest had cleared it, so a steer buffered into a running goal turn never got its staging lease bound — the staged daemon upload and cache copies lived until session close instead of being released at the consuming turn's end. Capture the live turn id before the reset (only while a turn is actually streaming; the id outlives its turn otherwise). Also move the staging-lease state machine off the KimiTUI coordinator into a self-contained StagingLeaseTracker with injected effects, drop the duplicate media-tag builder in image-placeholder in favor of the SDK helper, and fix the paste-in-flight comment to match the gate's real granularity. * fix(kap-server): project prompt.queued content without leaking daemon refs The broadcaster projected prompt.steered and stripped turn.started attachments but forwarded prompt.queued raw, leaking kimi-file:// URLs and absolute materialization paths to every subscribed WS connection and the journal. Fold the tag+ref pair into a {kind:'file'} part, same as steered. * fix: keep compressed uploads retrievable and close the steer abort window Two review fixes around prompt media intake: - The compressed re-save was released right after intake (and carried a 1h expiry) while every client read model projects its file id, leaving historical compressed images unfetchable. Keep the re-save as an ordinary upload; roll it back only when preparation or submission fails before the engine takes the prompt. The engine's PromptInput.release hook loses its only producer and is removed. - A prompt aborted while its steer awaited the loop's step assignment was flipped back to 'steered' and its content could still materialize into a later turn. Re-check the reservations after the assignment await and abort the undispatched request when the check fails. * perf(agent-core-v2): memoize inlined image parts across request steps A successful image inline depends only on the immutable upload bytes, so it is memoized per file id (size-bounded) in media.resolved and reused across steps, retries, and media-recovery reprojections instead of re-reading and re-encoding on every request. Degrade forms are never memoized since they depend on the message's tag pairing. Also make the never-empty message placeholder kind-aware (video vs image). * refactor: author media tag+ref pairs in the engine prompt intake Edges (TUI, kap-server REST) now submit bare kimi-file references and the engine intake materializes the bytes, synthesizes the paired media path tag, and falls back to the shared cache dir when the session store is unavailable, replacing per-edge pair construction and duplicate materialization copies. Thread the prompt id from submission through to turn.started (REST prompt_id, WS event, SDK prompt option) so the TUI binds staged-media leases to turns exactly; the origin heuristic stays as fallback and ambiguous claims now surface a staging_lease_invariant telemetry warning. Also lands the pending resendable-extraction fix for cache-hint resubmits after a session switch. * fix: decouple media persistence from prompt intake * refactor(agent-core-v2): project the turn prompt in a single fold pass * test: slim redundant media-ref coverage across layers Fold duplicate pinning of the same media tag+ref rules into shared helpers and it.each tables, and drop assertions that restate behavior already covered at another layer: - drop the kimiFileUrl alias describe (mediaRef.test.ts covers the aliased functions with more cases) - drop pairMediaPathTagRefs describe in favor of the parity fixtures - merge the identical prompt.steered/prompt.queued broadcast tests - parameterize the resolver degradation matrix and prompt intake fixtures (enqueueMedia/gatedImage/expectMediaPair helpers) - drop REST-level context-memory pairing assertions (engine-level intake tests pin the same shapes); keep the caption->system-reminder assertion, the only cover of extractCompressionCaptions - drop the turn-finish-during-intake steer-cancel vector and the switch-session release driver test (unit-level lease tests remain) Net -762 lines; 645 tests green across agent-core-v2, kap-server, transcript, node-sdk, klient, and the TUI. * chore: fix oxlint warnings introduced by image-file-ref changes * fix: harden image file reference lifecycle * fix: close image reference lifecycle gaps * fix: preserve session media paths on replay * chore: streamline image-file-ref changesets * refactor: make daemon media references self-contained, dropping tag+ref pairing A daemon-ref media part now carries everything a read model needs — the kind from the part type and the materialization path from the reference's `?path=` — so prompt intake no longer authors a paired `<media path>` tag, and the pairing/fold machinery (pairMediaPathTagRefs / foldMediaPathTagRefs and their mirror copy) is deleted across the engine, transcript, kap-server, node-sdk, and the TUI. The request-time resolver synthesizes the degrade tag from the reference path whenever bytes cannot reach the provider. Standalone tags stay user-visible text, and never reach the search index or prompt metadata. * fix: reconcile image file references with main after rebase Main removed the agent RPC aggregation layer (agent/rpc) and moved LifecycleScope to app/scopes. Fold the branch's RPC-side behavior into the new structure: PromptPayload carries promptId/disabledTools, and AgentPromptService.submit admits the client-chosen id through the reservation (duplicate rejects before any session state changes) and applies the denylist through toolPolicy. Regenerate the wire/state manifests. * fix(kimi-code): run paste ingestion in the background, wait bounded at submit The paste callback awaited compression + original persistence + the daemon upload while CustomEditor queued every keystroke, so a slow ingestion stalled all typing. Settle the callback once the placeholder lands and track the rest as ImageAttachment.pending; the send path gives a referenced pending ingestion a bounded wait (2s) so paste-then-Enter still submits the compressed/daemon-ref form, and falls back to the inline form when ingestion has not finished. Media-free submits stay fully synchronous. * fix(protocol): mirror prompt_id in the shared prompt submission schema kap-server's local REST schema accepts a client-chosen prompt_id, but the shared promptSubmissionSchema stripped it as an unknown key, so clients validating through @moonshot-ai/protocol lost the id and the turn.started promptId correlation never matched. * fix(klient): normalize file-store errors to public RPC errors on both transports The fileService save/get wire adaptation ran outside the dispatcher's error normalization, so a stale or expired upload id surfaced as the engine's raw Error2 on the memory transport and as a generic 50001 on ipc. Map file.not_found to the public NOT_FOUND RPCError in the shared dispatcher so both transports reject identically, and pin the parity in the conformance suite. * fix(agent-core-v2): keep launching media prompts visible in the queue snapshot startNext shifts the launching record out of pending before its media intake settles, so list()/GET /prompts reported neither an active nor a queued prompt during the intake window even though the submission was accepted and abortable. Report the launching record as still queued, matching the prompt.queued event already published for it. * fix(node-sdk): strip internal promptAttachments from SDK turn.started events The in-process v2 event mapper forwarded the whole domain event, so SDK session.onEvent consumers saw the transcript-projection-only promptAttachments field that kap-server explicitly strips from the WS wire event. Drop it in the mapper so both consumers share the same turn.started field set. * fix(kimi-code): align staging lease id multiplicity with retain count A lease's flat id list conflated two cases: one submission referencing the same image twice (one retain) and a batched steer merging two queued messages sharing the image (two retains). Occurrence-wise release over-consumed in the first case and batch-wise release would under-consume in the second. Dedupe each extraction's ids at the lease creation sites so list multiplicity always equals the retain count, and release one retain per occurrence. * fix(agent-core-v2): check video_in before honoring memoized video uploads The video memo hit path returned a cached ms:// part before the current model's capability check, so switching to a same-provider model with video_in:false sent a video part the model cannot accept instead of degrading to the path tag. Gate on capability first, mirroring the image strategy. * fix(kimi-code): keep recalled queued media staged instead of releasing it Recalling a queued media prompt into the editor is not a discard, but the recall path released the staged files: image attachments lost their daemon upload (resubmit silently downgraded to inline), and a recalled video's cache copy was deleted even though re-materialization needs a source that may already be gone. Recall now consumes only the retain (the next submit re-retains), retires the cache copy to session lifetime, and rebases the video attachment onto that copy. * fix(agent-core-v2): count launching media prompts in prompt.queued queueLength startNext shifts the record into launchingItem before publishQueued computes the count, so a media prompt's prompt.queued reported queueLength 0 even though the prompt is accepted, abortable, and listed as queued. Compute the count from the same snapshot list() exposes. * refactor(agent-core-v2): drop the session media shared-cache fallback Intake keeps the upload-backed reference when the canonical write fails instead of double-writing into an unowned global cache scope; the session media store's reads collapse to the canonical scope, and non-filesystem deployments no longer write every media blob twice. * refactor(agent-core-v2): stop persisting materialization paths in daemon file references The kimi-file:// reference persisted in context memory bundled a durable identity (fileId) with a perishable machine-local absolute path (?path=), which forked sessions and home relocations would stale. The reference now carries only the file id; the display path is derived from the session media store by file id at read time. Parsers tolerate and strip the legacy ?path= query so old records keep resolving. * fix(agent-core-v2): skip atomic-write temp siblings in session media by-id resolution The fs backend stages atomic writes at <key>.tmp.<pid>.<hex> next to the target key, and the media store's prefix-listing predicate matched them, so a lookup racing an unfinished materialize could return the partial copy as the canonical file. * fix(kimi-code): close the staging-lease gap between extraction and dispatch Create the staging lease right after extraction so every pre-dispatch exit releases through the tracker: validation/session failures release it, queueing defers it to the queue item's raw ids/paths, and the cache-hint stash takes over ownership. A forgotten exit now degrades to an unclaimed lease swept at session close instead of a permanently retained upload. The cache-hint restore exits (dismiss, chained restore, session switch during fetch, failed compact/new-session) previously returned only the text to the editor, leaking the extraction's retains and staged cache copies. They now go through queue-recall semantics: retains are consumed, staged copies retire, and recalled videos rebase onto them. * fix(agent-core-v2): bound the inline image memo with a private byte-budgeted LRU A memoized inline image part pins a multi-MB base64 string, and the agent state registry's snapshot/inspect path serializes every registered state in full — so the memo no longer lives in agentState. It is now a private per-file-id LRU with the existing 8MB per-entry cap plus a 64MB total budget; eviction simply re-reads the bytes on the next request. The video memo stays in agentState. * fix(kap-server): fall back to the staged upload on the session media route Prompt intake materializes bytes into the session media store asynchronously and best-effort, but a session_media ref is projected to clients as soon as the prompt is queued — so the download route could 404 during the intake window, and forever after an intake failure. The route now reads the canonical session store first and falls back to the App-scope staged upload, adapting it to the same served shape; only a double miss is a 404. The header note also records that resolving the store resumes cold sessions, an accepted short-term semantic with a TODO for a cold-read channel.	2026-08-17 13:11:28 +08:00
Luyu Cheng	61591bce09	feat(agent-core-v2): bundle multiple skill activations into one prompt submission (#2934) ... * feat(agent-core-v2): support grouped multi-skill prompt submissions Add IAgentSkillService.promptWithSkills: one or more skill activations are validated up front (an unknown or empty submission rejects with no side effects), recorded with a shared submissionId, and enqueued ahead of the prompt through the prompt queue's messagesBefore support, so the whole group materializes atomically as a single turn. Undo cuts, the transcript projection, and the undo precheck treat the group as one unit (stopping at the next anchor even when submission ids collide); hook-result messages are skipped like injections during those walks. Submit hooks run against every message of the group, and user-slash skill activations count as user-submitted content for the UserPromptSubmit hook's origin filter. Surface it through the contract layers: protocol gains submissionId on the user / skill_activation origins and on the skill.activated event (kap-server zod mirrored), klient exposes agentSkillContract.promptWithSkills with parity assertions, and the SDK grows session.promptWithSkills — implemented on the v2 engine and rejecting loudly on the deprecated v1 engine, which is otherwise untouched. * fix(agent-core-v2): reject empty skill lists in grouped prompt submissions - Validate that promptWithSkills receives at least one skill, enforced in the engine and as a non-empty constraint in the klient wire schema. - Restore the released versions and changelog sections for agent-core-v2, klient, and node-sdk that the branch cut had reverted. - Move statement-level narration into the owning file headers per the package comment conventions. - Align the hook-result undo tests with the reachable record ordering (hook results are recorded before the group materializes). * refactor(agent-core-v2): bundle grouped skill activations into the prompt message Replace the submissionId-correlated message group with a single bundled user message: the rendered skill blocks precede the caller's parts in the content, and every activation's metadata rides the prompt origin's new skillActivations field. The bundle is one anchor by construction, so undo needs no group-cutting logic and the messagesBefore prompt seam disappears; the submit hook fires once per submission. skill.activated still fires per skill (transient ops, live-only); resume rebuilds the per-skill view from the prompt origin. Contract chain (protocol, kap-server, klient, node-sdk) drops submissionId accordingly. * fix(agent-core-v2): keep bundled skill blocks out of prompt-facing projections - The transcript cold rebuild expands a bundled prompt's origin skillActivations back into per-skill markers (the live path already projects them from skill.activated events). - turn.started.prompt, the session title excerpt source, and the fork lastPrompt now derive from the caller's own parts, excluding the rendered skill blocks the engine prepends to the bundled content. - Drop the redundant undefined unions from the new origin fields. - Move the activateSkill test narration into the file header.	2026-08-17 00:09:18 +08:00
Haozhe	84da6629b1	refactor(agent-core-v2): decouple workspace from session DI via runtime binding (#2961) ... * refactor(agent-core-v2): decouple workspace from session DI via runtime binding * fix(agent-core-v2): unblock session external hooks and scope workspaceMcp seeds - externalHooksService: inject App-level ISessionManager instead of the unregistered ISessionLifecycleService so SessionStart/SessionEnd hooks actually activate in production; keep sessionId matching and tolerate absent lifecycle events - workspaceMcpService: ignore onWillCreateSession events whose session belongs to another workspace, preventing cross-workspace ISessionMcpHandle seed overrides - update externalHooks integration tests, agent harness, and workspaceMcp tests; add reloadSources coverage in skillCatalog tests * fix(agent-core-v2): honor the bound runtime in prompt context, swarm spawn, and ACP sessions - map system-prompt cwd, directory listing, and additional dirs through RuntimeWorkspaceView, and skip the listing when the bound runtime has no fs capability - pass the caller agent's runtime binding to AgentSwarm child creation and prompt-prefix execution instead of hardcoding local - expose the ACP client filesystem through the ACP session runtime and build its shell/path environment from the probed host instead of hardcoded Linux - dispatch klient facade createChild to sessionManager.createChild so child sessions keep their parent markers * fix(agent-core-v2): resolve routed fs and tool paths with runtime path semantics - WorkspaceFsService resolves via the bound runtime's RuntimePath (extended with basename/dirname) instead of node:path, so mapped roots such as C:\\repo stay runtime-local. - Read/Write/Glob/Grep pass skill roots through mapRoots via RuntimeWorkspaceView input, matching Edit. - acp-server unbinds session runtimes on session/close, not only on delete. - apps/kimi-code drops the /runtime slash command; SDK runtime methods stay. * fix(agent-core-v2): retire idle session controllers, untrack disposed runtime resources, and rebuild fs watches on generation replace * fix(agent-core-v2): resolve oxlint errors in runtime lifecycle fixes * fix(kap-server): untrack download stream from runtime generation on completion * fix(kap-server): drop meaningless void operator on tracked dispose	2026-08-16 20:24:12 +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
Grapedge	7475c2e2e3	feat(vscode): switch the extension to the v2 engine with a rollback switch (#2916) ... The extension now runs on the agent-core-v2 engine by default. The interface, sessions, and workflows do not change. Two rollback paths exist, and one function makes the decision (config/vscode-settings.ts): - the kimi.useAgentCoreV1 setting (temporary; a window reload applies the change); - the KIMI_CODE_LEGACY_FLAG environment variable, which wins over the setting and has the same semantics as in the CLI. An engine startup failure shows an explicit error that names the rollback setting. There is no silent fallback. CI runs the extension test suite on both engines: the sharded run covers the default v2 engine, and a new test-vscode-legacy job reruns the suite with KIMI_CODE_LEGACY_FLAG=1. To keep the v2 path identical to v1 for every method the extension uses, this change also completes the v2-backed SDK client and the v2 engine: - Implement session deletion in the v2 SDK client. - Implement fork truncation at a turn index in the v2 engine, with the same rules as v1, and reject a fork while the source session has an active turn. - Stop the session-level /init run when the turn is cancelled, as v1 does. - Read session metadata without the archived field as not-archived, so sessions written by the v1 engine open correctly. The SDK parity suite now covers session deletion, cancel, and fork truncation. The known-difference list for the methods the extension uses is empty.	2026-08-14 17:22:10 +08:00
qer	741708f948	feat(kap-server): add plugin marketplace and capability REST routes (#2868) ... * feat(agent-core-v2): surface a machine-key note from capability installs CapabilityEntry.install now resolves an optional note exposed through CapabilityInstallProgress.note (wire-visible). The webbridge entry returns 'user-skill-migrated' when it migrates a pre-existing standalone skill copy onto the plugin-managed one — clients can localize the migration instead of the skill silently disappearing from the user's directory. * feat(kap-server): add plugin management and capability REST routes Expose the App-scope plugin and capability services over the wire so non-CLI hosts (desktop, web) can manage plugins and built-in capabilities end to end: - GET /api/v1/plugins, POST /api/v1/plugins {source}, POST /api/v1/plugins/{id}:{enable,disable,remove} - GET /api/v1/plugins/marketplace — catalog (pluginMarketplaceUrl server option / KIMI_CODE_PLUGIN_MARKETPLACE_URL env / production default) merged on demand with live install state; updateAvailable only on strict semver catalog > installed (no semver dependency) - GET /api/v1/capabilities, GET /api/v1/capabilities/{id}, POST /api/v1/capabilities/{id}:install with client-polled progress - New wire codes 40418 capability.not_found, 40419 plugin.not_found, 40923 capability.install_in_progress, 40924 capability.unsupported Mutations flow through IPluginService, so they serialize with other install paths and fire onDidReload (session skill catalogs and the capability shelf-install hook converge). * fix(kap-server): map plugin input errors to 4xx and correct the unsupported test code - mapPluginError now translates the domain's validation.failed (40001) and fs.path_not_found (40409) instead of collapsing client-fixable input mistakes (relative source, nonexistent local path) into a 50001 internal error - the non-macOS capability install test expected 40923, which this branch assigns to capability.install_in_progress; the unsupported code is 40924 (macOS runners skip the case, which is why it only fails on Linux/Windows CI) * fix(kap-server): resolve catalog-relative marketplace sources and widen the unsupported-test skip - The production CDN catalog carries sources relative to the catalog URL (./official/*.zip); clients handing them back to POST /plugins would hit the local-path normalizer's 40001. Resolve entry sources against the configured catalog URL so every returned source is directly installable. - The 40924 install-rejection test only skipped macOS, but kimi-cu is also supported on Windows x64 — running it there would start the real installer. Skip on every supported platform. * fix(kap-server): accept the legacy url/downloadUrl marketplace source aliases Custom catalogs that the CLI already accepts can carry an entry's source under url or downloadUrl instead of source; the route's strict schema rejected the whole catalog with 50001. Normalize the aliases before validation (same precedence as the CLI parser) so those catalogs keep working through /api/v1/plugins/marketplace. * fix(kap-server): support local marketplace catalogs and drop conditional spreads - KIMI_CODE_PLUGIN_MARKETPLACE_URL accepts a plain path or file:// catalog in the CLI loader; the route only fetched over HTTP, so local catalogs 50001'd for desktop/web hosts. Read local catalogs from disk and resolve their relative sources against the catalog's directory. - Replace the marketplace mapping's conditional spreads with direct possibly-undefined properties per the repo rule. * fix: surface capability install notes through klient and convert file:// entry sources - The klient capabilities contract omitted install.note, so zod parsing stripped it and facade callers (node-sdk, TUI) never saw 'user-skill-migrated'. Add the field and pin it in the facade test fixture. - A marketplace entry source given as a file:// URL fell through to the relative-branch and came back as a garbage path; convert with fileURLToPath so the advertised source stays installable. * test(kap-server): keep the new route tests portable to Windows x64 - The capabilities list assertion treated every non-macOS host as unsupported, but kimi-cu is supported on Windows x64 — derive the expectation from the same platform predicate. - file:///abs/... is not a valid absolute file URL on Windows (no drive root); build the fixture with pathToFileURL from a temp path instead. * refactor: align the capability note and test helper with repo conventions - agent-core-v2 keeps explanatory docs in the top-of-file block only; the note contract already lives in the capability types header, so drop the two member-level doc blocks. - The plugins route test helper sets the optional fetch body directly instead of via a conditional spread. * fix(kap-server): expand ~ in local marketplace catalog paths The CLI loader expands ~/ against the home directory; the route read the path literally, so KIMI_CODE_PLUGIN_MARKETPLACE_URL=~/catalog.json 50001'd for desktop/web hosts while working in the CLI. Share one localCatalogPath helper (file:// conversion + tilde expansion) between the catalog read and the relative-source resolver. * fix(kap-server): expand home-relative marketplace entry sources A catalog entry with source '~/...' fell through to the catalog-relative branch and came back as <catalog-dir>/~/... — unresolvable by POST /plugins. Expand ~ via the shared helper before the absolute/relative decision. * fix(kap-server): match CLI field semantics for source aliases and stub the Windows home - A blank or non-string source no longer shadows the url/downloadUrl aliases; the first valid (non-blank, trimmed) of source/url/downloadUrl wins, mirroring the CLI parser's stringField. - The tilde test also stubs USERPROFILE so os.homedir() resolves to the fixture home on Windows runners. * fix(kap-server): read a blank marketplace tier as missing The CLI parser trims tier and treats a blank as absent (third-party); the route's enum rejected the whole catalog with 50001. Normalize the tier alongside the source aliases in the same preprocess. * fix(kap-server): derive marketplace versions from GitHub release sources Entries that omit version but encode it in a GitHub release/tag (or tree/commit) source never surfaced updateAvailable. Derive the version from the resolved source — same URL shapes as the CLI parser, validated with the route's strict x.y.z rule (no semver dependency). * fix(kap-server): fail catalog validation on a source with no usable value A whitespace-only source with no valid alias passed z.string().min(1) untrimmed and resolved against the catalog URL into nonsense. Drop the key during normalization so the schema reports the entry as missing its source (same outcome as the CLI's 'must define source'). * fix(kap-server): resolve latest versions for bare GitHub marketplace entries A catalog row whose source is a bare GitHub repo (the production curated rows are shaped this way) kept version undefined, so updateAvailable never fired for exactly the entries most likely to update. Resolve the latest release tag through the /releases/latest redirect — the UI route, not the rate-limited API — same as the CLI, degrading to no version on any failure. * docs(kap-server): note the marketplace version resolution in the plugins route header * feat(kap-server): mark capability wiring rows in the marketplace response A client following only /plugins/marketplace + POST /plugins would install a capability's wiring plugin without its binary runtime, with no wire-level way to tell. Entries whose id matches a capability's wiring plugin now carry capabilityId, so clients route them through /capabilities/{id}:install — the client-side routing pattern the CLI established (the upstream design that replaced the server-side hook). * fix(kap-server): fall back to the source-checkout catalog for the default location When the marketplace location is the built-in default (no server option or env override) and the fetch fails, read the repo checkout's own plugins/marketplace.json — the CLI loader's behavior for offline source-checkout dev. An explicitly configured catalog still fails hard with 50001. Bundled installs have no checkout file, so the fallback simply never fires there. * fix(kap-server): resolve fallback catalog sources against the fallback file readMarketplaceCatalog returned only the JSON, so entries from the source-checkout fallback resolved their relative sources against the (unreachable) CDN URL — coming back as unusable https paths instead of local directories. The reader now returns the location actually read, and source resolution uses it. * fix(kap-server): honor the CLI's marketplace metadata aliases Custom catalogs using name / shortDescription / websiteURL (accepted by the CLI parser) lost those fields to schema stripping, falling back to the entry id. Normalize the aliases in the same preprocess as the source/tier normalization. * fix(kap-server): filter marketplace keywords instead of rejecting the catalog A keywords array with non-string or blank members failed the strict schema and took the whole catalog down with 50001. Normalize to the CLI parser's semantics: non-array reads as missing, arrays keep trimmed non-blank strings only. * fix(kap-server): treat a blank or non-string marketplace version as missing The CLI parser reads version through its lenient stringField and falls through to source-derived versions; the route's schema rejected a numeric version with 50001 for the whole catalog. Normalize version in the preprocess like the other fields — the gh-plugin fixture now carries a numeric version and still derives 2.0.0 from its tag source. * fix(kap-server): trim marketplace entry ids before the install-state join A whitespace-padded id survived validation raw and never matched the installed records (updateAvailable silently lost). Normalize the id in the preprocess — trimmed, blank rejected — matching the CLI's requiredString. * fix(kap-server): gate capability markers to the default catalog A custom catalog (env or server option) may legitimately carry a same-id fork of a capability's wiring plugin; marking it capabilityId would route users to the built-in install. Apply the marker only for the default catalog (including the source-checkout fallback), matching the CLI injecting built-in rows only for the default catalog. * fix(kap-server): compare marketplace versions with real semver The hand-rolled strict x.y.z check rejected valid semver the CLI accepts (v-prefixed, prerelease tags), so updateAvailable diverged between CLI and wire clients. Take the semver package (already in the monorepo via the CLI) for the update check and the two source-derived version validators. * fix(kap-server): validate marketplace entry types and count the dev server as default - Custom catalog rows with an unsupported type (e.g. integration) were stripped by the schema and advertised as installable plugins; the CLI rejects the catalog outright. Model the same plugin/managed/guide vocabulary. - scripts/dev.mjs marks its repo-owned catalog with KIMI_CODE_PLUGIN_MARKETPLACE_FROM_DEV_SERVER=1 — honor the flag in the isDefault check so capability markers and the checkout fallback behave exactly like the CLI under the dev marketplace. * fix(kap-server): join capability rows through their platform wiring plugin id kimi-cu installs its wiring plugin as kimi-cu-win on Windows x64, so a catalog row keyed kimi-cu never matched the installed record there (no installed state, no updateAvailable). The row mapping now knows each capability's wiring plugin ids and joins through them. * fix(kap-server): map plugin load failures to 40001 An install source pointing at a directory/zip with a missing or invalid manifest throws plugin.load_failed — a client-fixable input error that fell through to 50001. Map it to validation.failed alongside the other input mistakes. * build(kap-server): align @types/semver with the workspace version sherif rejects multiple workspace versions of one dependency; the CLI pins @types/semver at ^7.7.0. * refactor(agent-core-v2): share the plugin marketplace client/parser across hosts The kap-server marketplace route grew its own copy of the CLI's catalog loading/parsing logic (lenient aliases, blank-means-missing fields, source resolution, GitHub version derivation) — two implementations of a public, hand-writable format would drift on every catalog change. Move the read/parse/version machinery into the plugin domain as app/plugin/marketplace (pure functions, no DI): the CLI keeps a thin wrapper owning configured-source resolution and its checkout fallback, and the route keeps only the wire concerns (install-state merge, capabilityId markers, error envelopes). plugins.ts drops ~230 lines of duplicated machinery. One deliberate behavior fix rides along: tilde entry sources now expand against the home directory at parse time (the CLI previously passed them through literally, failing later at install validation). * docs(agent-core-v2): fold the marketplace module's member docs into the file header The package convention keeps explanatory comments in the top-of-file block only; the moved parser carried several function/member-level JSDoc blocks from its CLI home. The header now carries the format contract, leniency rules, source/version resolution order, built-in masking semantics, and the fallback gating rule. * docs(agent-core-v2): drop the remaining statement comments in the marketplace module The header carries the rationale (update semantics, GitHub ref shapes, the releases/latest choice); the convention allows nothing beside statements. * fix(kimi-code): import the shared marketplace module by its deep path constant/app.ts is evaluated on every CLI invocation; re-exporting from the agent-core-v2 root would pull the whole engine module graph into startup. The package's wildcard subpath export lets both CLI files take only the pure marketplace module (node builtins + semver). * feat(kap-server): fan plugin and capability lifecycle out as global WS events Clients currently poll the plugins/capabilities REST surfaces and can hold stale rows while another client mutates the set. Publish two global events instead: - event.plugin.changed — fired off IPluginService.onDidReload, so any install/enable/disable/remove from any client reaches every host - event.capability.changed — every capability install progress transition (CapabilityService gains onDidChangeInstall), so rows update live and settle is observable without polling Both ride the existing global fan-out (no subscription needed) and are documented in the wire schema registry. * fix: register the lifecycle events in the wire union and tidy the contract header - event.plugin.changed / event.capability.changed were declared but not part of agentEventSchema, leaving the wire catalog incomplete. - The onDidChangeInstall member doc moves into the capability contract file header (package comment convention). * feat(protocol): mirror the plugin/capability lifecycle events in the shared WS schema Clients and e2e harnesses validating server frames against @moonshot-ai/protocol would reject event.plugin.changed / event.capability.changed. Register both in the shared catalog (TS interfaces, zod schemas, and both unions), matching the model_catalog.changed precedent for global events. * fix(kap-server): prefer the platform wiring plugin when joining capability rows A stale same-id record (e.g. a raw kimi-cu plugin next to the real kimi-cu-win wiring on Windows x64) previously won the join, showing the wrong installed state and update availability. Capability rows now join through the wiring plugin ids in platform preference order before falling back to the catalog id. * fix(kap-server): put the github metadata of plugin summaries on the wire schema GitHub-sourced plugin summaries carry github {owner, repo, ref, installedSha} from the domain; the route serializes raw domain objects, so the field reached clients undocumented. Declare it in pluginSummarySchema so the OpenAPI surface matches reality. * test(node-sdk): cover the new lifecycle events in the exhaustive switch The event-type exhaustiveness test broke when the shared protocol union gained event.plugin.changed / event.capability.changed. * fix(kap-server): mark capability progress events volatile Per-chunk download progress transitions ride the same fan-out as durable frames and were being persisted to the __global__ journal — hundreds of stale frames per install. event.capability.changed is live-only state, so it joins the volatile list alongside event.di.unit_changed; the settle frame stays recoverable via a direct capability read. event.plugin.changed remains durable (rare, and a reconnecting client should replay it). * feat(kap-server): inject built-in capability rows into the default catalog response The checked-in production catalog carries kimi-webbridge but not kimi-cu — the CLI injects built-in rows client-side, so wire clients never saw Kimi Computer Use in /plugins/marketplace. For the default catalog the route now appends supported capabilities the catalog lacks (static descriptors via ICapabilityService.describeCapabilities — no detector probes), marked with capabilityId and a capability:<id> sentinel source so installs still route through the capability surface. * fix(kap-server): run injected capability rows through the install-state join The injected kimi-cu row hardcoded installed: undefined, so an already-installed capability still read as installable. Injection now happens before projection, so injected rows get the same backing-plugin join (installed state, update badge, capabilityId marker) as catalog rows. Also moves the describeCapabilities note into the contract header (package comment convention). * test(kap-server): gate the injected-row assertions on platform support kimi-cu injects only where supported (macOS / Windows x64); on Linux CI the row is correctly absent. * fix(protocol): classify capability progress as volatile in the shared catalog kap-server never journals event.capability.changed (it is in the server-local volatile list); shared-protocol clients reading isVolatileEventType would treat per-chunk progress frames as durable and replayable. Mirror the classification. * fix(kap-server): hide capability rows on unsupported platforms Catalog-carried capability rows (kimi-webbridge in the default catalog) were marked with capabilityId regardless of host support — on an unsupported platform clients would route into an impossible capability install. Rows whose capability is unsupported are now excluded from the default-catalog response entirely (the CLI hides its built-in rows the same way).	2026-08-14 15:45:34 +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
Haozhe	23e68eee8b	refactor(agent-core-v2): remove the agent RPC aggregation layer (#2871) ... * refactor(agent-core-v2): remove the agent RPC aggregation layer - delete src/agent/rpc/ (AgentRPCService, IAgentRPCService, core-api, prompt-metadata, types) and sink each method's orchestration into its owning domain service - prompt: new submit/submitSteer composing disabledTools gating, MAIN-only session metadata, and engine-side {turn_id} settlement - skill: activate now returns PromptLaunchResult and writes session metadata internally (MAIN-only, unified across prompt/steer/skill/ pluginCommand); node-sdk and kap-server drop their edge-side writes - pluginCommand: new agent-scope domain owning command activation and the plugin_command.activated domain event - permissionMode/loop/fullCompaction: new setModeAndBroadcast / cancelFromUser / cancel; setMode and loop.cancel stay pure for internal callers - klient: agentRpcContract split into per-domain contracts; facade re-routes to domain channels with its public API unchanged - node-sdk, kap-server, kimi-inspect and the v2 test harness now call domain services directly; ctx.rpc keeps its name as a composed adapter - externally visible: the agentRPCService debug channel is gone and session metadata writes are now MAIN-agent-only (see changeset) * refactor(agent-core-v2): move disabledTools gating out of the prompt domain Prompt should not own session tool policy: submit no longer accepts or applies disabledTools. The klient facade keeps its prompt({ disabledTools }) API and composes it edge-side — applying agentToolPolicyService setSessionDisabledTools before calling agentPromptService.submit, the same way kap-server's prompt route already does. Over klient, a profile-less engine now surfaces the raw profile error instead of request.invalid. Also restores the RPC-removal changeset, which did not make it into the previous commit. * chore(agent-core-v2): drop the RPC-removal changeset * refactor(klient): drop disabledTools from the prompt entry entirely The prompt path no longer carries session tool gating on any surface: the klient facade prompt() loses the disabledTools field and calls agentPromptService.submit directly, and the node-sdk SessionPromptRpcInput stops accepting or forwarding it (v1 always ignored the field). Session tool gating remains available through IAgentToolPolicyService.setSessionDisabledTools, composed at the edge the way kap-server's prompt route does; the klient toolPolicy contract added for facade-side composition is removed as unused.	2026-08-13 10:57:01 +08:00
liruifengv	43c68f58f5	feat(agent-core-v2): keep session updatedAt stable across meta management writes (#2815) ... * feat(agent-core-v2): keep session updatedAt stable across meta management writes Rename, archive/restore, and fork no longer bump a session's updatedAt, so recency-sorted session lists stop reshuffling on management actions: - setTitle/setArchived pass touchUpdatedAt: false; an explicit patch.updatedAt always wins (fork inherits the source's recency, so a fork lands next to the source instead of floating to the top) - new SessionMeta.archivedAt records the archive moment (cleared on restore) and is surfaced through the session index, the v1/v2 session routes (archived_at), and the klient contract, so the archived list keeps an accurate archive time without relying on the updatedAt bump * fix(agent-core-v2): normalize a legacy ISO-string updatedAt when forking a cold session A cold legacy/v1 state.json read from disk can still carry an ISO-string updatedAt; passing it through as the fork's explicit patch.updatedAt would persist a string into the v2 metadata. Normalize with toEpochMs (falling back to now when absent/unparseable). * fix(agent-core-v2): write fork metadata after agent recreation Registering each copied agent during fork is an ordinary metadata write that bumps updatedAt, which overwrote the inherited source recency and still floated normal forks (sessions with agents) to the top. Move the fork's metadata update after the agent recreation loop so the inherited updatedAt is the final write. * fix(agent-core-v2): preserve persisted recency when restoring a cold session Resume creates the main agent for a cold session that has no persisted agents.main entry (e.g. an empty session), and that registration bumps updatedAt — so unarchiving an empty session still floated it to the top. Capture the index summary's updatedAt before resume and re-apply it in the restore write (archived:false, archivedAt cleared, explicit updatedAt wins over the bump). * fix(agent-core-v2): make agent registration non-touching for recency Registering an agent is a structural write, not content activity — but it went through an ordinary metadata update that bumped updatedAt. That reordered recency-sorted listings whenever materialization created an agent: resume of a cold session without a persisted agents.main (so archive-via-resume and restore of empty sessions still floated), and runtime subagent registration mid-turn. registerAgent now passes touchUpdatedAt: false; restore goes back to the plain unarchive write and no longer needs the capture/reapply workaround. * fix(agent-core-v2): duplicate cron tasks only after the fork metadata is durable With the metadata write moved after agent recreation, cron duplication ran before it — a rejected metadata update left cloned cron records pointing at a fork whose directory the catch block just removed. Keep cron duplication after the durable metadata write. * style(agent-core-v2): fold new invariants into module headers The package convention keeps comments in the top-of-file block only — move the touchUpdatedAt precedence, non-touching registration, and fork ordering notes out of statement-level positions into the respective module headers. * chore: scope the changeset to agent-core-v2	2026-08-12 13:40:26 +08:00
qer	335588e259	feat(agent-core-v2): persist the last turn outcome into session metadata for cold listings (#2666) ... * feat(agent-core-v2): persist the last turn outcome into session metadata for cold listings A cold session (no live handle) reported no lastTurnReason, so after a server restart the session list could not mark a session whose last turn failed until it was opened and resumed. A new Session-scope SessionOutcomeRecorder subscribes to the activity aggregate's turn_ended changes and persists the outcome (completed/failed) into the session metadata document; the summary pipeline (mirror + cold reader) carries it as SessionSummary .lastTurnReason, and toWireSession falls back to it when no live fact exists. 'cancelled' is deliberately not persisted: it is also what an in-flight turn ends with during scope disposal, and writing there races the host's home-dir teardown. Verified end to end with an isolated home and a dead provider: a turn fails, the server restarts, and GET /sessions reports last_turn_reason=failed without opening the session. * fix(klient): carry lastTurnReason/lastTurnOutcome in the validated contracts Review follow-up: zod strips unknown keys on parse, so the new outcome fields never reached klient callers; add them to the session summary and metadata/patch/key schemas (contract parity test covers the engine mirror). * fix(agent-core-v2): persist user-cancelled outcomes, never teardown aborts Review follow-up: skipping every 'cancelled' left a stale earlier outcome in the metadata (e.g. a prior failed reported for a session whose latest turn was stopped by the user). The recorder now subscribes to the main agent's turn.ended facts directly and keys on interruptReason: user_cancelled is persisted like any other terminal state, while programmatic aborts — including the cancel every in-flight turn suffers during scope disposal — are never written, so no metadata write races the host's home-dir teardown. * fix(kap-server): only fall back to the persisted outcome for cold sessions Review follow-up: a warm session that just started a new turn clears its live lastTurn, and the unconditional ?? fallback would then report the previous turn's persisted outcome for a turn that is still running. SessionFacts now reports whether a live handle exists, and the wire projection only reads the persisted value when the session is cold. * docs(agent-core-v2): keep the outcome-recorder header at role level * fix(agent-core-v2): settle turn outcomes on turn start and drain metadata writes on close Review follow-ups: - a new main turn now clears the persisted outcome (turn.started), so a process that dies mid-retry no longer reports the previous turn's terminal state for a turn that never ended - the dedupe marker only advances after a successful write, so a failed persist no longer suppresses the next identical outcome - session metadata writes are tracked in a module-level pending set with drainSessionMetadataWrites(), awaited by kap-server close alongside the mirror/query-store drains — an event-driven write (e.g. the outcome recorder) can no longer land in a session dir while the host removes it * fix(agent-core-v2): track the metadata dispose flag locally Disposable exposes no public isDisposed accessor; keep a class-local flag set in the dispose override. * fix(kap-server): drain session metadata writes before the mirror and disposal A write still in flight when close() begins must settle before the mirror flushes its summary into the read model and before scope disposal marks the service disposed — not after. * fix(agent-core-v2): reattach the recorder when the main agent is recreated Review follow-up: a failed bootstrap still fires onDidCreate before the handle is dropped; the subscription then pointed at a dead bus and the guard blocked any later reattach. Track onDidDispose and reset so the next main creation attaches cleanly. * test(agent-core-v2): resolve the recorder through the scoped DI harness Review follow-up: construct SessionOutcomeRecorder via registerScopedService + a Session-scope test host (stubbed lifecycle/metadata), so the test covers the production registration path; add the durable-value adoption case. * fix(agent-core-v2): unbreak CI — iterable Promise.all and the debug channel surface - Promise.all takes the pending-writes set directly (oxlint error) - the disposed flag moves into a _register'd marker instead of a public dispose() override, which the debug channels listing (and its test) correctly rejects as framework plumbing * fix(kap-server): surface persisted failures on the v2 session status The v2 list folds the outcome into activity.status, which previously read only live facts — a cold session always looked idle. Cold sessions now map a persisted failed outcome to status 'failed' (completed and cancelled stay idle, matching the live fold); warm sessions are unchanged, and the statuses filter inherits the mapping. * refactor(agent-core-v2): name the persisted field lastTurnReason Aligns with the established name for the same concept end to end (activity view's lastTurnReason, the v1 wire's last_turn_reason, and the SessionSummary mirror), instead of introducing a third variant. * fix(agent-core-v2): drain pending metadata writes before session teardown Review follow-up: closing/archiving a session right after a turn ended could dispose the scope while the outcome write was still queued, and delete() removes the session dir immediately after close. Await the pending metadata writes before the handle goes away. * fix(node-sdk): carry lastTurnReason through the SDK session summary Review follow-up: the in-process SDK path maps the engine summary through v2SummaryToSessionSummary, which dropped the new outcome field. Add it to the public SessionSummary type and the mapper; the parity gate projects it away (the v1 engine never records an outcome). * fix(node-sdk): populate lastTurnReason on live SDK summaries Review follow-up: resumeSession/reloadSession build their summary from the live session's metadata document, which now carries the outcome — surface it there too so the SDK reports it consistently for live and listed sessions. * fix(agent-core-v2): carry the last turn outcome across session forks Review follow-up: fork skips state.json when copying the session dir, so the fork's fresh metadata never had the outcome and a restart dropped a marker the warm fork was still reporting. The fork's metadata patch now inherits the source's lastTurnReason. * fix(agent-core-v2): settle pending outcome writes before reading a fork source Review follow-up: a fork requested right after the source's turn ended could read the metadata before the recorder's queued write landed, inheriting a stale or absent outcome. Drain pending metadata writes first. * fix(agent-core-v2): backfill restored outcomes into the session metadata Review follow-up: for sessions whose last turn ended before this field existed, the cold-resume seed restores the outcome into the activity view without a turn.ended fact, so the recorder never persisted it and cold listings stayed blank. The recorder now also watches the main agent's activity updates and backfills the restored outcome when nothing is persisted yet. * fix(agent-core-v2): never backfill restored cancellations Review follow-up: a restored 'cancelled' cannot be told apart from a programmatic abort (the activity event carries no interruptReason), and those are never persisted. Backfill now covers only completed/failed; user stops are still persisted from the live turn.ended fact. * refactor(agent-core-v2): rename the outcome recorder to outcome mirror Mirror is the codebase's established term for a write side that reflects live state into a store (SessionIndexMirror); Recorder has no precedent. * fix(agent-core-v2): backfill without bumping recency; header-only comments Review follow-ups: - a mere resume must not float an old session to the top of the list: metadata updates accept touchUpdatedAt:false and the outcome mirror's backfill uses it (live outcome writes keep bumping — turn end is a recency moment) - the mirror service's inline notes move into the file header per the package comment convention - drop the redundant |undefined from the SDK's optional outcome field * fix(node-sdk): read the live outcome for resumed session summaries Review follow-up: on a fresh resume the restored outcome can still be queued as a metadata backfill, so the document may lag a tick; the live activity aggregate already holds it. Resume/reload summaries now prefer the live value and fall back to the metadata field. * fix(agent-core-v2): confine the outcome backfill to pure resumes Review follow-up: the view publishes its turn.ended fold before this mirror's own turn.ended handler runs, so a live ending reached the backfill branch first and got persisted without the recency bump. The backfill now only applies when no turn ever started in this process — live endings always take the bumped write. * fix(agent-core-v2): drain the session-index mirror before session teardown Review follow-up: settling the metadata write alone left the fresh summary in the mirror's pending queue, so a list right after close could read a stale outcome from the read model. close/archive now also drain ISessionIndexMirror. Test harnesses register a mirror stub for the new dependency. * docs(agent-core-v2): fold the metadata drain contract into the file header * chore: include the SDK package in the changeset; fold the drain note into the header * fix(agent-core-v2): backfill restored cancellations too, quietly Review follow-ups: dropping every restored cancel loses legitimate user stops whose live write never landed (or was rejected) before a restart — cold surfaces never mark cancelled anyway, so healing them is harmless and strictly more accurate. The metadata disposal note moves into the file header per the comment convention. * fix(node-sdk): prefer the live outcome over the index in SDK listings Review follow-up: a live session that just started a new turn after a failure can briefly keep the stale outcome in the index while the mirror's clear is queued. listSessions now reads the live activity aggregate for warm sessions, matching the kap-server cold-only fallback. * fix(node-sdk): never read the metadata outcome for a live session Review follow-up: with a retry in flight the live aggregate has no outcome while the document may still hold the previous failure — the fallback showed the stale one. Live summaries now take the live aggregate's answer alone; the restored outcome is already seeded there on resume.	2026-08-06 20:14:05 +08:00
Haozhe	02c026d487	feat(agent-core-v2): tombstone removed MCP servers and freeze plugin prompt inputs (#2694) ... * feat(mcp): tombstone removed MCP servers and apply plugin changes immediately (20 files) - add 'removed' MCP server status: workspace config removals call markRemoved instead of remove, keeping tool registrations alive while short-circuiting calls with a removal notice - fire onDidReload after every plugin mutation (install/enable/disable/remove) so workspace consumers refresh contributions immediately - TUI renders the removed status in the MCP panel/startup summary and shows an apply-immediately hint on the v2 engine * feat(agent-core-v2): freeze plugin prompt inputs for live agents (2 files) - snapshot the model skill listing and plugin system-prompt sections on the first successful prompt build and reuse the frozen values for the agent's lifetime, so plugin install / enable / disable / remove / reload never rewrites a live agent's prompt (same keep-live-sessions-stable philosophy as the MCP tombstone) - freeze only on success: a not-yet-ready skill catalog or a failed enabledSystemPrompts() read must not pin empty values for the agent's lifetime - refreshSystemPrompt still rebuilds on catalog change events but reuses the frozen values, so the prompt only moves when non-plugin inputs change (AGENTS.md, [tools] section, session tool policy, compaction); new agents snapshot the then-current state * chore(changeset): add changesets for MCP tombstone and frozen plugin prompt inputs * docs: describe immediate plugin changes and the removed MCP status on the v2 engine * fix(klient): mirror the removed MCP server status in the wire contract * docs: drop the legacy-engine behavior notes from the plugin and MCP pages * fix(agent-core-v2): freeze plugin sections only on a loaded snapshot - enabledSystemPrompts() resolves to its consumption fallback (never rejects) while the initial plugin load has failed; freezing that empty read locked plugin sections out of the live agent even after a later successful reload - expose hasLoadedSnapshot() on IPluginService so resolvePluginSections can tell a real empty snapshot from the fallback before freezing	2026-08-06 19:19:51 +08:00
Haozhe	8c766a6c30	feat(agent-core-v2): add the L3 unit layer and the Feature seam (#2678) ... * feat(agent-core-v2): add the L3 unit layer and the Feature seam - introduce the L3 Service/Fiber unit layer: the Service base class with this.provide/effect/on/get/ref capabilities, the fiber runtime with thenable FiberHandles, collection contribution points, and the per-scope-kind ScopeUnits materialization fold - provide each scope's static registration batch as one atomic provideAll cascade transaction (waiting-area activation, sticky Failed on construction error) - add the DI unit inspection surface: App-scope debug ledger / dependency graph / cascade history services and the kimi-inspect DI view - add the Feature unit seam (IFeatureManager + feature assembly), port plan mode onto it, and add the contributed-command seam (agent-command domain + node-sdk RPC types) - remove the legacy dep-graph tooling - apply the header-only comment convention across src and test: strip non-header narration, keep the file header, tooling pragmas, and NOTE comments * feat(kap-server): gate the event.di.* debug feed to kimi-inspect connections - add an opt-in target set in SessionEventBroadcaster; the global fan-out now skips event.di.* frames for connections that never opted in, so kimi-web and other clients no longer receive the high-churn DI feed - WsConnectionV1 opts a connection in when client_hello carries client_id 'kimi-inspect'; removeGlobalTarget drops the opt-in on close - temporary gate until a client-declared event-type whitelist lands * chore(agent-core-v2): fix oxlint errors in the DI unit layer - build the live-ref container chain without aliasing this (no-this-alias) - snapshot the materialized map with Array.from and document why the copy is required (no-useless-spread) * test(klient): use string scope kinds in the lifecycle handle fakes The engine's LifecycleScope is a string enum now; the facade test doubles still returned the old numeric kinds and failed the handleWireSchema output validation. * build(nix): update the pnpmDeps fetch hash	2026-08-06 18:22:36 +08:00