5 commits

Author	SHA1	Message	Date
Haozhe	430cd382a8	refactor(agent-core-v2): drop pass-through methods from AgentRPCService (#2042) ... - trim AgentRPCService/AgentAPI to the 10 methods with real logic (prompt, steer, cancel, undoHistory, setPermission, cancelCompaction, activateSkill, activatePluginCommand, getContext, getTools) - route the klient agent facade to the domain services directly (shellCommand, profile, usage, plan, task) with new wire contracts - keep the test harness ctx.rpc surface unchanged via passthrough adapters - rewire kap-server rpc tests and the kimi-inspect RPC panel	2026-07-22 13:42:01 +08:00
Haozhe	6dd4fd3368	refactor(agent-core-v2): rebuild the model wire layer on the kosong architecture (#1970) ... * refactor(v2): land kosong contract layer (L0 wire contract) * refactor(v2): land kosong protocol layer (L1 traits and base registry) * refactor(v2): land kosong provider layer (bases, trait composers, kimi definition) * refactor(v2): land kosong model and catalog layers * refactor(v2): migrate engine callers to kosong, drop old llmProtocol layer * test(v2): migrate agent-core-v2 tests and harness to kosong * refactor: sync peripheral packages to kosong architecture * refactor(v2): replace provider dialects with per-protocol definitions * refactor(v2): merge the vertexai protocol into google-genai via providerOptions * refactor(v2): remove vendor-name gates outside the kosong layer * feat(v2): add model resolution inspection and connectivity ping * refactor(v2): remove the unused platform config layer * test(klient): pin invalid-input behavior across providers in e2e * refactor(agent-core-v2): merge kimi traits, split bases by protocol - merge the seven kimi trait modules into kimi.contrib.ts as two trait objects: kimiOpenAITrait (all native-transport hooks) and kimiAnthropicTrait (thinking only) - move bases/* implementations into per-protocol directories (openai/, anthropic/, google-genai/) and rename openai.contrib.ts to openai-legacy.contrib.ts - add per-directory index.ts registration barrels (import = registration) and exempt them in check-domain-layers.mjs alongside *.contrib.ts * refactor(agent-core-v2): reorganize model and request-layer types - consolidate shared model types (ModelOverrides, CompletionBudgetConfig/Params, ResolvedModelAuthMaterial, ThinkingDefaults/ModelThinkingMetadata) into kosong/model/model.types.ts and drop modelOverrides.ts - rename L2 request types to the ModelRequest* prefix: LLMEvent -> ModelRequestEvent, LLMRequestInput -> ModelRequestInput, LLMCallParams -> ModelRequestParams - extract ModelRequestTiming to replace three duplicated copies of the stream-timing shape - rename L3 llmRequester types with the Agent prefix to match IAgentLLMRequesterService (AgentLLMRequestOverrides/Finish/Task/Source/ PartHandler/LogFields) - delete the unused LLMRequestParams type * refactor(agent-core-v2): fold kosong/catalog into kosong/model - merge IModelCatalogService's enumeration surface (listModels / listProviders / getProvider / setDefaultModel and the wire shapes) into IModelCatalog; delete kosong/catalog/modelCatalog.ts - move the remote refresh path to the new IProviderDiscoveryService (discovery.ts + discoveryService.ts, renamed from catalog/modelCatalogService.ts) - relocate configSection / errors to discoveryConfigSection.ts / errors.ts; DEFAULT_MODEL_SECTION now lives in kosong/model/model.ts - drop the L3 catalog layer from check-domain-layers.mjs - kap-server routes / refresh scheduler / channelRegistry follow the split; klient renames the contract modelCatalogService to modelResolver and adds providerDiscovery; kimi-inspect reads via IModelCatalog - modelRequesterImpl: drop the streamedAnyPart backfill, onMessagePart already delivers every part - tests: remove the app/modelCatalog and kosong/catalog suites, add the kosong/model catalog and discovery suites * feat(klient): trim trailing undefined args and add boundary smoke probes - add trimTrailingUndefined helper so optional trailing args no longer cross the wire as null in http/ipc transports, which defeated server-side default parameters - add model-requester-boundary smoke probe for ChatProvider error wrapping behavior against real config and a local stub - add kimi-select-tools smoke probe verifying the kimi-only wire encoding of dynamic tool declarations - extend smoke.ts with a models set/get/delete round-trip, catalog list assertions, and update AGENTS.md with the new scripts * fix(agent-core-v2): declare openai chat hooks as function properties Method-shorthand members on OpenAIChatCompletionsHooks tripped typescript-eslint(unbound-method) at every extraction site (`const hook = this._hooks?.convertMessage` and friends), failing the repo-wide lint job. Every implementation is a plain closure composed by openaiHooks.ts, so declare the members as function-typed properties, which matches the actual semantics and clears the four errors. * fix: repair stale references surfaced by the origin/main rebase - agent-core-v2: point vacuousContent's ContentPart import at kosong/contract - kap-server: rewrite the transcript test seed as IModelCatalog (IModelResolver is gone) - klient: inline onceEvent/waitFor after the http transport helpers were dropped - kimi-inspect: remove useLiveEvent from ModelCatalogView; catalog polls on a slow interval * chore: downgrade the kosong architecture changeset to patch	2026-07-21 13:03:54 +08:00
Haozhe	5ae60fa673	feat(transcript): add unified transcript layer, drop the /api/v2 RPC surface (#1888) ... * feat(transcript): add unified transcript layer and v1 surface - add packages/transcript: agent-granular L1 store, idempotent L2 ops, off/turn/block/delta L3 granularity, L4 view registry, and turn-cursor pagination; sole owner of all transcript wire types - kap-server: engine-event-driven TranscriptService with history backfill, GET /sessions/{id}/transcript, and transcript.ops WS deltas with per-connection granularity control - kimi-inspect: render ChatView from the transcript surface (REST pages + delta-only WS) instead of context memory - sync flake.nix workspace lists and document packages/transcript and packages/server-e2e in AGENTS.md * fix(transcript): project live prompts and anchor backfilled items - agent-core-v2: carry the extracted prompt text on turn.started so the transcript projector can render the user input at turn open (the context append with the same text is not a bus event and lands later) - kap-server: keep the prompt through turn.ended; anchor backfilled markers/taskrefs to their following snapshot turn so replaying history after live turns arrived keeps the historical order - transcript: add an optional beforeTurn placement anchor to marker.upsert / taskref.upsert; anchored inserts land before the first turn at or past the anchor instead of appending blindly Addresses review feedback on #1888. * fix(transcript): adopt backfilled stream frames and group goal turns - kap-server: on mid-stream attach, adopt the backfill-seeded stream frame (id + offset) instead of opening an empty one whose upsert clobbered the seeded text and whose offset-0 appends could not land - transcript: group a turn-opening system_trigger (goal continuation) into its own turn so cold rebuilds keep the turn boundary and stay ordinal-aligned with the engine's live turn numbering Addresses review feedback on #1888. * fix(transcript): drop stale live stores on close and heal after turns - drop a session's live transcript store when the session closes or archives (lifecycle events plus a re-check on the cached-entry path) so reads fall back to the cold rebuild instead of serving a stale store - re-read an ended turn from the persisted wire records (debounced per agent) and merge it back live-first: headers keep live state/timestamps while origin/prompt recover from disk, and truncated text/thinking frames from a mid-turn attach are restored only when the persisted text is longer — a fresh live frame or a lagging flush is never reverted Addresses review feedback on #1888. * fix(transcript): adopt seeded tool frames and route subagent questions - kap-server: adopt the backfill-seeded tool frame when a tool.result arrives for a call that started before the projector attached, so the output lands instead of being dropped (the producer-store lookups now ride one projector options object) - agent-core-v2: record the owning agent on question interactions (ISessionQuestionService.request gains an agentId option, passed by AskUserQuestionTool from its agent scope) so a subagent's questions route to its own transcript and WS events instead of 'main' Addresses review feedback on #1888. * fix(transcript): adopt parent frames, namespace live markers, redact resets - kap-server: fall back to store adoption when subagent.spawned links a parent tool call that started before the projector attached, so the agentRefs link is not lost on mid-bind attaches - kap-server: id live markers in their own namespace (live-mN) — the cold rebuild numbers its markers m1... too, and a colliding id made the store's upsert replace the historical marker instead of appending - transcript/kap-server: redact transcript.reset snapshots to the subscriber's grade (below 'block' the step/frame detail is stripped), so a 'turn'-grade subscription no longer receives full content on resets Addresses review feedback on #1888. * fix(transcript): fold blocked turns into failed, drop inline v2 comment - kap-server: map turn.ended reason 'blocked' to the 'failed' transcript state, matching the engine's TurnEndReason wire contract and the v1 mapTurnReason folding (it was presented as a user cancellation) - agent-core-v2: move the question agentId rationale into the ask-user file header — package rules keep comments in the top-of-file block only Addresses review feedback on #1888. * fix(transcript): keep roster descriptors and resolved-event agents - kap-server: keep the metadata-seeded roster descriptor (parentAgentId / label) when an on-demand history backfill lands its roster entry, instead of downgrading it to { agentId, type } - kap-server: remember each interaction's owning agent and stamp it on the resolved question/approval v1 events — they were hard-coded to 'main', so an agent-filtered subscriber saw a subagent's question open but never close Addresses review feedback on #1888. * fix(transcript): defer pending seeding, skip ghost roster entries - kap-server: announce interactions pending at bind time only after the initial backfill (new TranscriptBinding.seedPendingInteractions), and adopt the seeded tool frame on the request/resolve paths, so a pre-existing approval lands next to its backfilled tool call and keeps the approvalId back-link - kap-server: skip the roster entry when a probed agent id has neither a roster presence nor persisted content (agent_id=nope no longer conjures a ghost subagent) - agent-core-v2: fold the turnEvents import rationale into the loop file header (package rule: comments live in the top-of-file block only) Addresses review feedback on #1888. * fix(transcript): reject hostile agent ids, honor the agent allowlist - transcript/kap-server: validate agent ids as plain names (no separators, no dot segments) at the REST query layer and again before the id is joined into the wire-records path — an authenticated client could otherwise read a wire.jsonl outside the agents directory - kap-server: compose the legacy v1 agent allowlist with transcript grades on every fan-out path (initial resets, per-ops fan-out, roster-driven resets), so a filtered connection no longer receives other agents' transcript frames Addresses review feedback on #1888. * fix(transcript): settle foreground shell tasks on shell.completed - agent-core-v2: emit a transient shell.completed event when a foreground `!` command settles (detached runs keep reporting through the task lifecycle) — the generic task.terminated never fires for foreground tasks, so their transcript cards were stuck at 'running' - kap-server: map shell.completed to the terminal transcript task state (completed/failed) and classify the event as volatile on both v1 durability gates, like its shell.* siblings Addresses review feedback on #1888. * fix(transcript): replay early resolves, reset on a widened filter - kap-server: register bind-time pending interactions without frames so a resolve arriving before the post-backfill seed still routes, then replay it at seed time — request and resolve land together with the approvalId back-link, instead of the interaction vanishing entirely - kap-server: treat an agent newly admitted by a broadened legacy agent filter as owed a transcript.reset even when its grade transition is a no-op (delta → delta) — its ops were suppressed so far, so it has no baseline otherwise Addresses review feedback on #1888. * fix(transcript): keep materialized transcripts on agent disposal - kap-server: only the projector dies with the agent scope — the materialized transcript and roster entry now survive disposal (the roster mirrors session metadata, which keeps completed agents). Dropping them lost already-served history for good: the backfill cache dedupes per agent, so the next read rebuilt an empty shell instead of replaying the persisted records Addresses review feedback on #1888. * fix(transcript): anchor refreshes by oldest turn, group slash turns - kimi-inspect: re-cover the previously loaded window after a refresh by paging until the previous OLDEST turn is loaded again (extracted as recoverLoadedWindow) — a count-based stop silently dropped the window's head once new turns shifted the server window - transcript: group user-slash skill/plugin activations into their own turn (marker included), mirroring the engine's isRealUserPrompt — their assistant output no longer folds into the previous turn on cold rebuilds; other triggers stay marker-only Addresses review feedback on #1888. * fix(transcript): compare all tool fields, overlay in-flight backfills - transcript: include toolCallId/name/view/input in the tool frame equality check — an upsert correcting only those was dropped as a no-op, leaving stale tool metadata on clients - kap-server: overlay the loop's active turn as 'running' after a backfill (cold grouping marks every rebuilt turn completed, so a live turn showed as finished until it ended); snapshot data supplies origin/prompt, and a projector-owned running header is never downgraded Addresses review feedback on #1888. * fix(transcript): gate ops before the seed, re-assert running headers - kap-server: gate the transcript ops fan-out (and roster-driven resets) on a per-connection seeded flag set only after the baseline reset has landed — a subscriber joining mid-stream no longer receives deltas against an empty baseline - kap-server: always re-assert the loop's active turn as 'running' after the snapshot ops in a backfill (skipping the overlay when a live running header existed let the snapshot's cold 'completed' header downgrade it); live header fields win over the snapshot's Addresses review feedback on #1888. * docs(agent-core-v2): fold turnEvents notes into the file header Move the turn.started prompt rationale from field/function TSDoc into the module header — package rules keep comments in the top-of-file block only. Addresses review feedback on #1888. * fix(transcript): emit shell failure output, dispose per-agent listeners - agent-core-v2: emit the synthesized failure text as a final shell.output chunk before shell.completed (it was never streamed, so failed foreground commands showed empty output in transcript tasks until a full rebuild) - kap-server: track each agent's bus subscription per agent and dispose it in onDidDispose — the listener captures the projector, so a disposed agent no longer keeps projecting late events into the store Addresses review feedback on #1888. * fix(transcript): route shell events by task id, tidy question docs - agent-core-v2: keep the commandId → foreground-task-id mapping and carry taskId on shell.output / shell.completed, so consumers attaching mid-command (having missed shell.started) can still route output and the terminal state - kap-server: fall back to the event's taskId in the shell output/completed projectors and seed the shell task before the first chunk, so output is preserved and the terminal upsert cannot clobber it with an empty tail - agent-core-v2: fold the question agentId note into the question.ts file header (package rule: comments live in the top-of-file block only) Addresses review feedback on #1888. * fix(transcript): tighten agent id validation, match kinds in heals - transcript: constrain agent ids to a filename-safe shape ([A-Za-z0-9._-], <=128 chars) — NUL-containing or overlong ids made the wire-records read throw unhandled errors (500) instead of failing validation - kap-server: require the live frame's kind to match before the post-turn heal's length shortcut — a kind-mismatched frame (the projector guessed the stream kind wrong mid-turn) is now replaced by the persisted one instead of being skipped Addresses review feedback on #1888. * fix(transcript): heal missed tool results, seed pendings per agent - kap-server: re-emit tool frames in the post-turn heal when the live step lacks the frame or the live frame lacks the outcome the persisted one carries (a tool.result dropped in the attach race is otherwise unrecoverable); live-only extras (display / agentRefs / approvalId) are preserved, and frames with a live outcome stay untouched - kap-server: scope seedPendingInteractions by agent — the initial seed after backfillMain covers main-owned pendings, and each subagent's pendings seed after its own on-demand backfill, so placement and the approvalId back-link find the persisted tool frames Addresses review feedback on #1888. * fix(protocol): register shell.completed on the v1 event surface - packages/protocol: add ShellCompletedEvent (plus optional taskId on shell.output / shell.completed and prompt on turn.started) to the event interfaces, zod schemas, the agent event union, and the volatile list — schema-validating consumers previously rejected the forwarded shell.completed frames outright - kap-server: mirror the same fields in the v1 events-zod module Addresses review feedback on #1888. * test(node-sdk): cover shell.completed in the exhaustive event switch The SDK's session-event type test asserts exhaustiveness with assertNever; register the new event there (CI typecheck caught it). Addresses review feedback on #1888. * fix(transcript): source cold-session rosters from session metadata - kap-server: add TranscriptService.readColdRoster (persisted state.json → descriptors, mapped like the live seeding) and use it for the cold transcript path — the requested agent id is only appended when it has content (or is main), so an empty probe (agent_id=nope) no longer fabricates a ghost roster entry, matching the live path Addresses review feedback on #1888. * fix(transcript): emit taskrefs when seeding missed shell commands - kap-server: the mid-command-attach seeding in onShellOutput now emits the matching taskref.upsert (exactly like onShellStarted), and onShellCompleted emits one when the whole command was missed — the task no longer exists only in the global map with no timeline item to render Addresses review feedback on #1888. * fix(transcript): defer unseeded live pendings, keep cold tools running - kap-server: pendings created before their owning agent's seed has run now defer into the same unseeded queue as bind-time ones (tracked per agent) — announcing them during the backfill window misplaced them into a synthetic step with no later repair - transcript: cold grouping initializes tool frames as 'running' and lets the tool-message branch transition them to done/error — an approval- gated or still-executing tool no longer shows as completed on rebuilds Addresses review feedback on #1888. * fix(transcript): seed live-created agents, merge backfills live-first - kap-server: agents created after binding are marked seeded immediately — their projector covers every event from creation on, so their pendings announce without waiting for an explicit history read (which previously left live subagent approvals/questions stuck in the unseeded queue) - kap-server: the initial backfill merges turns live-first via healTurnOps (snapshotToOps gains a turn-mapper parameter) — live frame fields landed during the disk read (display/approvalId, longer text) are no longer replaced by the staler persisted version Addresses review feedback on #1888. * fix(transcript): count pages in turn segments, not head units - transcript: the leading non-turn unit no longer consumes a turn slot — pages are counted in turn segments and the head unit rides only with the page reaching the first turn. A timeline with a head marker and exactly pageSize turns used to drop the marker from the newest page and hallucinate an older marker-only page (has_more: true with no older turns) Addresses review feedback on #1888. * fix(transcript): send baseline resets after cursor replay - kap-server: broadcaster.subscribe gains deferTranscriptReset (recording prev grades/filter per target) plus flushTranscriptSeed; the v1 connection defers the transcript baseline on cursor-carrying (re)subscribes and flushes it after replay — a reconnecting client no longer sees the reset's current seq ahead of the replayed lower-seq backlog Addresses review feedback on #1888. * fix(transcript): gate the ops fan-out only when a reset is coming - kap-server: willSendTranscriptReset decides upfront whether any reset will be sent (grade upgrade or widened legacy filter); a same-grades resubscribe no longer un-seeds the target, so ops emitted mid-resubscribe keep flowing instead of being silently dropped by the fan-out gate Addresses review feedback on #1888. * fix(transcript): seed subscribers even when no reset is owed - kap-server: a no-reset subscription (e.g. a client subscribing to a fresh session with an empty roster) now still marks the target seeded after subscribeTranscript completes — roster resets and ops would otherwise stay gated forever once agents appear Addresses review feedback on #1888. * fix(transcript): guard mismatched appends, expose prompt via klient - transcript: appendAtOffset now treats an overlapping chunk whose head does not match the local tail as a gap (diverged stream) instead of silently rewriting from the offset and dropping local content - klient: add the optional prompt field to the turn.started event schema so SDK listeners receive it instead of zod stripping it Addresses review feedback on #1888. * fix(transcript): open turns for subagent run prompts in cold grouping - transcript: add the subagent system trigger to the turn-opening set — a subagent's run prompt (persisted as system_trigger/'subagent') always launches a new engine turn, so resumed subagent histories no longer fold the response into the previous turn or lose the prompt Addresses review feedback on #1888. * fix(transcript): guard bus subscriptions independently of projectors - kap-server: subscribeAgent now guards on a dedicated subscribedAgents set instead of projector existence — a projector seeded before its agent's handle exists (e.g. during an on-demand backfill) no longer blocks the bus subscription, so the agent's live events keep flowing Addresses review feedback on #1888. * fix(kimi-inspect): reconcile the transcript on every socket open - apps/kimi-inspect: TranscriptWs now reports onReconnected on the FIRST successful open too, not only on re-established ones — ops emitted between the REST page load and the subscription (a delayed or failed first connection) were previously lost onto a stale store; the consumer's refresh guard drops the no-op call while the initial load is in flight Addresses review feedback on #1888. * fix(transcript): derive the active step, dedupe tool error rendering - kap-server: the projector gains a stepOrdinal lookup backed by the engine's activity view (resolved lazily through the agent lifecycle), so deltas after a late attach at step >= 2 land in the real active step instead of a synthesized t<N>.1 - apps/kimi-inspect: render a tool frame's error only when it differs from its output — onToolResult sets both to the same string for failed tools, which drew the failure twice in red Addresses review feedback on #1888. * fix(kimi-inspect): reconcile the transcript on the subscribe ack - apps/kimi-inspect: TranscriptWs now fires onReconnected when the subscribe ack for its client_hello arrives instead of at socket open — the server attaches the transcript stream only after processing client_hello, so a refresh fired at open could finish before the subscription was active and still miss the ops in between Addresses review feedback on #1888. * fix(kimi-inspect): coalesce concurrent transcript refreshes instead of dropping A subscribe ack landing while the initial REST load was still in flight hit the `if (refreshing) return` guard, so ops emitted between the REST page snapshot and the WS subscribe were neither in the page nor delivered over the socket. Replace the drop guard with a coalesced runner: at most one refresh in flight, and triggers during a run are collapsed into exactly one follow-up run after it settles. * fix(kap-server): force the transcript baseline after cursor-based replay A cursor re-subscribe at unchanged grades deferred its baseline and then compared against the previous grades on flush, so no reset was sent — while volatile ops fanned out during the deferral had been dropped, leaving the client with a permanent gap. flushTranscriptSeed now always seeds a full baseline (previous grades no longer tracked in the deferred record), and a regression test covers the same-grade cursor resubscribe. Also drop the inline comments added to shellCommandService.ts — the agent-core-v2 convention keeps commentary in the top-of-file block; the context moved there. * fix(kap-server): harden transcript seeding against stale and wildcard subs Two subscribeTranscript gaps found in review: - Re-read the target's subscription after the history awaits: subscribe work runs asynchronously, so an overlapping downgrade/unsubscribe used to be answered with resets computed from the stale spec. The reset loop now uses the latest grades/filter from state.targets and bails when the target is gone or no longer graded. - Backfill roster agents admitted via the wildcard grade, not just explicitly named ones: a historical subagent seeded into the roster from session metadata had no materialized AgentTranscript, so wildcard subscribers silently never received its baseline reset. Adds regression tests for the wildcard backfill, the mid-seed downgrade, and the mid-seed unsubscribe (all three fail without the fix); makeCore now accepts persisted agent metadata for roster seeding. * fix(transcript): let meta.merge clear mode badges on mode exit `agent.status.updated` with `planMode: false` / `swarmMode: false` was dropped by the transcript projector because `meta.merge` could only set mode badges, never clear them — clients kept rendering an exited mode until the next full reset. The merge wire shape now accepts `null` per mode key (set = object, clear = null, absent = keep): the reducer deletes the key and normalizes an empty `modes` away, the zod schema validates the nullable form, and the projector emits the clearing op for exit events. * fix(agent-core-v2): keep system-turn steering text out of turn prompts `turn.started.prompt` was populated from the turn input for every origin, so system-triggered turns (goal continuation, subagent run, cron) exposed their internal steering text to live transcript consumers; the cold rebuild mirrored the same leak when grouping persisted history. The loop now populates the prompt only for displayable user origins (user input, or a user-slash skill/plugin activation) via the new isDisplayablePromptOrigin gate, and the cold grouping opens hidden-origin turns promptless. Turns still open normally — only the prompt text is withheld. * fix(kap-server): reattach the transcript fan-out after a session reload When the engine session closed or archived, TranscriptService dropped the live store together with its ops listener set, but the broadcaster's SessionState kept its transcriptStream — so ensureTranscriptStream returned early for a later subscribe on the resumed session, delivering a fresh reset but never the live transcript.ops. The stream is now pinned to its TranscriptStore instance and the fan-out re-registers whenever a rebuilt store shows up. Adds a regression test that drops the service entry mid-stream and asserts ops keep flowing after resubscribe (fails without the fix). * fix(transcript): map legacy background_task origins in cold rebuilds Legacy/v1 sessions persist background-task notifications with origin.kind === 'background_task' (the live mapper already handles that spelling), but the cold grouping only mapped 'task' — after a restart those turns fell through to { kind: 'other' } and lost their taskId, so the transcript could no longer associate the notification turn with its background task. Both spellings now share the task-origin branch. * fix(kap-server): project no-taskId shell failures into the transcript A foreground `!` command that failed before onForegroundTaskStart ran (Bash validation/spawn/registerTask errors) published shell.output / shell.completed with taskId undefined, and the projector's guard dropped them — the live transcript lost the stderr and the terminal state of a command that did run. Shell events now resolve their task as the id learned at shell.started, else the event's own taskId, else a synthetic per-command id (shell-<commandId>), so early failures land like any other shell task. * refactor: drop the /api/v2 RPC surface and the klient http transport - kap-server: remove the /api/v2 REST routes and /api/v2/ws socket (registerRpcRoutes renamed to serviceDispatcherRoutes; transport/ws/{eventMap,registerWs,wsClient,wsConnection,wsProtocol} deleted). /api/v1/debug/* is now the only RPC surface — a reflection dispatcher over the entire scoped DI registry with no whitelist — and /api/v1/ws the only WS endpoint - klient: drop the http transport (transports/http/*, transports/ws/wsSocket.ts) and the kap-server devDependency; transports reduce to the ipc|memory subpath entries, and the dual/v2 e2e suites go with them - kimi-inspect: target /api/v1/debug only with no fallback, replace the Service-event push channel (wsChannel/wsSocket) with on-demand fetch plus 15 s polling, and show a blocking "Debug surface unavailable" screen on connection failure - transcript: add global attachment/interaction/todo entities (model, ops, wire schema) and project them from engine events in kap-server's coreEventMap * fix(kimi-inspect): drop the unused TranscriptTodo import	2026-07-20 15:33:05 +08:00
Haozhe	a41a09c33c	feat(cli): replace the kimi server command tree with kimi web and share one home across servers (#1826) ... * feat(kap-server): enable multi-server shared home by default - always register kap-server instances under server/instances and drop the legacy single-instance lock (acquireLock/getLiveLock/ServerLockedError) - remove the multi_server experimental flag and its KIMI_CODE_EXPERIMENTAL_MULTI_SERVER env var from agent-core-v2 - discover running servers via the instance registry in server ps/kill/rotate-token, kimi web daemon reuse, and the desktop app - remove the pending minidb changesets * feat(cli): add per-instance targeting to server kill and ps - `kimi server kill [serverId]` stops only the matching instance; without an id it still stops the longest-running one, and an unknown id errors with the live server ids listed - `kimi server ps` lists connections grouped per server id (`--json` nests them under a per-server object); an unreachable instance degrades to a per-server note instead of failing the whole listing - update the zh/en command reference and the multi-server changeset * feat(cli): replace kimi server with the kimi web command tree - `kimi web` now runs the local server in the foreground and opens the browser; the background daemon (ensureDaemon / spawn / idle-exit) is removed, so repeated runs simply start another instance on the next free port - drop the OS-service lifecycle (install/uninstall/start/stop/restart/ status) together with kap-server's svc layer - `kimi web kill [serverId]`, `kimi web ps`, and `kimi web rotate-token` manage instances from the registry - the TUI /web command now connects to an already-running instance instead of spawning a background daemon - update the zh/en command reference, dev scripts, and tests * feat(cli): route kimi server invocations to a deprecation notice Any `kimi server …` call — bare or with any legacy subcommand/flags — now prints a deprecation notice pointing at `kimi web` and exits 1, instead of failing with an opaque "unknown command". The shim is scheduled for removal in the next major version. * feat(cli): add the `all` keyword to kimi web kill `kimi web kill all` stops every live instance in the registry (ULIDs can never collide with the keyword). Each instance still gets the API shutdown + SIGTERM/SIGKILL treatment; a failure on one instance does not stop the sweep and is reported at the end. * docs(changeset): drop the web-foreground-default changeset The kimi web command tree replaces the foreground-default behavior this entry describes: --background, daemon reuse, and the version-mismatch hint no longer exist, so the pending entry would contradict the actual release notes. * docs(changeset): tighten the multi-server entry wording * feat(cli): let /web pick a running server or start a new one The /web picker now lists the live instances from the registry with their versions (flagging a CLI mismatch) instead of only connecting to the longest-running one, and offers starting a new server: that one runs in the foreground attached to the terminal after the TUI exits, via the restored exit-takeover wiring. formatReadyBanner is exported and adapts its Stop hint to Ctrl+C for the attached case. * feat(cli): skip the /web picker and start a new server when none is running	2026-07-19 11:43:46 +08:00
Haozhe	9b496946dc	feat(kimi-inspect): add kap-server web inspector with dev-only /api/v1/debug RPC surface (#1806) ... * feat(kimi-inspect): add web inspector for kap-server /api/v2 surface - new apps/kimi-inspect app: connect screen (server URL + optional bearer token, persisted in localStorage, deep-linkable via ?url=/?token=), workspace/session browser sidebar, per-session chat view, and live Service panels with data and trigger buttons for Session/Agent scopes - built on @moonshot-ai/klient (HTTP for calls, /api/v2/ws for events); Vite dev server proxies /api to a running kap-server - register the workspace in AGENTS.md project map and flake.nix workspacePaths/workspaceNames * fix(kimi-inspect): align dependency versions with the workspace (sherif) * feat: dev /api/v1/debug RPC surface and kimi-inspect channel rework - kimi-inspect: replace @moonshot-ai/klient with an in-app old-klient-style channel layer (service-bound IChannel, HTTP ProxyChannel, shared /api/v2/ws socket with ref-counted event listens), typed by agent-core-v2 interfaces; /channels descriptors + serviceByName keep every wire protocol loaded 1:1 - kimi-inspect: local server auto-discovery (Vite middleware over the kap-server instance registry + home token), zero-config startup connect, and a header switcher for runtime server switching - kap-server: wire the dormant --debug-endpoints flag to a new whitelist-free /api/v1/debug dispatcher (every scoped service callable), gated to loopback binds; repo dev scripts pass the flag - kimi-inspect: probe the debug surface at connect, falling back to /api/v2 on servers without it - tests: channel + discovery unit tests in kimi-inspect; debug RPC and loopback-gating coverage in the kap-server rpc/debugNonloopback suites * chore(changesets): ignore @moonshot-ai/kimi-inspect The private dev app never ships, so it should never appear in a changeset. Add it to the changeset config ignore list (next to vis*) and note the rule in the gen-changesets skill.	2026-07-17 15:56:53 +08:00