@nextclaw/kernel 0.1.2 → 0.1.3

package/dist/index.d.ts

@@ -1,5 +1,14 @@
-import { a as getUnsignedUpdateManifest, c as UpdateBlockReason, d as UpdateSnapshot, f as UpdateStatus, i as UpdateManifestReader, l as UpdatePreferences, n as UpdateHostKind, o as serializeUnsignedUpdateManifest, r as UpdateManifest, s as InstallationKind, t as UnsignedUpdateManifest, u as UpdateProgress } from "./update-manifest.types-BAJqcsP5.js";
-import { NcpMessage, NcpSessionSummary } from "@nextclaw/ncp";
+import { a as getUnsignedUpdateManifest, c as UpdateBlockReason, d as UpdateSnapshot, f as UpdateStatus, i as UpdateManifestReader, l as UpdatePreferences, n as UpdateHostKind, o as serializeUnsignedUpdateManifest, r as UpdateManifest, s as InstallationKind, t as UnsignedUpdateManifest, u as UpdateProgress } from "./update-manifest.types-DLWDvs_v.js";
+import { BaseChannel, ChannelManager, ChannelManager as ChannelManager$1, Config, ContextCompactionPlan, ContextWindowSnapshot, CronService, Disposable, ExtensionRegistry, GatewayController, InboundAttachment, InboundMessage, LLMProvider, LLMResponse, LLMStreamEvent, MessageBus, SearchConfig, SessionManager, SessionMessage, SessionRequestDispatcher, SessionRequestManager, SessionRequestRecord, SessionRequestToolResult, SessionSearchManager, SpawnSessionAndRequestParams, ThinkingLevel, buildCompressingCompactionCheckpoint } from "@nextclaw/core";
+import * as _$_nextclaw_shared0 from "@nextclaw/shared";
+import { EventBus, Ingress, Unsubscribe } from "@nextclaw/shared";
+import { LocalAssetStore } from "@nextclaw/ncp-agent-runtime";
+import * as _$_nextclaw_ncp0 from "@nextclaw/ncp";
+import { ListMessagesOptions, ListSessionsOptions, NcpAgentClientEndpoint, NcpAgentRunApi, NcpAgentRunInput, NcpAgentRuntime, NcpContextBuilder, NcpContextPrepareOptions, NcpEndpointEvent, NcpLLMApi, NcpLLMApiInput, NcpLLMApiOptions, NcpMessage, NcpMessagePart, NcpSessionApi, NcpSessionPatch, NcpSessionStatus, NcpSessionSummary, NcpTool, NcpToolDefinition, NcpToolRegistry, OpenAIChatChunk } from "@nextclaw/ncp";
+import { AgentSessionStore, ChatTarget, DefaultNcpAgentBackend, NcpReplyInput, RuntimeFactoryParams } from "@nextclaw/ncp-toolkit";
+import { McpNcpToolRegistryAdapter } from "@nextclaw/ncp-mcp";
+import { PluginChannelBinding, PluginRegistry, PluginUiMetadata } from "@nextclaw/openclaw-compat";
+import { NcpHttpAgentStreamProvider } from "@nextclaw/ncp-http-agent-server";
 
 //#region src/types/entity-ids.types.d.ts
 type AgentId = string;
@@ -7,7 +16,6 @@ type TaskId = string;
 type SessionId = string;
 type ToolId = string;
 type SkillId = string;
-type LlmProviderId = string;
 type AutomationId = string;
 type ChannelId = string;
 //#endregion
@@ -16,7 +24,6 @@ type AgentRecord = {
   id: AgentId;
   name: string;
   description?: string;
-  defaultProviderId?: LlmProviderId | null;
   enabledSkillIds: SkillId[];
   enabledToolIds: ToolId[];
   metadata: Record<string, unknown>;
@@ -24,159 +31,583 @@ type AgentRecord = {
 //#endregion
 //#region src/managers/agent.manager.d.ts
 declare class AgentManager {
-  readonly listAgents: () => never;
-  readonly getAgent: (agentId: AgentId) => never;
-  readonly requireAgent: (agentId: AgentId) => never;
-  readonly saveAgent: (agent: AgentRecord) => never;
-  readonly removeAgent: (agentId: AgentId) => never;
-  readonly attachSkill: (agentId: AgentId, skillId: SkillId) => never;
-  readonly detachSkill: (agentId: AgentId, skillId: SkillId) => never;
-  readonly attachTool: (agentId: AgentId, toolId: ToolId) => never;
-  readonly detachTool: (agentId: AgentId, toolId: ToolId) => never;
+  listAgents: () => never;
+  getAgent: (agentId: AgentId) => never;
+  requireAgent: (agentId: AgentId) => never;
+  saveAgent: (agent: AgentRecord) => never;
+  removeAgent: (agentId: AgentId) => never;
+  attachSkill: (agentId: AgentId, skillId: SkillId) => never;
+  detachSkill: (agentId: AgentId, skillId: SkillId) => never;
+  attachTool: (agentId: AgentId, toolId: ToolId) => never;
+  detachTool: (agentId: AgentId, toolId: ToolId) => never;
 }
 //#endregion
-//#region src/types/automation.types.d.ts
-type AutomationTrigger = {
-  kind: "cron";
-  expression: string;
-} | {
-  kind: "manual";
-} | {
-  kind: "event";
-  event: string;
-};
-type AutomationRecord = {
-  id: AutomationId;
-  name: string;
-  enabled: boolean;
-  trigger: AutomationTrigger;
-  agentId: AgentId;
-  sessionId?: SessionId | null;
-  inputTemplate?: unknown;
-  metadata: Record<string, unknown>;
+//#region src/managers/llm-provider.manager.d.ts
+type ProviderChatParams = {
+  messages: Array<Record<string, unknown>>;
+  tools?: Array<Record<string, unknown>>;
+  model?: string | null;
+  maxTokens?: number;
+  thinkingLevel?: ThinkingLevel | null;
+  signal?: AbortSignal;
+};
+type LlmProviderRuntime = {
+  get: (model?: string | null) => LLMProvider;
+  chat: (params: ProviderChatParams) => Promise<LLMResponse>;
+  chatStream: (params: ProviderChatParams) => AsyncGenerator<LLMStreamEvent>;
+};
+type ProviderConnectionTestInput = {
+  providerName: string | null;
+  apiKey?: string | null;
+  apiBase?: string | null;
+  defaultModel: string;
+  extraHeaders?: Record<string, string> | null;
+  wireApi?: "auto" | "chat" | "responses" | null;
+  messages: Array<Record<string, unknown>>;
+  maxTokens?: number;
+  signal?: AbortSignal;
 };
+declare class LlmProviderManager {
+  private readonly providerRegistry;
+  private readonly providerPool;
+  private readonly missingProvider;
+  private config;
+  constructor();
+  load: (config: Config) => void;
+  get: (model?: string | null) => LLMProvider;
+  readonly chat: (params: ProviderChatParams) => Promise<LLMResponse>;
+  readonly chatStream: (this: LlmProviderManager, params: ProviderChatParams) => AsyncGenerator<LLMStreamEvent>;
+  readonly testConnection: (input: ProviderConnectionTestInput) => Promise<void>;
+  private resolveRoute;
+  private resolveProvider;
+  private matchPrefixedProvider;
+  private getOrCreateProvider;
+  private createProvider;
+  private buildCacheKey;
+}
 //#endregion
-//#region src/managers/automation.manager.d.ts
-declare class AutomationManager {
-  readonly listAutomations: () => never;
-  readonly getAutomation: (automationId: AutomationId) => never;
-  readonly requireAutomation: (automationId: AutomationId) => never;
-  readonly saveAutomation: (automation: AutomationRecord) => never;
-  readonly enableAutomation: (automationId: AutomationId) => never;
-  readonly disableAutomation: (automationId: AutomationId) => never;
-  readonly deleteAutomation: (automationId: AutomationId) => never;
+//#region src/managers/extension.manager.d.ts
+type AgentRuntimeContribution = {
+  pluginId: string;
+  kind: string;
+  label: string;
+  createRuntime: (params: RuntimeFactoryParams) => NcpAgentRuntime;
+  createRuntimeForEntry?: (params: {
+    entry: {
+      id: string;
+      label: string;
+      type: string;
+      enabled?: boolean;
+      config?: Record<string, unknown>;
+    };
+    runtimeParams: RuntimeFactoryParams;
+  }) => NcpAgentRuntime;
+  describeSessionType?: (params?: {
+    describeMode?: "observation" | "probe";
+  }) => Promise<Record<string, unknown> | null | undefined> | Record<string, unknown> | null | undefined;
+  describeSessionTypeForEntry?: (params: {
+    entry: {
+      id: string;
+      label: string;
+      type: string;
+      enabled?: boolean;
+      config?: Record<string, unknown>;
+    };
+    describeParams?: {
+      describeMode?: "observation" | "probe";
+    };
+  }) => Promise<Record<string, unknown> | null | undefined> | Record<string, unknown> | null | undefined;
+  source?: string;
+};
+type NextclawExtensionRegistry = ExtensionRegistry & {
+  ncpAgentRuntimes: AgentRuntimeContribution[];
+};
+type ExtensionContributions = {
+  registry: PluginRegistry;
+  extensionRegistry: NextclawExtensionRegistry;
+  channelBindings?: PluginChannelBinding[];
+  uiMetadata?: PluginUiMetadata[];
+};
+declare class ExtensionManager {
+  private pluginRegistry;
+  private extensionRegistry;
+  private channelBindings;
+  private uiMetadata;
+  loadContributions: (contributions: ExtensionContributions) => void;
+  loadExtensionRegistry: (extensionRegistry: NextclawExtensionRegistry) => void;
+  getExtensionRegistry: () => NextclawExtensionRegistry;
+  getChannelBindings: () => PluginChannelBinding[];
+  getUiMetadata: () => PluginUiMetadata[];
+  toConfigView: (config: Config) => Config;
+  mergeConfigView: (current: Config, nextConfigView: Record<string, unknown>) => Config;
+  resolveMessageToolHints: (params: {
+    channel?: string | null;
+    config?: Config;
+    accountId?: string | null;
+  }) => string[];
 }
 //#endregion
-//#region src/types/channel.types.d.ts
-type ChannelDirection = "inbound" | "outbound" | "bidirectional";
-type ChannelRecord = {
-  id: ChannelId;
-  name: string;
-  enabled: boolean;
-  direction: ChannelDirection;
-  metadata: Record<string, unknown>;
-};
+//#region src/features/runtime-registry/services/agent-runtime-registry.service.d.ts
+declare const DEFAULT_AGENT_RUNTIME_ENTRY_ID = "native";
+type AgentRuntimeSessionTypeIcon = {
+  kind: "image";
+  src: string;
+  alt?: string | null;
+};
+type AgentRuntimeSessionTypeOption = {
+  value: string;
+  label: string;
+  icon?: AgentRuntimeSessionTypeIcon | null;
+  ready?: boolean;
+  reason?: string | null;
+  reasonMessage?: string | null;
+  supportedModels?: string[];
+  recommendedModel?: string | null;
+  cta?: {
+    kind: string;
+    label?: string;
+    href?: string;
+  } | null;
+};
+type AgentRuntimeSessionTypeDescribeParams = {
+  describeMode?: "observation" | "probe";
+};
+type AgentRuntimeEntry = {
+  id: string;
+  label: string;
+  icon?: AgentRuntimeSessionTypeIcon | null;
+  type: string;
+  enabled?: boolean;
+  config?: Record<string, unknown>;
+};
+type AgentRuntimeProviderRegistration = {
+  kind: string;
+  label: string;
+  createRuntime: (params: RuntimeFactoryParams) => NcpAgentRuntime;
+  createRuntimeForEntry?: (params: {
+    entry: AgentRuntimeEntry;
+    runtimeParams: RuntimeFactoryParams;
+  }) => NcpAgentRuntime;
+  describeSessionType?: (params?: AgentRuntimeSessionTypeDescribeParams) => Promise<Omit<AgentRuntimeSessionTypeOption, "value" | "label"> | null | undefined> | Omit<AgentRuntimeSessionTypeOption, "value" | "label"> | null | undefined;
+  describeSessionTypeForEntry?: (params: {
+    entry: AgentRuntimeEntry;
+    describeParams?: AgentRuntimeSessionTypeDescribeParams;
+  }) => Promise<Omit<AgentRuntimeSessionTypeOption, "value" | "label"> | null | undefined> | Omit<AgentRuntimeSessionTypeOption, "value" | "label"> | null | undefined;
+};
+declare function normalizeAgentRuntimeSessionTypeIcon(value: unknown): AgentRuntimeSessionTypeIcon | null;
+type ConfigRuntimeEntry = {
+  enabled?: boolean;
+  label?: string;
+  icon?: unknown;
+  type?: string;
+  config?: Record<string, unknown>;
+};
+type AgentRuntimeResolverConfig = {
+  ui?: {
+    ncp?: {
+      runtimes?: {
+        native?: unknown;
+      };
+    };
+  };
+  agents: {
+    runtimes: {
+      entries?: Record<string, ConfigRuntimeEntry>;
+    };
+  };
+};
+declare function resolveAgentRuntimeEntries(params: {
+  config: AgentRuntimeResolverConfig;
+  providerKinds: string[];
+}): {
+  defaultEntryId: string;
+  entries: AgentRuntimeEntry[];
+};
+declare class AgentRuntimeRegistry {
+  private readonly providers;
+  private entries;
+  private defaultEntryId;
+  register: (registration: AgentRuntimeProviderRegistration) => Disposable;
+  applyEntries: (params: {
+    entries: AgentRuntimeEntry[];
+    defaultEntryId?: string;
+  }) => void;
+  listProviderKinds: () => string[];
+  createRuntime: (params: RuntimeFactoryParams) => NcpAgentRuntime;
+  listSessionTypes: (params?: AgentRuntimeSessionTypeDescribeParams) => Promise<{
+    defaultType: string;
+    options: AgentRuntimeSessionTypeOption[];
+  }>;
+}
 //#endregion
-//#region src/managers/channel.manager.d.ts
-declare class ChannelManager {
-  readonly listChannels: () => never;
-  readonly getChannel: (channelId: ChannelId) => never;
-  readonly requireChannel: (channelId: ChannelId) => never;
-  readonly saveChannel: (channel: ChannelRecord) => never;
-  readonly enableChannel: (channelId: ChannelId) => never;
-  readonly disableChannel: (channelId: ChannelId) => never;
+//#region src/features/runtime-registry/controllers/plugin-runtime-registration.controller.d.ts
+declare class PluginRuntimeRegistrationController {
+  private readonly runtimeRegistry;
+  private readonly extensions;
+  private readonly pluginRuntimeScopes;
+  private pluginRuntimeSnapshotKey;
+  constructor(runtimeRegistry: AgentRuntimeRegistry, extensions: ExtensionManager);
+  refreshPluginRuntimeRegistrations: () => void;
+  dispose: () => void;
+  private syncPluginRuntimeRegistrations;
+  private resolveActiveExtensionRegistry;
 }
 //#endregion
-//#region src/types/context.types.d.ts
-type ContextRecord = {
-  sessionId: SessionId;
-  taskId?: TaskId | null;
-  agentId?: AgentId | null;
-  workspace?: string | null;
-  memoryRefs: string[];
-  selectedSkillIds: SkillId[];
-  selectedToolIds: ToolId[];
-  selectedProviderId?: LlmProviderId | null;
-  variables: Record<string, unknown>;
-};
-//#endregion
-//#region src/types/task.types.d.ts
-type TaskStatus = "pending" | "running" | "blocked" | "completed" | "failed" | "cancelled";
-type TaskRecord = {
-  id: TaskId;
-  title: string;
-  status: TaskStatus;
-  agentId: AgentId;
-  sessionId: SessionId;
-  input: unknown;
-  output?: unknown;
-  error?: string | null;
-  createdAt: string;
-  updatedAt: string;
-  metadata: Record<string, unknown>;
-};
+//#region src/features/ncp-dispatch/utils/agent-runtime-handle.utils.d.ts
+type AgentRuntimeSessionTypes = Awaited<ReturnType<AgentRuntimeRegistry["listSessionTypes"]>>;
+type AgentRuntimeEndpoint = {
+  agentClientEndpoint: NcpAgentClientEndpoint;
+  streamProvider?: NcpHttpAgentStreamProvider;
+  listSessionTypes?: (params?: AgentRuntimeSessionTypeDescribeParams) => Promise<AgentRuntimeSessionTypes> | AgentRuntimeSessionTypes;
+  assetApi?: {
+    put: (input: {
+      fileName: string;
+      mimeType?: string | null;
+      bytes: Uint8Array;
+      createdAt?: Date;
+    }) => ReturnType<LocalAssetStore["putBytes"]>;
+    stat: LocalAssetStore["statRecord"];
+    resolveContentPath: LocalAssetStore["resolveContentPath"];
+  };
+  basePath?: string;
+};
+type AgentRuntimeHandle = AgentRuntimeEndpoint & {
+  runApi: NcpAgentRunApi;
+  sessionApi: NcpSessionApi;
+  applyMcpConfig?: (config: Config) => Promise<void>;
+  dispose?: () => Promise<void>;
+};
+declare function createAgentRuntimeHandle(params: {
+  backend: DefaultNcpAgentBackend;
+  runtimeRegistry: AgentRuntimeRegistry;
+  refreshPluginRuntimeRegistrations: () => void;
+  refreshConfiguredRuntimeEntries: () => void;
+  applyMcpConfig: (config: Config) => Promise<void>;
+  dispose: () => Promise<void>;
+  assetStore: LocalAssetStore;
+}): AgentRuntimeHandle;
 //#endregion
-//#region src/types/session.types.d.ts
-type SessionMessage = NcpMessage;
-type SessionRecord = {
-  id: SessionId;
-  title?: string;
-  agentId?: AgentId | null;
-  taskIds: TaskId[];
-  contextVersion: number;
-  createdAt: string;
-  updatedAt: string;
-  metadata: Record<string, unknown>;
-};
+//#region src/features/ncp-dispatch/utils/nextclaw-ncp-runner.utils.d.ts
+type AssetApi = {
+  put: (input: {
+    fileName: string;
+    mimeType?: string | null;
+    bytes: Uint8Array;
+    createdAt?: Date;
+  }) => Promise<{
+    uri: string;
+  }>;
+  resolveContentPath?: (uri: string) => string | null;
+};
+type NcpRunnerAgent = {
+  runApi: NcpAgentRunApi;
+  assetApi?: AssetApi;
+};
+type RunPromptOverNcpParams = {
+  agent: NcpRunnerAgent;
+  sessionId: string;
+  content: string;
+  attachments?: InboundAttachment[];
+  metadata?: Record<string, unknown>;
+  abortSignal?: AbortSignal;
+  onAssistantDelta?: (delta: string) => void;
+  onEvent?: (event: NcpEndpointEvent) => void;
+  missingCompletedMessageError?: string;
+  runErrorMessage?: string;
+};
+type StreamPromptOverNcpParams = Omit<RunPromptOverNcpParams, "onAssistantDelta" | "missingCompletedMessageError" | "runErrorMessage">;
+declare function buildUserMessageParts(params: {
+  content: string;
+  attachments?: InboundAttachment[];
+  assetApi?: AssetApi;
+}): Promise<NcpMessagePart[]>;
+declare function buildNcpUserMessage(params: {
+  sessionId: string;
+  content: string;
+  attachments?: InboundAttachment[];
+  metadata?: Record<string, unknown>;
+  assetApi?: AssetApi;
+}): Promise<NcpMessage>;
+declare function streamPromptOverNcp(params: StreamPromptOverNcpParams): AsyncGenerator<NcpEndpointEvent>;
+declare function runPromptOverNcp(params: RunPromptOverNcpParams): Promise<{
+  text: string;
+  completedMessage: NcpMessage;
+}>;
 //#endregion
-//#region src/managers/session.manager.d.ts
-declare class SessionManager {
-  readonly listSessions: () => never;
-  readonly getSession: (sessionId: SessionId) => never;
-  readonly requireSession: (sessionId: SessionId) => never;
-  readonly createSession: (input?: {
-    title?: string;
-    agentId?: AgentId | null;
-    metadata?: Record<string, unknown>;
-  }) => never;
-  readonly saveSession: (session: SessionRecord) => never;
-  readonly appendMessage: (sessionId: SessionId, message: SessionMessage) => never;
-  readonly attachTask: (sessionId: SessionId, taskId: TaskId) => never;
-  readonly closeSession: (sessionId: SessionId) => never;
+//#region src/features/ncp-dispatch/utils/channel-reply.utils.d.ts
+type ReplyCapableChannel = BaseChannel<Record<string, unknown>> & {
+  consumeNcpReply(input: NcpReplyInput): Promise<void>;
+};
+type ChannelReplyRoute = {
+  target: ChatTarget;
+  channel: ReplyCapableChannel;
+};
+type ResolvedInboundRoute = {
+  accountId?: string | null;
+};
+type ChannelReplyRouterDispatchParams = {
+  agent: NcpRunnerAgent;
+  route: ChannelReplyRoute;
+  sessionId: string;
+  content: string;
+  attachments?: InboundAttachment[];
+  metadata?: Record<string, unknown>;
+  abortSignal?: AbortSignal;
+  onEvent?: (event: NcpEndpointEvent) => void;
+};
+declare function isReplyCapableChannel(channel: BaseChannel<Record<string, unknown>> | null | undefined): channel is ReplyCapableChannel;
+declare function resolveChannelReplyRoute(params: {
+  channel: BaseChannel<Record<string, unknown>> | null | undefined;
+  message: InboundMessage;
+  route: ResolvedInboundRoute;
+}): ChannelReplyRoute | null;
+declare function dispatchChannelReplyRoute(params: ChannelReplyRouterDispatchParams): Promise<void>;
+//#endregion
+//#region src/features/ncp-dispatch/utils/nextclaw-ncp-dispatch.utils.d.ts
+type DirectPromptDispatchParams = {
+  config: Config;
+  sessionManager: SessionManager;
+  resolveNcpAgent?: () => NcpRunnerAgent | null;
+  content: string;
+  sessionKey?: string;
+  channel?: string;
+  chatId?: string;
+  attachments?: InboundAttachment[];
+  metadata?: Record<string, unknown>;
+  agentId?: string;
+  abortSignal?: AbortSignal;
+  onAssistantDelta?: (delta: string) => void;
+};
+type GatewayInboundLoopRuntime = {
+  kernel: {
+    channels: ChannelManager$1;
+  };
+  messageBus: MessageBus;
+  sessionManager: SessionManager;
+  configManager: {
+    loadConfig: () => Config;
+  };
+  liveAgentRuntime: NcpRunnerAgent | null;
+  appEventBus?: EventBus;
+};
+declare function dispatchPromptOverNcp(params: DirectPromptDispatchParams): Promise<string>;
+declare function runGatewayInboundLoop(runtime: GatewayInboundLoopRuntime): Promise<void>;
+//#endregion
+//#region src/types/llm-usage.types.d.ts
+type LlmUsageSummary = {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+  cachedTokens: number;
+  cacheHit: boolean;
+  cacheMetricKeys: string[];
+};
+type LlmUsageRecord = {
+  version: 1;
+  observedAt: string;
+  source: string;
+  model: string | null;
+  usage: Record<string, number>;
+  summary: LlmUsageSummary;
+};
+type LlmUsageSnapshot = LlmUsageRecord;
+declare function createLlmUsageRecord(params: {
+  observedAt?: string;
+  source: string;
+  model?: string | null;
+  usage: Record<string, number>;
+}): LlmUsageRecord;
+declare function sanitizeLlmUsage(usage: Record<string, number>): Record<string, number>;
+declare function hasLlmUsageTelemetry(usage: Record<string, number>): boolean;
+declare function buildLlmUsageSummary(usage: Record<string, number>): LlmUsageSummary;
+declare function normalizeLlmUsageModel(value: string | null | undefined): string | null;
+//#endregion
+//#region src/stores/llm-usage.store.d.ts
+type LlmUsageStoreOptions = {
+  snapshotPath?: string;
+  historyPath?: string;
+};
+declare class LlmUsageStore {
+  private readonly options;
+  constructor(options?: LlmUsageStoreOptions);
+  get snapshotPath(): string;
+  get historyPath(): string;
+  readSnapshot: () => LlmUsageRecord | null;
+  writeSnapshot: (snapshot: LlmUsageRecord) => void;
+  clearSnapshot: () => void;
+  listHistory: () => LlmUsageRecord[];
+  appendHistory: (record: LlmUsageRecord) => void;
+  clearHistory: () => void;
 }
 //#endregion
-//#region src/managers/context-builder.manager.d.ts
-declare class ContextBuilder {
-  private readonly sessions;
-  constructor(sessions: SessionManager);
-  readonly build: (input: {
-    sessionId: SessionId;
-    task?: TaskRecord | null;
-    agent: AgentRecord;
-  }) => ContextRecord;
+//#region src/managers/llm-usage.manager.d.ts
+type LlmUsageManagerOptions = {
+  store?: LlmUsageStore;
+};
+declare class LlmUsageManager {
+  private readonly store;
+  constructor(options?: LlmUsageManagerOptions);
+  observeProviderManager: (providerManager: LlmProviderRuntime, source: string) => LlmProviderRuntime;
+  record: (params: {
+    observedAt?: string;
+    source: string;
+    model?: string | null;
+    usage: Record<string, number>;
+  }) => LlmUsageRecord | null;
 }
 //#endregion
-//#region src/types/llm-provider.types.d.ts
-type LlmProviderRecord = {
-  id: LlmProviderId;
-  name: string;
-  modelIds: string[];
+//#region src/managers/agent-runtime.manager.d.ts
+type AgentRuntimeManagerOptions = {
+  bus: MessageBus;
+  providerManager: LlmProviderRuntime;
+  sessions: SessionManager;
+  ingress: Ingress;
+  sessionRequests: SessionRequestManager;
+  sessionSearch: SessionSearchManager;
+  ncpAgentSessionStore: AgentSessionStore;
+  cronService?: CronService | null;
+  configManager: {
+    loadConfig: () => Config;
+  };
+  extensions: ExtensionManager;
+  eventBus: EventBus;
+  handleNcpEvent: (event: NcpEndpointEvent) => void;
+  llmUsage: LlmUsageManager;
+  onSessionUpdated: (sessionKey: string) => void;
+};
+declare class AgentRuntimeManager {
+  private readonly params;
+  private readonly runtimeRegistry;
+  private readonly mcpRuntimeSupport;
+  private readonly assetStore;
+  private readonly pluginRuntimeRegistrationController;
+  private readonly refreshConfiguredRuntimeEntries;
+  private backend;
+  private handle;
+  private builtinNarpRegistrations;
+  private kernelBootstrapped;
+  private warmupPromise;
+  private unsubscribeNcpEvents;
+  private unsubscribeAgentRuntimeRequestIngress;
+  private gatewayController;
+  private disposed;
+  constructor(params: AgentRuntimeManagerOptions);
+  get currentHandle(): AgentRuntimeHandle | null;
+  connectGatewayController: (gatewayController: GatewayController) => void;
+  bootstrap: () => Promise<AgentRuntimeHandle>;
+  warmDerivedCapabilities: () => Promise<void>;
+  dispose: () => Promise<void>;
+  private readonly registerCoreRuntimes;
+  private runDerivedCapabilityWarmup;
+  private publishSessionRunStatus;
+  private publishNcpEvent;
+  private handleSessionMessageRequest;
+  private updateToolCallResult;
+  private readonly assertNotDisposed;
+}
+//#endregion
+//#region src/managers/automation.manager.d.ts
+type AutomationManagerOptions = {
+  storePath: string;
+};
+declare class AutomationManager extends CronService {
+  constructor(options: AutomationManagerOptions);
+}
+//#endregion
+//#region src/managers/config.manager.d.ts
+type ConfigManagerRuntimeHooks = {
+  resolveChannelConfig?: (config: Config) => Config;
+  getExtensionChannels?: () => ExtensionRegistry["channels"];
+  applyAgentRuntimeConfig?: (config: Config) => void;
+  reloadCompanion?: (params: {
+    config: Config;
+    changedPaths: string[];
+  }) => Promise<void> | void;
+  reloadMcp?: (params: {
+    config: Config;
+    changedPaths: string[];
+  }) => Promise<void> | void;
+  reloadPlugins?: (params: {
+    config: Config;
+    changedPaths: string[];
+  }) => Promise<{
+    restartChannels?: boolean;
+  } | void> | {
+    restartChannels?: boolean;
+  } | void;
+  onRestartRequired?: (paths: string[]) => void;
+};
+type ConfigManagerOptions = {
+  configPath?: string;
+  channels: ChannelManager$1;
+  providerManager: LlmProviderManager;
+};
+declare class ConfigManager {
+  private readonly options;
+  readonly configPath: string;
+  private currentConfig;
+  private hooks;
+  private reloadTask;
+  private providerReloadTask;
+  private reloadTimer;
+  private reloadRunning;
+  private reloadPending;
+  constructor(options: ConfigManagerOptions);
+  get config(): Config;
+  loadConfig: () => Config;
+  installRuntimeHooks: (hooks: ConfigManagerRuntimeHooks) => void;
+  applyLiveConfigReload: () => Promise<void>;
+  applyReloadPlan: (nextConfig: Config) => Promise<void>;
+  scheduleReload: (reason: string) => void;
+  runReload: (reason: string) => Promise<void>;
+  reloadConfig: (reason?: string) => Promise<string>;
+  rebuildChannels: (nextConfig: Config, options?: {
+    start?: boolean;
+  }) => Promise<void>;
+  private resolveChannelConfig;
+  private resolveExtensionChannels;
+  private reloadProvider;
+  private reloadPlugins;
+  private reloadMcp;
+  private reloadCompanion;
+}
+//#endregion
+//#region src/configs/learning-loop.config.d.ts
+declare const LEARNING_LOOP_DISABLED_METADATA_KEY = "learning_loop_disabled";
+declare const LEARNING_LOOP_LAST_TOOL_CALL_COUNT_METADATA_KEY = "learning_loop_last_tool_call_count";
+declare const LEARNING_LOOP_LAST_REQUESTED_AT_METADATA_KEY = "learning_loop_last_requested_at";
+declare const LEARNING_LOOP_LAST_REVIEW_SESSION_ID_METADATA_KEY = "learning_loop_last_review_session_id";
+declare const LEARNING_LOOP_SOURCE_SESSION_ID_METADATA_KEY = "learning_loop_source_session_id";
+declare const LEARNING_LOOP_REQUESTED_SKILLS: string[];
+declare const DEFAULT_LEARNING_LOOP_TOOL_CALL_THRESHOLD = 15;
+type LearningLoopRuntimeConfig = {
   enabled: boolean;
-  metadata: Record<string, unknown>;
+  toolCallThreshold: number;
 };
+declare function readLearningLoopRuntimeConfig(config: Config): LearningLoopRuntimeConfig;
 //#endregion
-//#region src/managers/llm-provider.manager.d.ts
-declare class LlmProviderManager {
-  readonly listProviders: () => never;
-  readonly getProvider: (providerId: LlmProviderId) => never;
-  readonly requireProvider: (providerId: LlmProviderId) => never;
-  readonly saveProvider: (provider: LlmProviderRecord) => never;
-  readonly enableProvider: (providerId: LlmProviderId) => never;
-  readonly disableProvider: (providerId: LlmProviderId) => never;
-  readonly selectProvider: (input: {
-    agent: AgentRecord;
-    context: ContextRecord;
-  }) => never;
+//#region src/managers/learning-loop.manager.d.ts
+type LearningLoopSessionRequester = {
+  spawnSessionAndRequest: (params: SpawnSessionAndRequestParams) => Promise<SessionRequestToolResult>;
+};
+type LearningLoopManagerOptions = {
+  eventBus: EventBus;
+  sessionManager: SessionManager;
+  sessionRequester: LearningLoopSessionRequester;
+  resolveLearningLoopConfig?: () => LearningLoopRuntimeConfig;
+};
+declare class LearningLoopManager {
+  private readonly options;
+  private readonly sessionStore;
+  private readonly inFlightSessionIds;
+  private unsubscribe;
+  constructor(options: LearningLoopManagerOptions);
+  start: () => void;
+  dispose: () => void;
+  private handleRunFinished;
+  private handleRunFinishedInBackground;
+  private readRuntimeConfig;
+  private buildReviewTitle;
 }
 //#endregion
 //#region src/types/skill.types.d.ts
@@ -191,32 +622,13 @@ type SkillRecord = {
 //#endregion
 //#region src/managers/skill.manager.d.ts
 declare class SkillManager {
-  readonly listSkills: () => never;
-  readonly getSkill: (skillId: SkillId) => never;
-  readonly requireSkill: (skillId: SkillId) => never;
-  readonly saveSkill: (skill: SkillRecord) => never;
-  readonly enableSkill: (skillId: SkillId) => never;
-  readonly disableSkill: (skillId: SkillId) => never;
-  readonly resolveSkills: (skillIds: SkillId[]) => never;
-}
-//#endregion
-//#region src/managers/task.manager.d.ts
-declare class TaskManager {
-  readonly listTasks: () => never;
-  readonly getTask: (taskId: TaskId) => never;
-  readonly requireTask: (taskId: TaskId) => never;
-  readonly createTask: (input: {
-    title: string;
-    agentId: AgentId;
-    sessionId: SessionId;
-    input: unknown;
-    metadata?: Record<string, unknown>;
-  }) => never;
-  readonly saveTask: (task: TaskRecord) => never;
-  readonly updateTaskStatus: (taskId: TaskId, status: TaskStatus) => never;
-  readonly completeTask: (taskId: TaskId, output: unknown) => never;
-  readonly failTask: (taskId: TaskId, error: string) => never;
-  readonly cancelTask: (taskId: TaskId) => never;
+  listSkills: () => never;
+  getSkill: (skillId: SkillId) => never;
+  requireSkill: (skillId: SkillId) => never;
+  saveSkill: (skill: SkillRecord) => never;
+  enableSkill: (skillId: SkillId) => never;
+  disableSkill: (skillId: SkillId) => never;
+  resolveSkills: (skillIds: SkillId[]) => never;
 }
 //#endregion
 //#region src/types/tool.types.d.ts
@@ -231,32 +643,41 @@ type ToolRecord = {
 //#endregion
 //#region src/managers/tool.manager.d.ts
 declare class ToolManager {
-  readonly listTools: () => never;
-  readonly getTool: (toolId: ToolId) => never;
-  readonly requireTool: (toolId: ToolId) => never;
-  readonly saveTool: (tool: ToolRecord) => never;
-  readonly enableTool: (toolId: ToolId) => never;
-  readonly disableTool: (toolId: ToolId) => never;
-  readonly resolveTools: (toolIds: ToolId[]) => never;
+  listTools: () => never;
+  getTool: (toolId: ToolId) => never;
+  requireTool: (toolId: ToolId) => never;
+  saveTool: (tool: ToolRecord) => never;
+  enableTool: (toolId: ToolId) => never;
+  disableTool: (toolId: ToolId) => never;
+  resolveTools: (toolIds: ToolId[]) => never;
 }
 //#endregion
-//#region src/types/nextclaw-kernel.types.d.ts
-type NextclawKernelRunMetadata = {
-  agentId?: AgentId;
-  model?: string;
-  skills?: SkillId[];
-};
-type NextclawKernelRunInput = {
-  sessionId: SessionId;
-  messages: NcpMessage[];
-  metadata?: NextclawKernelRunMetadata;
-  extra?: Record<string, unknown>;
-};
-type NextclawKernelRun = {
-  taskId: TaskId;
-};
+//#region src/services/ncp-session-api.service.d.ts
+type NcpSessionApiServiceOptions = {
+  eventBus: EventBus;
+  getConfig: () => Config;
+  sessionManager: SessionManager;
+};
+declare class NcpSessionApiService implements NcpSessionApi {
+  private readonly options;
+  private unsubscribeSessionUpdated;
+  private readonly contextWindowPreview;
+  constructor(options: NcpSessionApiServiceOptions);
+  start: () => void;
+  dispose: () => void;
+  publishSessionChange: (sessionKey: string) => Promise<void>;
+  listSessions: (options?: ListSessionsOptions) => Promise<NcpSessionSummary[]>;
+  listSessionMessages: (sessionId: string, options?: ListMessagesOptions) => Promise<NcpMessage[]>;
+  getSession: (sessionId: string) => Promise<NcpSessionSummary | null>;
+  updateSession: (sessionId: string, patch: NcpSessionPatch) => Promise<NcpSessionSummary | null>;
+  deleteSession: (sessionId: string) => Promise<void>;
+}
 //#endregion
 //#region src/app/nextclaw-kernel.d.ts
+type NextclawKernelOptions = {
+  homeDir?: string;
+  configPath?: string;
+};
 type NextclawKernelRuntimeControl<TGatewayInput, TUiInput, TStartInput> = {
   gateway: (input: TGatewayInput) => Promise<void>;
   ui: (input: TUiInput) => Promise<void>;
@@ -267,173 +688,278 @@ type NextclawKernelRuntimeControl<TGatewayInput, TUiInput, TStartInput> = {
 };
 declare class NextclawKernelControlManager<TGatewayInput, TUiInput, TStartInput> {
   private runtimeControl;
-  readonly installRuntimeControl: (runtimeControl: NextclawKernelRuntimeControl<TGatewayInput, TUiInput, TStartInput>) => void;
-  readonly requireRuntimeControl: () => NextclawKernelRuntimeControl<TGatewayInput, TUiInput, TStartInput>;
+  installRuntimeControl: (runtimeControl: NextclawKernelRuntimeControl<TGatewayInput, TUiInput, TStartInput>) => void;
+  requireRuntimeControl: () => NextclawKernelRuntimeControl<TGatewayInput, TUiInput, TStartInput>;
 }
-declare class NextclawKernel<TGatewayInput = unknown, TUiInput = unknown, TStartInput = unknown> {
+declare class NextclawKernel {
+  readonly eventBus: EventBus;
+  readonly ingress: Ingress;
+  readonly messageBus: MessageBus;
+  readonly llmProviders: LlmProviderManager;
+  readonly llmUsage: LlmUsageManager;
+  readonly configManager: ConfigManager;
   readonly agents: AgentManager;
-  readonly tasks: TaskManager;
   readonly sessions: SessionManager;
-  readonly contextBuilder: ContextBuilder;
-  readonly control: NextclawKernelControlManager<TGatewayInput, TUiInput, TStartInput>;
+  readonly control: NextclawKernelControlManager<unknown, unknown, unknown>;
   readonly tools: ToolManager;
   readonly skills: SkillManager;
-  readonly llmProviders: LlmProviderManager;
   readonly automation: AutomationManager;
-  readonly channels: ChannelManager;
-  readonly run: (input: NextclawKernelRunInput) => NextclawKernelRun;
+  readonly channels: ChannelManager$1;
+  readonly sessionRequests: SessionRequestManager;
+  readonly sessionSearch: SessionSearchManager;
+  readonly ncpSessionApi: NcpSessionApiService;
+  readonly extensions: ExtensionManager;
+  readonly agentRuntimeManager: AgentRuntimeManager;
+  readonly learningLoop: LearningLoopManager;
+  private readonly sessionLifecycleEvents;
+  private readonly ncpAgentSessionStore;
+  private startPromise;
+  constructor(options?: NextclawKernelOptions);
+  start: () => Promise<void>;
+  dispose: () => Promise<void>;
+  private publishSessionUpdated;
+  private handleNcpEvent;
 }
 //#endregion
-//#region src/events/event-bus.types.d.ts
-type AppEventKey<T> = {
-  readonly id: string;
-  readonly _type?: T;
-};
-type AppEventSource = "backend" | "realtime" | "local";
-type AppEventEnvelope<T = unknown> = {
-  type: string;
-  payload: T;
-  emittedAt?: string;
-  source?: AppEventSource;
-};
-type AppEventEmitOptions = {
-  emittedAt?: string;
-  source?: AppEventSource;
-};
-type AppEventHandler<T> = (payload: T, envelope: AppEventEnvelope<T>) => void;
-type EventBusOptions = {
-  onFirstSubscriber?: () => void;
-  onListenerError?: (params: {
-    type: string;
-    payload: unknown;
-    error: unknown;
-  }) => void;
-  onNoSubscribers?: () => void;
-};
-type ConfigUpdatedEvent = AppEventEnvelope<{
-  path: string;
-}> & {
-  type: "config.updated";
-};
-type ChannelConfigApplyStatusEvent = AppEventEnvelope<{
+//#region src/utils/learning-loop-prompt.utils.d.ts
+declare function buildLearningLoopTask(params: {
+  sessionId: string;
+  toolCallsSinceReview: number;
+  currentToolCallCount: number;
+}): string;
+//#endregion
+//#region src/features/narp-runtime/services/builtin-narp-runtime-registration.service.d.ts
+declare const NARP_HTTP_RUNTIME_KIND = "narp-http";
+declare const NARP_STDIO_RUNTIME_KIND = "narp-stdio";
+declare class BuiltinNarpRuntimeRegistrationService {
+  private readonly getConfig;
+  constructor(getConfig: () => Config);
+  registerInto: (runtimeRegistry: AgentRuntimeRegistry) => Disposable[];
+  private createUnavailableRuntime;
+  private createHttpRuntime;
+  private createStdioRuntime;
+}
+//#endregion
+//#region src/features/native-runtime/services/context-compaction-preflight.service.d.ts
+type ContextWindowOwner = "nextclaw" | "runtime";
+type ContextCompactionPreflightResult = {
+  contextWindow: ContextWindowSnapshot;
+  metadata: Record<string, unknown>;
+  sessionMessages: NcpMessage[];
+  timelineMessage: NcpMessage | null;
+};
+type ContextCompactionPreflightBeginResult = ContextCompactionPreflightResult & {
+  pendingCompaction: ContextCompactionPendingWork | null;
+};
+type ContextCompactionPendingWork = {
+  checkpoint: ReturnType<typeof buildCompressingCompactionCheckpoint>;
+  contextTokens: number;
+  inputMessageIds: string[];
+  model: string;
+  plan: ContextCompactionPlan;
+  reservedContextTokens: number;
+  sessionId: string;
+};
+declare class ContextCompactionPreflightService {
+  private readonly options;
+  private readonly compactionService;
+  private readonly contextWindowBudgetService;
+  constructor(options: {
+    getConfig: () => Config;
+    providerManager?: LlmProviderRuntime;
+    sessionManager: SessionManager;
+  });
+  run: (params: {
+    contextWindowOwner: ContextWindowOwner;
+    inputMessages: readonly NcpMessage[];
+    requestMetadata: Record<string, unknown>;
+    sessionId: string;
+    sessionMessages: readonly NcpMessage[];
+  }) => Promise<ContextCompactionPreflightResult | null>;
+  preview: (params: {
+    contextWindowOwner: ContextWindowOwner;
+    requestMetadata: Record<string, unknown>;
+    sessionId: string;
+    sessionMessages: readonly NcpMessage[];
+  }) => ContextWindowSnapshot | null;
+  begin: (params: {
+    contextWindowOwner: ContextWindowOwner;
+    inputMessages: readonly NcpMessage[];
+    requestMetadata: Record<string, unknown>;
+    sessionId: string;
+    sessionMessages: readonly NcpMessage[];
+  }) => ContextCompactionPreflightBeginResult | null;
+  private buildContextWindowSnapshotForMessages;
+  finish: (pending: ContextCompactionPendingWork) => Promise<ContextCompactionPreflightResult>;
+  private generateSummary;
+}
+//#endregion
+//#region src/features/native-runtime/services/native-agent-runtime-factory.service.d.ts
+type NativeRuntimeFactory = (runtimeParams: RuntimeFactoryParams) => NcpAgentRuntime;
+type UpdateToolCallResult = (params: {
+  sessionId: string;
+  toolCallId: string;
+  result: unknown;
+}) => Promise<void>;
+type NativeAgentRuntimeFactoryOptions = {
+  bus: MessageBus;
+  providerManager: LlmProviderRuntime;
+  sessions: SessionManager;
+  sessionRequests: SessionRequestManager;
+  sessionSearch: SessionSearchManager;
+  cronService?: CronService | null;
+  configManager: {
+    loadConfig: () => Config;
+  };
+  extensions: ExtensionManager;
+  llmUsage: LlmUsageManager;
+  onSessionUpdated: (sessionKey: string) => void;
+  resolveGatewayController: () => GatewayController | undefined;
+  mcpToolRegistryAdapter: McpNcpToolRegistryAdapter;
+  assetStore: LocalAssetStore;
+  updateToolCallResult: UpdateToolCallResult;
+};
+declare class NativeAgentRuntimeFactory {
+  private readonly options;
+  private readonly observedProviderManager;
+  constructor(options: NativeAgentRuntimeFactoryOptions);
+  create: NativeRuntimeFactory;
+  resolveOpenAiToolsForRuntime: (input: NcpAgentRunInput) => _$_nextclaw_ncp0.OpenAITool[] | undefined;
+  private createToolRegistry;
+}
+//#endregion
+//#region src/features/native-runtime/services/nextclaw-ncp-tool-registry.service.d.ts
+type NextclawNcpToolRegistryOptions = {
+  bus: MessageBus;
+  providerManager: LlmProviderRuntime;
+  sessionManager: SessionManager;
+  cronService?: CronService | null;
+  gatewayController?: GatewayController;
+  getConfig: () => Config;
+  getExtensionRegistry?: () => ExtensionRegistry | undefined;
+  getAdditionalTools?: (context: PreparedRunContext) => ReadonlyArray<NcpTool>;
+  onSessionUpdated?: (sessionKey: string) => void;
+  sessionRequestManager: SessionRequestManager;
+  updateToolCallResult: (params: {
+    sessionId: string;
+    toolCallId: string;
+    result: unknown;
+  }) => Promise<void>;
+};
+type PreparedRunContext = {
+  agentId: string;
   channel: string;
-  status: "started" | "succeeded" | "failed";
-  message?: string;
-}> & {
-  type: "channel.config.apply-status";
-};
-type SessionUpdatedEvent = AppEventEnvelope<{
-  sessionKey: string;
-}> & {
-  type: "session.updated";
-};
-type SessionRunStatusEvent = AppEventEnvelope<{
-  sessionKey: string;
-  status: "running" | "idle";
-}> & {
-  type: "session.run-status";
-};
-type SessionSummaryUpsertEvent = AppEventEnvelope<{
-  summary: NcpSessionSummary;
-}> & {
-  type: "session.summary.upsert";
-};
-type SessionSummaryDeleteEvent = AppEventEnvelope<{
+  chatId: string;
+  config: Config;
+  contextTokens: number;
+  execTimeoutSeconds: number;
+  handoffDepth: number;
+  maxTokens?: number;
+  metadata: Record<string, unknown>;
+  model: string;
+  restrictToWorkspace: boolean;
+  searchConfig: SearchConfig;
+  sessionId: string;
+  workspace: string;
+};
+declare class NextclawNcpToolRegistry implements NcpToolRegistry {
+  private readonly options;
+  private registry;
+  private readonly tools;
+  private currentExtensionToolContext;
+  constructor(options: NextclawNcpToolRegistryOptions);
+  prepareForRun: (context: PreparedRunContext) => void;
+  listTools: () => ReadonlyArray<NcpTool>;
+  getTool: (name: string) => NcpTool | undefined;
+  getToolDefinitions: () => ReadonlyArray<NcpToolDefinition>;
+  execute: (toolCallId: string, toolName: string, args: unknown) => Promise<unknown>;
+  private buildToolExecutionContext;
+  private registerDefaultTools;
+  private registerMessagingTools;
+  private registerExtensionTools;
+  private registerTool;
+  private registerAdditionalTools;
+  private isToolAvailable;
+}
+declare function resolveAgentHandoffDepth(metadata: Record<string, unknown>): number;
+declare function readAccountIdForHints(metadata: Record<string, unknown>, sessionMetadata: Record<string, unknown>): string | undefined;
+//#endregion
+//#region src/features/native-runtime/services/nextclaw-ncp-context-builder.service.d.ts
+type MessageToolHintsResolver = (params: {
   sessionKey: string;
-}> & {
-  type: "session.summary.delete";
-};
-type ConfigReloadStartedEvent = AppEventEnvelope<Record<string, unknown> | undefined> & {
-  type: "config.reload.started";
-};
-type ConfigReloadFinishedEvent = AppEventEnvelope<Record<string, unknown> | undefined> & {
-  type: "config.reload.finished";
-};
-type ErrorEvent = AppEventEnvelope<{
-  message: string;
-  code?: string;
-}> & {
-  type: "error";
-};
-type ConnectionOpenEvent = AppEventEnvelope<Record<string, never> | undefined> & {
-  type: "connection.open";
-};
-type ConnectionCloseEvent = AppEventEnvelope<Record<string, never> | undefined> & {
-  type: "connection.close";
-};
-type ConnectionErrorEvent = AppEventEnvelope<{
-  message?: string;
-} | undefined> & {
-  type: "connection.error";
-};
-type RuntimeUpdateSnapshotEvent = AppEventEnvelope<UpdateSnapshot> & {
-  type: "runtime.update.snapshot";
-};
-type AppEvent = ConfigUpdatedEvent | ChannelConfigApplyStatusEvent | SessionUpdatedEvent | SessionRunStatusEvent | SessionSummaryUpsertEvent | SessionSummaryDeleteEvent | ConfigReloadStartedEvent | ConfigReloadFinishedEvent | ErrorEvent | ConnectionOpenEvent | ConnectionCloseEvent | ConnectionErrorEvent | RuntimeUpdateSnapshotEvent;
-//#endregion
-//#region src/events/event-bus.service.d.ts
-declare class EventBus {
-  private readonly listeners;
-  private readonly globalListeners;
-  private listenerCount;
-  private readonly onFirstSubscriber?;
-  private readonly onListenerError?;
-  private readonly onNoSubscribers?;
-  constructor(options?: EventBusOptions);
-  emit: <T>(key: AppEventKey<T>, payload: T, options?: AppEventEmitOptions) => void;
-  emitEnvelope: <T>(event: AppEventEnvelope<T>) => void;
-  on: <T>(key: AppEventKey<T>, handler: AppEventHandler<T>) => (() => void);
-  off: <T>(key: AppEventKey<T>, handler: AppEventHandler<T>) => void;
-  once: <T>(key: AppEventKey<T>, handler: AppEventHandler<T>) => (() => void);
-  subscribeAll: (handler: (event: AppEventEnvelope) => void) => (() => void);
-  private registerSubscriber;
-  private unregisterSubscriber;
-  private safeInvokeListener;
-  private safeInvokeGlobalListener;
+  channel: string;
+  chatId: string;
+  accountId?: string | null;
+}) => string[];
+type NextclawNcpContextBuilderOptions = {
+  sessionManager: SessionManager;
+  toolRegistry: NextclawNcpToolRegistry;
+  getConfig: () => Config;
+  resolveMessageToolHints?: MessageToolHintsResolver;
+  assetStore?: LocalAssetStore | null;
+};
+declare class NextclawNcpContextBuilder implements NcpContextBuilder {
+  private readonly options;
+  private readonly inputBudgetPruner;
+  constructor(options: NextclawNcpContextBuilderOptions);
+  prepare: (input: NcpAgentRunInput, _options?: NcpContextPrepareOptions) => NcpLLMApiInput;
+  private prepareRunContext;
+  private buildModelMessages;
+  private pruneModelMessages;
 }
 //#endregion
-//#region src/app/nextclaw-app.service.d.ts
-type NextClawApp = {
-  readonly eventBus: EventBus;
-};
-declare const nextclaw: NextClawApp;
+//#region src/features/native-runtime/services/provider-manager-ncp-llm-api.service.d.ts
+declare class ProviderManagerNcpLLMApi implements NcpLLMApi {
+  private readonly providerManager;
+  constructor(providerManager: LlmProviderRuntime);
+  readonly generate: (this: ProviderManagerNcpLLMApi, input: NcpLLMApiInput, options?: NcpLLMApiOptions) => AsyncGenerator<OpenAIChatChunk>;
+}
 //#endregion
-//#region src/events/event-keys.config.d.ts
-declare function createAppEventKey<T>(id: string): AppEventKey<T>;
-declare const eventKeys: {
-  readonly configUpdated: AppEventKey<{
-    path: string;
-  }>;
-  readonly channelConfigApplyStatus: AppEventKey<{
-    channel: string;
-    status: "started" | "succeeded" | "failed";
-    message?: string;
-  }>;
-  readonly sessionUpdated: AppEventKey<{
-    sessionKey: string;
-  }>;
-  readonly sessionRunStatus: AppEventKey<{
-    sessionKey: string;
-    status: "running" | "idle";
-  }>;
-  readonly sessionSummaryUpsert: AppEventKey<{
-    summary: NcpSessionSummary;
-  }>;
-  readonly sessionSummaryDelete: AppEventKey<{
-    sessionKey: string;
-  }>;
-  readonly configReloadStarted: AppEventKey<Record<string, unknown> | undefined>;
-  readonly configReloadFinished: AppEventKey<Record<string, unknown> | undefined>;
-  readonly error: AppEventKey<{
-    message: string;
-    code?: string;
-  }>;
-  readonly connectionOpen: AppEventKey<Record<string, never> | undefined>;
-  readonly connectionClose: AppEventKey<Record<string, never> | undefined>;
-  readonly connectionError: AppEventKey<{
-    message?: string;
-  } | undefined>;
-  readonly runtimeUpdateSnapshot: AppEventKey<UpdateSnapshot>;
-};
+//#region src/features/native-runtime/tools/ncp-asset.tools.d.ts
+declare function createAssetTools(params: {
+  assetStore: LocalAssetStore;
+  contentBasePath?: string;
+}): NcpTool[];
+//#endregion
+//#region src/features/session-request/utils/agent-runtime-session-request-dispatcher.utils.d.ts
+declare const AGENT_RUNTIME_SESSION_MESSAGE_INGRESS_TYPE: _$_nextclaw_shared0.TypedKey<AgentRuntimeSessionMessageRequest>;
+type AgentRuntimeSessionMessageRequest = {
+  message: NcpMessage;
+  requestId: string;
+  sessionId: string;
+};
+type AgentRuntimeSessionRequestDispatcherOptions = {
+  eventBus: EventBus;
+  ingress: Ingress;
+};
+declare function waitForAgentRuntimeSessionReply(input: {
+  eventBus: EventBus;
+  onAccepted: (messageId: string) => void;
+  requestId: string;
+}): {
+  dispose: Unsubscribe;
+  promise: Promise<NcpMessage>;
+};
+declare function dispatchAgentRuntimeSessionRequest(input: {
+  ingress: Ingress;
+  request: SessionRequestRecord;
+  task: string;
+}): Promise<void>;
+declare function createAgentRuntimeSessionRequestDispatcher(options: AgentRuntimeSessionRequestDispatcherOptions): SessionRequestDispatcher;
+//#endregion
+//#region src/utils/ncp-session-summary.utils.d.ts
+declare function createNcpSessionSummary(params: {
+  sessionId: string;
+  agentId?: string;
+  messages: readonly NcpMessage[];
+  updatedAt: string;
+  status: NcpSessionStatus;
+  metadata?: Record<string, unknown>;
+  contextWindow?: Record<string, unknown> | null;
+}): NcpSessionSummary;
+//#endregion
+//#region src/utils/ncp-session-message-adapter.utils.d.ts
+declare function toNcpMessages(sessionId: string, messages: SessionMessage[]): NcpMessage[];
+declare function resolveLegacyEventType(message: SessionMessage): string;
 //#endregion
-export { AgentId, AgentManager, AgentRecord, type AppEvent, type AppEventEmitOptions, type AppEventEnvelope, type AppEventHandler, type AppEventKey, type AppEventSource, AutomationId, AutomationManager, AutomationRecord, AutomationTrigger, type ChannelConfigApplyStatusEvent, ChannelDirection, ChannelId, ChannelManager, ChannelRecord, type ConfigReloadFinishedEvent, type ConfigReloadStartedEvent, type ConfigUpdatedEvent, type ConnectionCloseEvent, type ConnectionErrorEvent, type ConnectionOpenEvent, ContextBuilder, ContextRecord, type ErrorEvent, EventBus, type EventBusOptions, InstallationKind, LlmProviderId, LlmProviderManager, LlmProviderRecord, NextClawApp, NextclawKernel, NextclawKernelRun, NextclawKernelRunInput, NextclawKernelRunMetadata, type RuntimeUpdateSnapshotEvent, SessionId, SessionManager, SessionMessage, SessionRecord, type SessionRunStatusEvent, type SessionSummaryDeleteEvent, type SessionSummaryUpsertEvent, type SessionUpdatedEvent, SkillId, SkillManager, SkillRecord, TaskId, TaskManager, TaskRecord, TaskStatus, ToolId, ToolManager, ToolRecord, UnsignedUpdateManifest, UpdateBlockReason, UpdateHostKind, UpdateManifest, UpdateManifestReader, UpdatePreferences, UpdateProgress, UpdateSnapshot, UpdateStatus, createAppEventKey, eventKeys, getUnsignedUpdateManifest, nextclaw, serializeUnsignedUpdateManifest };
+export { AGENT_RUNTIME_SESSION_MESSAGE_INGRESS_TYPE, AgentId, AgentManager, AgentRecord, AgentRuntimeContribution, AgentRuntimeEndpoint, AgentRuntimeEntry, type AgentRuntimeHandle, AgentRuntimeManager, AgentRuntimeManagerOptions, AgentRuntimeProviderRegistration, AgentRuntimeRegistry, AgentRuntimeSessionMessageRequest, AgentRuntimeSessionRequestDispatcherOptions, AgentRuntimeSessionTypeDescribeParams, AgentRuntimeSessionTypeIcon, AgentRuntimeSessionTypeOption, AutomationId, AutomationManager, AutomationManagerOptions, BuiltinNarpRuntimeRegistrationService, ChannelId, ChannelManager, ChannelReplyRouterDispatchParams, ConfigManager, ConfigManagerOptions, ConfigManagerRuntimeHooks, ContextCompactionPendingWork, ContextCompactionPreflightBeginResult, ContextCompactionPreflightResult, ContextCompactionPreflightService, ContextWindowOwner, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_LEARNING_LOOP_TOOL_CALL_THRESHOLD, DirectPromptDispatchParams, ExtensionContributions, ExtensionManager, GatewayInboundLoopRuntime, InstallationKind, LEARNING_LOOP_DISABLED_METADATA_KEY, LEARNING_LOOP_LAST_REQUESTED_AT_METADATA_KEY, LEARNING_LOOP_LAST_REVIEW_SESSION_ID_METADATA_KEY, LEARNING_LOOP_LAST_TOOL_CALL_COUNT_METADATA_KEY, LEARNING_LOOP_REQUESTED_SKILLS, LEARNING_LOOP_SOURCE_SESSION_ID_METADATA_KEY, LearningLoopManager, LearningLoopManagerOptions, LearningLoopRuntimeConfig, LearningLoopSessionRequester, LlmProviderManager, LlmProviderRuntime, LlmUsageManager, LlmUsageManagerOptions, LlmUsageRecord, LlmUsageSnapshot, LlmUsageStore, LlmUsageStoreOptions, LlmUsageSummary, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NativeAgentRuntimeFactory, NativeAgentRuntimeFactoryOptions, NativeRuntimeFactory, NcpRunnerAgent, NcpSessionApiService, NcpSessionApiServiceOptions, NextclawExtensionRegistry, NextclawKernel, NextclawKernelOptions, NextclawNcpContextBuilder, NextclawNcpToolRegistry, PluginRuntimeRegistrationController, ProviderManagerNcpLLMApi, RunPromptOverNcpParams, SessionId, SkillId, SkillManager, SkillRecord, StreamPromptOverNcpParams, TaskId, ToolId, ToolManager, ToolRecord, UnsignedUpdateManifest, UpdateBlockReason, UpdateHostKind, UpdateManifest, UpdateManifestReader, UpdatePreferences, UpdateProgress, UpdateSnapshot, UpdateStatus, UpdateToolCallResult, buildLearningLoopTask, buildLlmUsageSummary, buildNcpUserMessage, buildUserMessageParts, createAgentRuntimeHandle, createAgentRuntimeSessionRequestDispatcher, createAssetTools, createLlmUsageRecord, createNcpSessionSummary, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, getUnsignedUpdateManifest, hasLlmUsageTelemetry, isReplyCapableChannel, normalizeAgentRuntimeSessionTypeIcon, normalizeLlmUsageModel, readAccountIdForHints, readLearningLoopRuntimeConfig, resolveAgentHandoffDepth, resolveAgentRuntimeEntries, resolveChannelReplyRoute, resolveLegacyEventType, runGatewayInboundLoop, runPromptOverNcp, sanitizeLlmUsage, serializeUnsignedUpdateManifest, streamPromptOverNcp, toNcpMessages, waitForAgentRuntimeSessionReply };