@byfriends/agent-core 0.1.0

package/dist/index-BUBoyyCX.d.mts

@@ -0,0 +1,3987 @@
+import { ChatProvider, ContentPart, FinishReason, Message, ModelCapability, ProviderConfig, ProviderRequestAuth, TextPart, ThinkPart, ThinkingEffort, TokenUsage, Tool, ToolCall, ToolCall as ToolCall$1, generate } from "@byfriends/kosong";
+import { z } from "zod";
+import { OAuthClientProvider, OAuthDiscoveryState } from "@modelcontextprotocol/sdk/client/auth.js";
+import { Kaos, KaosProcess } from "@byfriends/kaos";
+import { ActivateSkillPayload, AgentAPI, AgentEvent, SDKAgentRPC, SDKSessionRPC, UsageStatus } from "#/rpc";
+import { OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+import { ByfConfig, ByfConfigPatch, OAuthRef } from "#/config";
+import { AgentType } from "#/agent";
+import { AgentConfigData, AgentConfigUpdateData } from "#/agent/config";
+import { AgentContextData, ContextMessage } from "#/agent/context";
+import { PermissionApprovalResultRecord, PermissionData, PermissionMode } from "#/agent/permission";
+import { PlanData } from "#/agent/plan";
+import { ToolInfo } from "#/agent/tool";
+import { SessionMeta } from "#/session";
+import { BackgroundTaskInfo } from "#/tools/builtin";
+
+//#region src/logging/types.d.ts
+type LogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug';
+type LogContext = Record<string, unknown>;
+/**
+ * Second argument to `log.error / warn / info / debug`.
+ *
+ * Three usage shapes, detected at runtime:
+ *   - `Error`     → stack is extracted onto the entry
+ *   - `LogContext` (object) → merged into entry context; if it contains
+ *                              `{ error: Error }`, that field is pulled out
+ *                              and its stack extracted (bunyan-style)
+ *   - `unknown`   → typically a `catch` binding; treated as an Error if
+ *                   it's an Error instance, otherwise stringified into a
+ *                   `reason` field
+ */
+type LogPayload = unknown;
+interface Logger {
+  error(message: string, payload?: LogPayload): void;
+  warn(message: string, payload?: LogPayload): void;
+  info(message: string, payload?: LogPayload): void;
+  debug(message: string, payload?: LogPayload): void;
+  /**
+   * Returns a new logger that adds `ctx` to every entry it emits. The bound
+   * context wins over per-call payload context, so callers can't accidentally
+   * overwrite ownership fields like `sessionId` / `agentId`:
+   *
+   *   finalCtx = { ...payloadCtx, ...boundCtx }
+   *
+   * Children chain — `parent.createChild({a: 1}).createChild({b: 2})` binds
+   * both.
+   */
+  createChild(ctx: LogContext): Logger;
+}
+interface LogEntry {
+  readonly t: number;
+  readonly level: Exclude<LogLevel, 'off'>;
+  readonly msg: string;
+  readonly ctx?: LogContext | undefined;
+  readonly error?: {
+    readonly message: string;
+    readonly stack?: string;
+  } | undefined;
+  readonly sessionId?: string | undefined;
+  readonly sessionLogId?: string | undefined;
+}
+interface LoggingConfig {
+  readonly level: LogLevel;
+  readonly globalLogPath: string;
+  readonly globalMaxBytes: number;
+  readonly globalFiles: number;
+  readonly sessionMaxBytes: number;
+  readonly sessionFiles: number;
+}
+interface SessionLogHandle {
+  readonly logger: Logger;
+  flush(): Promise<void>;
+  close(): Promise<void>;
+}
+interface SessionAttachInput {
+  readonly sessionId: string;
+  readonly sessionDir: string;
+}
+interface RootLogger {
+  configure(config: LoggingConfig): Promise<void>;
+  attachSession(input: SessionAttachInput): SessionLogHandle;
+  /** False if any sink could not flush its pending batch. */
+  flush(): Promise<boolean>;
+  /** False if the global sink could not flush; true when there is no global sink. */
+  flushGlobal(): Promise<boolean>;
+  /** False if the session sink could not flush; true when there is no active sink. */
+  flushSession(sessionId: string): Promise<boolean>;
+  flushSync(): void;
+  isConfigured(): boolean;
+  getConfig(): LoggingConfig | undefined;
+}
+//#endregion
+//#region src/config/schema.d.ts
+declare const ProviderTypeSchema: z.ZodEnum<{
+  anthropic: "anthropic";
+  openai: "openai";
+  "openai-compat": "openai-compat";
+  "google-genai": "google-genai";
+  openai_responses: "openai_responses";
+  vertexai: "vertexai";
+}>;
+type ProviderType = z.infer<typeof ProviderTypeSchema>;
+declare const OAuthRefSchema: z.ZodObject<{
+  storage: z.ZodEnum<{
+    file: "file";
+    keyring: "keyring";
+  }>;
+  key: z.ZodString;
+}, z.core.$strip>;
+type OAuthRef$1 = z.infer<typeof OAuthRefSchema>;
+declare const ProviderConfigSchema: z.ZodObject<{
+  type: z.ZodEnum<{
+    anthropic: "anthropic";
+    openai: "openai";
+    "openai-compat": "openai-compat";
+    "google-genai": "google-genai";
+    openai_responses: "openai_responses";
+    vertexai: "vertexai";
+  }>;
+  apiKey: z.ZodOptional<z.ZodString>;
+  baseUrl: z.ZodOptional<z.ZodString>;
+  defaultModel: z.ZodOptional<z.ZodString>;
+  thinkingEffortKey: z.ZodOptional<z.ZodString>;
+  oauth: z.ZodOptional<z.ZodObject<{
+    storage: z.ZodEnum<{
+      file: "file";
+      keyring: "keyring";
+    }>;
+    key: z.ZodString;
+  }, z.core.$strip>>;
+  env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type ProviderConfig$1 = z.infer<typeof ProviderConfigSchema>;
+declare const ModelAliasSchema: z.ZodObject<{
+  provider: z.ZodString;
+  model: z.ZodString;
+  maxContextSize: z.ZodNumber;
+  maxOutputSize: z.ZodOptional<z.ZodNumber>;
+  capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  displayName: z.ZodOptional<z.ZodString>;
+  reasoningKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ModelAlias = z.infer<typeof ModelAliasSchema>;
+declare const ThinkingConfigSchema: z.ZodObject<{
+  mode: z.ZodOptional<z.ZodEnum<{
+    off: "off";
+    auto: "auto";
+    on: "on";
+  }>>;
+  effort: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ThinkingConfig = z.infer<typeof ThinkingConfigSchema>;
+declare const PermissionModeSchema: z.ZodEnum<{
+  auto: "auto";
+  yolo: "yolo";
+  manual: "manual";
+}>;
+declare const PermissionRuleDecisionSchema: z.ZodEnum<{
+  allow: "allow";
+  deny: "deny";
+  ask: "ask";
+}>;
+declare const PermissionRuleScopeSchema: z.ZodEnum<{
+  "turn-override": "turn-override";
+  "session-runtime": "session-runtime";
+  project: "project";
+  user: "user";
+}>;
+declare const PermissionRuleSchema: z.ZodObject<{
+  decision: z.ZodEnum<{
+    allow: "allow";
+    deny: "deny";
+    ask: "ask";
+  }>;
+  scope: z.ZodDefault<z.ZodEnum<{
+    "turn-override": "turn-override";
+    "session-runtime": "session-runtime";
+    project: "project";
+    user: "user";
+  }>>;
+  pattern: z.ZodString;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const PermissionConfigSchema: z.ZodObject<{
+  rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    decision: z.ZodEnum<{
+      allow: "allow";
+      deny: "deny";
+      ask: "ask";
+    }>;
+    scope: z.ZodDefault<z.ZodEnum<{
+      "turn-override": "turn-override";
+      "session-runtime": "session-runtime";
+      project: "project";
+      user: "user";
+    }>>;
+    pattern: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type PermissionConfig = z.infer<typeof PermissionConfigSchema>;
+declare const LoopControlSchema: z.ZodObject<{
+  maxStepsPerTurn: z.ZodOptional<z.ZodNumber>;
+  maxRetriesPerStep: z.ZodOptional<z.ZodNumber>;
+  maxRalphIterations: z.ZodOptional<z.ZodNumber>;
+  reservedContextSize: z.ZodOptional<z.ZodNumber>;
+  compactionTriggerRatio: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type LoopControl = z.infer<typeof LoopControlSchema>;
+declare const BackgroundConfigSchema: z.ZodObject<{
+  maxRunningTasks: z.ZodOptional<z.ZodNumber>;
+  keepAliveOnExit: z.ZodOptional<z.ZodBoolean>;
+  killGracePeriodMs: z.ZodOptional<z.ZodNumber>;
+  agentTaskTimeoutS: z.ZodOptional<z.ZodNumber>;
+  printWaitCeilingS: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type BackgroundConfig = z.infer<typeof BackgroundConfigSchema>;
+declare const HookDefSchema: z.ZodObject<{
+  event: z.ZodEnum<{
+    PreToolUse: "PreToolUse";
+    PostToolUse: "PostToolUse";
+    PostToolUseFailure: "PostToolUseFailure";
+    UserPromptSubmit: "UserPromptSubmit";
+    Stop: "Stop";
+    StopFailure: "StopFailure";
+    SessionStart: "SessionStart";
+    SessionEnd: "SessionEnd";
+    SubagentStart: "SubagentStart";
+    SubagentStop: "SubagentStop";
+    PreCompact: "PreCompact";
+    PostCompact: "PostCompact";
+    Notification: "Notification";
+  }>;
+  matcher: z.ZodOptional<z.ZodString>;
+  command: z.ZodString;
+  timeout: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type HookDefConfig = z.infer<typeof HookDefSchema>;
+declare const ByfServiceConfigSchema: z.ZodObject<{
+  baseUrl: z.ZodOptional<z.ZodString>;
+  apiKey: z.ZodOptional<z.ZodString>;
+  oauth: z.ZodOptional<z.ZodObject<{
+    storage: z.ZodEnum<{
+      file: "file";
+      keyring: "keyring";
+    }>;
+    key: z.ZodString;
+  }, z.core.$strip>>;
+  customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type ByfServiceConfig = z.infer<typeof ByfServiceConfigSchema>;
+declare const ServicesConfigSchema: z.ZodObject<{
+  byfSearch: z.ZodOptional<z.ZodObject<{
+    baseUrl: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    oauth: z.ZodOptional<z.ZodObject<{
+      storage: z.ZodEnum<{
+        file: "file";
+        keyring: "keyring";
+      }>;
+      key: z.ZodString;
+    }, z.core.$strip>>;
+    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  }, z.core.$strip>>;
+  byfFetch: z.ZodOptional<z.ZodObject<{
+    baseUrl: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    oauth: z.ZodOptional<z.ZodObject<{
+      storage: z.ZodEnum<{
+        file: "file";
+        keyring: "keyring";
+      }>;
+      key: z.ZodString;
+    }, z.core.$strip>>;
+    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ServicesConfig = z.infer<typeof ServicesConfigSchema>;
+declare const McpServerStdioConfigSchema: z.ZodObject<{
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+  toolTimeoutMs: z.ZodOptional<z.ZodNumber>;
+  enabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  disabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  transport: z.ZodLiteral<"stdio">;
+  command: z.ZodString;
+  args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  cwd: z.ZodOptional<z.ZodString>;
+  executor: z.ZodOptional<z.ZodEnum<{
+    local: "local";
+    kaos: "kaos";
+  }>>;
+}, z.core.$strip>;
+type McpServerStdioConfig = z.infer<typeof McpServerStdioConfigSchema>;
+declare const McpServerHttpConfigSchema: z.ZodObject<{
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+  toolTimeoutMs: z.ZodOptional<z.ZodNumber>;
+  enabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  disabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  transport: z.ZodLiteral<"http">;
+  url: z.ZodString;
+  headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  bearerTokenEnvVar: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type McpServerHttpConfig = z.infer<typeof McpServerHttpConfigSchema>;
+declare const McpServerConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+  toolTimeoutMs: z.ZodOptional<z.ZodNumber>;
+  enabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  disabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  transport: z.ZodLiteral<"stdio">;
+  command: z.ZodString;
+  args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  cwd: z.ZodOptional<z.ZodString>;
+  executor: z.ZodOptional<z.ZodEnum<{
+    local: "local";
+    kaos: "kaos";
+  }>>;
+}, z.core.$strip>, z.ZodObject<{
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+  toolTimeoutMs: z.ZodOptional<z.ZodNumber>;
+  enabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  disabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  transport: z.ZodLiteral<"http">;
+  url: z.ZodString;
+  headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  bearerTokenEnvVar: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "transport">>;
+type McpServerConfig = z.infer<typeof McpServerConfigSchema>;
+declare const ByfConfigSchema: z.ZodObject<{
+  providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodEnum<{
+      anthropic: "anthropic";
+      openai: "openai";
+      "openai-compat": "openai-compat";
+      "google-genai": "google-genai";
+      openai_responses: "openai_responses";
+      vertexai: "vertexai";
+    }>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    defaultModel: z.ZodOptional<z.ZodString>;
+    thinkingEffortKey: z.ZodOptional<z.ZodString>;
+    oauth: z.ZodOptional<z.ZodObject<{
+      storage: z.ZodEnum<{
+        file: "file";
+        keyring: "keyring";
+      }>;
+      key: z.ZodString;
+    }, z.core.$strip>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  }, z.core.$strip>>>;
+  defaultProvider: z.ZodOptional<z.ZodString>;
+  defaultModel: z.ZodOptional<z.ZodString>;
+  models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+    maxContextSize: z.ZodNumber;
+    maxOutputSize: z.ZodOptional<z.ZodNumber>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    displayName: z.ZodOptional<z.ZodString>;
+    reasoningKey: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  thinking: z.ZodOptional<z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+      off: "off";
+      auto: "auto";
+      on: "on";
+    }>>;
+    effort: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  planMode: z.ZodOptional<z.ZodBoolean>;
+  yolo: z.ZodOptional<z.ZodBoolean>;
+  defaultThinking: z.ZodOptional<z.ZodBoolean>;
+  defaultPermissionMode: z.ZodOptional<z.ZodEnum<{
+    auto: "auto";
+    yolo: "yolo";
+    manual: "manual";
+  }>>;
+  defaultPlanMode: z.ZodOptional<z.ZodBoolean>;
+  permission: z.ZodOptional<z.ZodObject<{
+    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        ask: "ask";
+      }>;
+      scope: z.ZodDefault<z.ZodEnum<{
+        "turn-override": "turn-override";
+        "session-runtime": "session-runtime";
+        project: "project";
+        user: "user";
+      }>>;
+      pattern: z.ZodString;
+      reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>;
+  hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    event: z.ZodEnum<{
+      PreToolUse: "PreToolUse";
+      PostToolUse: "PostToolUse";
+      PostToolUseFailure: "PostToolUseFailure";
+      UserPromptSubmit: "UserPromptSubmit";
+      Stop: "Stop";
+      StopFailure: "StopFailure";
+      SessionStart: "SessionStart";
+      SessionEnd: "SessionEnd";
+      SubagentStart: "SubagentStart";
+      SubagentStop: "SubagentStop";
+      PreCompact: "PreCompact";
+      PostCompact: "PostCompact";
+      Notification: "Notification";
+    }>;
+    matcher: z.ZodOptional<z.ZodString>;
+    command: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>>;
+  services: z.ZodOptional<z.ZodObject<{
+    byfSearch: z.ZodOptional<z.ZodObject<{
+      baseUrl: z.ZodOptional<z.ZodString>;
+      apiKey: z.ZodOptional<z.ZodString>;
+      oauth: z.ZodOptional<z.ZodObject<{
+        storage: z.ZodEnum<{
+          file: "file";
+          keyring: "keyring";
+        }>;
+        key: z.ZodString;
+      }, z.core.$strip>>;
+      customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    byfFetch: z.ZodOptional<z.ZodObject<{
+      baseUrl: z.ZodOptional<z.ZodString>;
+      apiKey: z.ZodOptional<z.ZodString>;
+      oauth: z.ZodOptional<z.ZodObject<{
+        storage: z.ZodEnum<{
+          file: "file";
+          keyring: "keyring";
+        }>;
+        key: z.ZodString;
+      }, z.core.$strip>>;
+      customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  mergeAllAvailableSkills: z.ZodOptional<z.ZodBoolean>;
+  extraSkillDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  loopControl: z.ZodOptional<z.ZodObject<{
+    maxStepsPerTurn: z.ZodOptional<z.ZodNumber>;
+    maxRetriesPerStep: z.ZodOptional<z.ZodNumber>;
+    maxRalphIterations: z.ZodOptional<z.ZodNumber>;
+    reservedContextSize: z.ZodOptional<z.ZodNumber>;
+    compactionTriggerRatio: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  background: z.ZodOptional<z.ZodObject<{
+    maxRunningTasks: z.ZodOptional<z.ZodNumber>;
+    keepAliveOnExit: z.ZodOptional<z.ZodBoolean>;
+    killGracePeriodMs: z.ZodOptional<z.ZodNumber>;
+    agentTaskTimeoutS: z.ZodOptional<z.ZodNumber>;
+    printWaitCeilingS: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  telemetry: z.ZodOptional<z.ZodBoolean>;
+  raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ByfConfig$1 = z.infer<typeof ByfConfigSchema>;
+declare const ByfConfigPatchSchema: z.ZodObject<{
+  providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodOptional<z.ZodEnum<{
+      anthropic: "anthropic";
+      openai: "openai";
+      "openai-compat": "openai-compat";
+      "google-genai": "google-genai";
+      openai_responses: "openai_responses";
+      vertexai: "vertexai";
+    }>>;
+    apiKey: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    baseUrl: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    defaultModel: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    thinkingEffortKey: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    oauth: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+      storage: z.ZodEnum<{
+        file: "file";
+        keyring: "keyring";
+      }>;
+      key: z.ZodString;
+    }, z.core.$strip>>>;
+    env: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    customHeaders: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+  }, z.core.$strip>>>;
+  defaultProvider: z.ZodOptional<z.ZodString>;
+  defaultModel: z.ZodOptional<z.ZodString>;
+  models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    maxContextSize: z.ZodOptional<z.ZodNumber>;
+    maxOutputSize: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    capabilities: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    displayName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    reasoningKey: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  }, z.core.$strip>>>;
+  thinking: z.ZodOptional<z.ZodObject<{
+    mode: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+      off: "off";
+      auto: "auto";
+      on: "on";
+    }>>>;
+    effort: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  }, z.core.$strip>>;
+  planMode: z.ZodOptional<z.ZodBoolean>;
+  yolo: z.ZodOptional<z.ZodBoolean>;
+  defaultThinking: z.ZodOptional<z.ZodBoolean>;
+  defaultPermissionMode: z.ZodOptional<z.ZodEnum<{
+    auto: "auto";
+    yolo: "yolo";
+    manual: "manual";
+  }>>;
+  defaultPlanMode: z.ZodOptional<z.ZodBoolean>;
+  permission: z.ZodOptional<z.ZodObject<{
+    rules: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+      decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        ask: "ask";
+      }>;
+      scope: z.ZodDefault<z.ZodEnum<{
+        "turn-override": "turn-override";
+        "session-runtime": "session-runtime";
+        project: "project";
+        user: "user";
+      }>>;
+      pattern: z.ZodString;
+      reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+  }, z.core.$strip>>;
+  hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    event: z.ZodEnum<{
+      PreToolUse: "PreToolUse";
+      PostToolUse: "PostToolUse";
+      PostToolUseFailure: "PostToolUseFailure";
+      UserPromptSubmit: "UserPromptSubmit";
+      Stop: "Stop";
+      StopFailure: "StopFailure";
+      SessionStart: "SessionStart";
+      SessionEnd: "SessionEnd";
+      SubagentStart: "SubagentStart";
+      SubagentStop: "SubagentStop";
+      PreCompact: "PreCompact";
+      PostCompact: "PostCompact";
+      Notification: "Notification";
+    }>;
+    matcher: z.ZodOptional<z.ZodString>;
+    command: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>>;
+  services: z.ZodOptional<z.ZodObject<{
+    byfSearch: z.ZodOptional<z.ZodObject<{
+      baseUrl: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+      apiKey: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+      oauth: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        storage: z.ZodEnum<{
+          file: "file";
+          keyring: "keyring";
+        }>;
+        key: z.ZodString;
+      }, z.core.$strip>>>;
+      customHeaders: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    }, z.core.$strip>>;
+    byfFetch: z.ZodOptional<z.ZodObject<{
+      baseUrl: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+      apiKey: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+      oauth: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        storage: z.ZodEnum<{
+          file: "file";
+          keyring: "keyring";
+        }>;
+        key: z.ZodString;
+      }, z.core.$strip>>>;
+      customHeaders: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  mergeAllAvailableSkills: z.ZodOptional<z.ZodBoolean>;
+  extraSkillDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  loopControl: z.ZodOptional<z.ZodObject<{
+    maxStepsPerTurn: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    maxRetriesPerStep: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    maxRalphIterations: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    reservedContextSize: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    compactionTriggerRatio: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+  }, z.core.$strip>>;
+  background: z.ZodOptional<z.ZodObject<{
+    maxRunningTasks: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    keepAliveOnExit: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    killGracePeriodMs: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    agentTaskTimeoutS: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    printWaitCeilingS: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+  }, z.core.$strip>>;
+  telemetry: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type ByfConfigPatch$1 = z.infer<typeof ByfConfigPatchSchema>;
+declare function getDefaultConfig(): ByfConfig$1;
+declare function validateConfig(config: unknown): ByfConfig$1;
+declare function formatConfigValidationError(error: unknown): string;
+//#endregion
+//#region src/mcp/oauth/store.d.ts
+declare class JsonFileStore {
+  private readonly dir;
+  constructor(dir?: string);
+  read<T>(file: string): T | undefined;
+  write(file: string, data: unknown): void;
+  remove(file: string): void;
+}
+//#endregion
+//#region src/mcp/oauth/provider.d.ts
+interface McpOAuthProviderOptions {
+  /** Friendly name of the MCP server; used in DCR `client_name`. */
+  readonly serverName: string;
+  /** Canonical resource identity used to isolate credentials for this server entry. */
+  readonly serverUrl: string | URL;
+  /** JSON store used for persistence. Tests inject an in-memory dir. */
+  readonly store: JsonFileStore;
+  /** Identifier embedded in DCR `client_name` ("byf (server)"). */
+  readonly clientLabel?: string;
+}
+declare class McpOAuthClientProvider implements OAuthClientProvider {
+  readonly storeKey: string;
+  readonly serverUrl: string;
+  private readonly store;
+  private readonly clientLabel;
+  private _redirectUrl;
+  private _codeVerifier;
+  private _state;
+  private _lastAuthorizationUrl;
+  constructor(options: McpOAuthProviderOptions);
+  setRedirectUrl(url: URL): void;
+  /** URL captured from the most recent `redirectToAuthorization` call. */
+  takeAuthorizationUrl(): URL | undefined;
+  /** OAuth `state` value generated for the most recent flow, for callback verification. */
+  expectedState(): string | undefined;
+  resetFlow(): void;
+  get redirectUrl(): string | URL;
+  get clientMetadata(): OAuthClientMetadata;
+  state(): string;
+  clientInformation(): OAuthClientInformationMixed | undefined;
+  saveClientInformation(info: OAuthClientInformationMixed): void;
+  tokens(): OAuthTokens | undefined;
+  saveTokens(tokens: OAuthTokens): void;
+  redirectToAuthorization(url: URL): void;
+  saveCodeVerifier(codeVerifier: string): void;
+  codeVerifier(): string;
+  saveDiscoveryState(state: OAuthDiscoveryState): void;
+  discoveryState(): OAuthDiscoveryState | undefined;
+  invalidateCredentials(scope: 'all' | 'client' | 'tokens' | 'verifier' | 'discovery'): void;
+  private effectiveRedirectUri;
+}
+//#endregion
+//#region src/mcp/oauth/service.d.ts
+interface McpOAuthServiceOptions {
+  /** Storage backend; overrides `byfHomeDir` when supplied. */
+  readonly store?: JsonFileStore;
+  /** Resolved Byf home; credentials default to `<byfHomeDir>/credentials/mcp/`. */
+  readonly byfHomeDir?: string;
+  /** Override for the label embedded in DCR `client_name`. */
+  readonly clientLabel?: string;
+}
+interface BeginAuthorizationOptions {
+  /** Override the `client_name` embedded in the DCR registration request. */
+  readonly clientLabel?: string;
+}
+interface BeginAuthorizationResult {
+  /** The authorization URL the user must open in their browser. */
+  readonly authorizationUrl: URL;
+  /**
+   * Awaits the OAuth callback, validates `state`, exchanges the code for
+   * tokens, and persists them via the provider. Resolves on success;
+   * rejects on abort, timeout, or auth-server error.
+   */
+  complete(opts?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+  }): Promise<void>;
+  /**
+   * Tears down the callback listener without finishing the flow. Safe to
+   * call repeatedly; called automatically by `complete()`.
+   */
+  cancel(): Promise<void>;
+}
+declare class McpOAuthService {
+  private readonly store;
+  private readonly clientLabel;
+  private readonly providers;
+  constructor(options?: McpOAuthServiceOptions);
+  /** Returns the cached provider for `serverName` + `serverUrl`, constructing it on first use. */
+  getProvider(serverName: string, serverUrl: string | URL): McpOAuthClientProvider;
+  /** True once the provider has persisted tokens for this server/resource identity. */
+  hasTokens(serverName: string, serverUrl: string | URL): boolean;
+  /**
+   * Drive the SDK `auth()` orchestrator far enough to surface an
+   * authorization URL. The caller is responsible for displaying the URL
+   * (typically via the synthetic authenticate tool) and then awaiting
+   * `complete()` to finish the code exchange.
+   */
+  beginAuthorization(serverName: string, serverUrl: string | URL, options?: BeginAuthorizationOptions): Promise<BeginAuthorizationResult>;
+  /**
+   * Clear stored credentials for a server. Use `'all'` after the user
+   * explicitly signs out; use `'tokens'` to force a re-auth while keeping
+   * the registered DCR client.
+   */
+  invalidate(serverName: string, serverUrl: string | URL, scope?: 'all' | 'client' | 'tokens' | 'discovery'): void;
+}
+//#endregion
+//#region src/mcp/types.d.ts
+/**
+ * MCP protocol types and the minimal client contract `ToolManager` consumes.
+ *
+ * Lives in its own file (rather than `toolset.ts`) because the agent-side
+ * tool-runtime layer is `ExecutableTool`, not the legacy `Toolset` interface.
+ * What remains here is the wire-level surface: tool definitions returned by
+ * `tools/list`, the `tools/call` result shape, and the small interface that
+ * lets tests inject a fake transport without pulling in the MCP SDK type graph.
+ */
+/**
+ * Inline resource contents nested under an EmbeddedResource block.
+ * Exactly one of `text` or `blob` is populated, per the MCP schema's
+ * `TextResourceContents | BlobResourceContents` union.
+ */
+interface MCPEmbeddedResourceContents {
+  uri: string;
+  mimeType?: string;
+  text?: string;
+  blob?: string;
+  [key: string]: unknown;
+}
+/**
+ * A content block as returned by an MCP tool call (`tools/call`).
+ *
+ * This is a structural subset of the MCP protocol `ContentBlock` union,
+ * covering the shapes that {@link convertMCPContentBlock} knows how to convert
+ * into kosong `ContentPart`s. Additional fields are ignored.
+ */
+interface MCPContentBlock {
+  type: string;
+  text?: string;
+  data?: string;
+  mimeType?: string;
+  uri?: string;
+  resource?: MCPEmbeddedResourceContents;
+  [key: string]: unknown;
+}
+/**
+ * Result of a single MCP tool invocation.
+ *
+ * Matches the shape returned by the MCP protocol's `tools/call` method.
+ */
+interface MCPToolResult {
+  content: MCPContentBlock[];
+  isError: boolean;
+}
+/**
+ * An MCP tool definition as returned by an MCP server's `tools/list` method.
+ */
+interface MCPToolDefinition {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+}
+/**
+ * Minimal MCP client interface consumed by {@link McpConnectionManager} and
+ * {@link ToolManager}.
+ *
+ * This is a transport-agnostic seam: implementations can wrap
+ * `@modelcontextprotocol/sdk`, a bespoke stdio client, an HTTP SSE client,
+ * or a mock for testing. Keeping the surface small lets tests inject fakes
+ * without pulling in the full SDK type graph.
+ */
+interface MCPClient {
+  /** List the tools advertised by the MCP server. */
+  listTools(): Promise<MCPToolDefinition[]>;
+  /**
+   * Invoke a tool by name with the given JSON arguments.
+   *
+   * `signal`, when provided, is forwarded to the underlying transport so an
+   * abort from the loop (e.g. user cancellation) propagates all the way to
+   * the server instead of leaving the request running in the background.
+   */
+  callTool(name: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<MCPToolResult>;
+}
+//#endregion
+//#region src/mcp/connection-manager.d.ts
+type McpServerStatus = 'pending' | 'connected' | 'failed' | 'disabled' | 'needs-auth';
+interface McpServerEntry {
+  readonly name: string;
+  readonly transport: 'stdio' | 'http';
+  readonly status: McpServerStatus;
+  readonly toolCount: number;
+  readonly error?: string;
+}
+type McpStatusListener = (entry: McpServerEntry) => void;
+interface McpConnectionManagerOptions {
+  readonly envLookup?: (name: string) => string | undefined;
+  /**
+   * Optional OAuth orchestrator. When provided, HTTP servers without a
+   * static bearer token participate in the OAuth-via-synthetic-tool flow:
+   *  - If `oauthService.hasTokens(name, url)` is true, the provider is
+   *    attached to the transport so the SDK can refresh tokens on 401.
+   *  - Connection failures that look like 401 / `UnauthorizedError` flip
+   *    the entry into `needs-auth` instead of `failed`; `/mcp-config`
+   *    drives the browser flow through the synthetic auth tool.
+   */
+  readonly oauthService?: McpOAuthService;
+  /**
+   * Parent logger. Defaults to the global `log`; Session passes its own
+   * `session.log` so MCP events land in the session log too.
+   */
+  readonly log?: Logger;
+}
+/**
+ * Owns the lifecycle of every configured MCP server for a Session.
+ *
+ * Servers are connected in parallel; per-server failures are isolated so a
+ * crashed or misconfigured entry never blocks Session startup. State
+ * transitions are surfaced through {@link onStatusChange} so callers (the
+ * Session) can react — registering tools onto the main agent, emitting
+ * wire events, or updating the TUI.
+ */
+declare class McpConnectionManager {
+  private readonly options;
+  private readonly entries;
+  private readonly listeners;
+  private initialLoad;
+  private initialLoadAttemptId;
+  private initialLoadStartedAt;
+  private initialLoadFinishedAt;
+  /**
+   * OAuth orchestrator injected at construction time. Consumed by the
+   * {@link ToolManager} `needs-auth` branch to build the synthetic
+   * `authenticate` tool.
+   */
+  readonly oauthService: McpOAuthService | undefined;
+  private readonly log;
+  constructor(options?: McpConnectionManagerOptions);
+  /**
+   * Returns the URL of an HTTP MCP server by name, or `undefined` for
+   * unknown / non-HTTP / disabled entries. Used by the synthetic auth tool
+   * to drive OAuth discovery against the right base URL.
+   */
+  getHttpServerUrl(name: string): string | undefined;
+  onStatusChange(listener: McpStatusListener): () => void;
+  list(): readonly McpServerEntry[];
+  get(name: string): McpServerEntry | undefined;
+  /**
+   * Returns the MCP client, the discovered tools, and the allow-list of tool
+   * names for a given connected server, or `undefined` if the server is not
+   * currently connected. The allow-list combines the server's `enabledTools`
+   * and `disabledTools` filters; callers should only register names in the
+   * set.
+   */
+  resolved(name: string): {
+    client: MCPClient;
+    tools: readonly Tool[];
+    enabledNames: ReadonlySet<string>;
+  } | undefined;
+  connectAll(configs: Record<string, McpServerConfig>): Promise<void>;
+  waitForInitialLoad(signal?: AbortSignal): Promise<void>;
+  initialLoadDurationMs(): number;
+  private connectAllNow;
+  reconnect(name: string): Promise<void>;
+  shutdown(): Promise<void>;
+  private connectOne;
+  private watchForUnexpectedClose;
+  private beginConnectAttempt;
+  private createClient;
+  private resolveOAuthProvider;
+  private shouldMarkNeedsAuth;
+  private connectAndDiscoverTools;
+  private closeClient;
+  private closeRuntimeClient;
+  private isCurrent;
+  private emit;
+}
+//#endregion
+//#region src/mcp/session-config.d.ts
+interface SessionMcpConfig {
+  readonly servers: Record<string, McpServerConfig>;
+}
+//#endregion
+//#region src/skill/types.d.ts
+type SkillSource = 'project' | 'user' | 'extra' | 'builtin';
+interface SkillMetadata {
+  readonly name?: string | undefined;
+  readonly description?: string | undefined;
+  readonly type?: string | undefined;
+  readonly whenToUse?: string | undefined;
+  readonly disableModelInvocation?: boolean | undefined;
+  readonly safe?: boolean | undefined;
+  readonly arguments?: readonly unknown[] | string | undefined;
+  readonly [key: string]: unknown;
+}
+interface SkillDefinition {
+  readonly name: string;
+  readonly description: string;
+  readonly path: string;
+  readonly dir: string;
+  readonly content: string;
+  readonly metadata: SkillMetadata;
+  readonly source: SkillSource;
+  readonly mermaid?: string | undefined;
+  readonly d2?: string;
+}
+interface SkillSummary$1 {
+  readonly name: string;
+  readonly description: string;
+  readonly path: string;
+  readonly source: SkillSource;
+  readonly type?: string | undefined;
+  readonly disableModelInvocation?: boolean | undefined;
+}
+interface SkillRoot {
+  readonly path: string;
+  readonly source: SkillSource;
+}
+interface SkippedSkill {
+  readonly path: string;
+  readonly type: string;
+  readonly reason: string;
+}
+//#endregion
+//#region src/skill/scanner.d.ts
+interface DiscoverSkillsOptions {
+  readonly roots: readonly SkillRoot[];
+  readonly onWarning?: (message: string, cause?: unknown) => void;
+  readonly onSkippedByPolicy?: (skill: SkippedSkill) => void;
+  readonly readdir?: (p: string) => Promise<readonly string[]>;
+  readonly isFile?: (p: string) => Promise<boolean>;
+  readonly isDir?: (p: string) => Promise<boolean>;
+  readonly parse?: (input: {
+    readonly skillMdPath: string;
+    readonly skillDirName: string;
+    readonly source: SkillSource;
+  }) => Promise<SkillDefinition>;
+}
+declare function discoverSkills(options: DiscoverSkillsOptions): Promise<readonly SkillDefinition[]>;
+//#endregion
+//#region src/skill/registry.d.ts
+interface SkillRegistryOptions {
+  readonly discover?: typeof discoverSkills;
+  readonly onWarning?: (message: string, cause?: unknown) => void;
+  readonly sessionId?: string;
+}
+declare class SkillRegistry {
+  private readonly byName;
+  private readonly roots;
+  private readonly skipped;
+  private readonly discoverImpl;
+  private readonly onWarning;
+  readonly sessionId?: string;
+  constructor(options?: SkillRegistryOptions);
+  loadRoots(roots: readonly SkillRoot[]): Promise<void>;
+  registerBuiltinSkill(skill: SkillDefinition): void;
+  register(skill: SkillDefinition, options?: {
+    readonly replace?: boolean;
+  }): void;
+  getSkill(name: string): SkillDefinition | undefined;
+  renderSkillPrompt(skill: SkillDefinition, rawArgs: string): string;
+  listSkills(): readonly SkillDefinition[];
+  listInvocableSkills(): readonly SkillDefinition[];
+  getSkillRoots(): readonly string[];
+  getSkippedByPolicy(): readonly SkippedSkill[];
+  getByfSkillsDescription(): string;
+  getModelSkillListing(): string;
+}
+//#endregion
+//#region src/utils/environment.d.ts
+/**
+ * Environment — cross-platform probe of OS / shell.
+ *
+ * Detection is a pure function of injected probes (`platform` / `arch` /
+ * `release` / `env` / `isFile` / `findExecutable`) so the same suite runs
+ * identically on any host OS. `detectEnvironmentFromNode()` bundles the
+ * Node defaults for production callers.
+ *
+ * On Windows the probe expects Git Bash (the canonical POSIX shell that
+ * ships with Git for Windows). If it cannot be located the function
+ * throws `ByfError` with code `shell.git_bash_not_found`; the SDK layer
+ * can wrap that into a user-facing install hint. Set `BYF_SHELL_PATH`
+ * to override.
+ */
+type OsKind = string;
+type ShellName = 'bash' | 'sh';
+interface Environment {
+  readonly osKind: OsKind;
+  readonly osArch: string;
+  readonly osVersion: string;
+  readonly shellName: ShellName;
+  readonly shellPath: string;
+}
+//#endregion
+//#region src/profile/types.d.ts
+/**
+ * Runtime context supplied to a system prompt renderer.
+ *
+ * Captures everything determined at render time rather than at profile-load
+ * time: the OS/shell, working directory, AGENTS.md instructions, available
+ * skills, and so on. Loaders return renderers; callers invoke them with
+ * the live context whenever a concrete prompt is needed.
+ */
+interface SystemPromptContext {
+  readonly osEnv: Environment;
+  readonly cwd: string;
+  readonly now?: string | Date;
+  readonly cwdListing?: string;
+  readonly agentsMd?: string;
+  readonly skills?: SkillRegistry | string;
+  readonly additionalDirsInfo?: string;
+  readonly roleAdditional?: string;
+}
+type SystemPromptRenderer = (context: SystemPromptContext) => string;
+interface ResolvedAgentProfile {
+  name: string;
+  description?: string;
+  systemPrompt: SystemPromptRenderer;
+  tools: string[];
+  whenToUse?: string;
+  subagents?: Record<string, ResolvedAgentProfile>;
+}
+//#endregion
+//#region src/profile/context.d.ts
+type PreparedSystemPromptContext = Pick<SystemPromptContext, 'cwd' | 'cwdListing' | 'agentsMd'>;
+//#endregion
+//#region src/config/merge.d.ts
+declare function mergeConfigPatch(config: ByfConfig$1, patch: ByfConfigPatch$1): ByfConfig$1;
+//#endregion
+//#region src/config/path.d.ts
+declare function resolveByfHome(homeDir?: string | undefined): string;
+declare function resolveConfigPath(input: {
+  readonly homeDir?: string | undefined;
+  readonly configPath?: string | undefined;
+}): string;
+declare function ensureByfHome(homeDir: string): void;
+//#endregion
+//#region src/config/resolve.d.ts
+interface ResolveConfigValueInput<T> {
+  readonly env?: Readonly<Record<string, string | undefined>>;
+  readonly envKey: string;
+  readonly configValue?: T;
+  readonly defaultValue: T;
+  readonly parseEnv: (value: string | undefined) => T | undefined;
+}
+declare function resolveConfigValue<T>(input: ResolveConfigValueInput<T>): T;
+declare function parseBooleanEnv(value: string | undefined): boolean | undefined;
+//#endregion
+//#region src/config/toml.d.ts
+declare function ensureConfigFile(filePath: string): Promise<void>;
+declare function readConfigFile(filePath: string): ByfConfig$1;
+declare function parseConfigString(tomlText: string, filePath?: string): ByfConfig$1;
+declare function transformTomlData(data: Record<string, unknown>): Record<string, unknown>;
+declare function writeConfigFile(filePath: string, config: ByfConfig$1): Promise<void>;
+declare function configToTomlData(config: ByfConfig$1): Record<string, unknown>;
+//#endregion
+//#region src/providers/request-auth.d.ts
+interface ProviderRequestAuthOptions {
+  readonly forceRefresh?: boolean;
+}
+type ProviderRequestAuthResolver = (options?: ProviderRequestAuthOptions) => Promise<ProviderRequestAuth>;
+//#endregion
+//#region src/providers/runtime-provider.d.ts
+interface BearerTokenProvider {
+  getAccessToken(options?: {
+    readonly force?: boolean | undefined;
+  }): Promise<string>;
+}
+type OAuthTokenProviderResolver = (providerName: string, oauthRef?: OAuthRef | undefined) => BearerTokenProvider | undefined;
+interface ResolvedRuntimeProvider {
+  readonly modelName: string;
+  readonly providerName?: string | undefined;
+  readonly provider: ProviderConfig;
+  readonly modelCapabilities: ModelCapability;
+  readonly resolveAuth?: ProviderRequestAuthResolver;
+}
+//#endregion
+//#region src/providers/provider-manager.d.ts
+interface ProviderManagerOptions {
+  readonly config: ByfConfig$1;
+  readonly byfRequestHeaders?: Record<string, string> | undefined;
+  readonly resolveOAuthTokenProvider?: OAuthTokenProviderResolver | undefined;
+  readonly promptCacheKey?: string;
+}
+declare class ProviderManager {
+  private readonly options;
+  private readonly state;
+  constructor(options: ProviderManagerOptions, state?: ProviderManagerState);
+  get config(): ByfConfig$1;
+  get providers(): ByfConfig$1['providers'];
+  get models(): NonNullable<ByfConfig$1['models']>;
+  updateConfig(config: ByfConfig$1): void;
+  withPromptCacheKey(promptCacheKey?: string): ProviderManager;
+  resolveProviderConfigForModel(model: string | undefined, options?: {
+    readonly promptCacheKey?: string;
+  }): ResolvedRuntimeProvider | undefined;
+  resolveProviderForModel(model: string | undefined): Promise<ResolvedRuntimeProvider | undefined>;
+  createAuthResolverForModel(model: string | undefined, options?: {
+    readonly log?: Logger;
+  }): ProviderRequestAuthResolver | undefined;
+  resolveThinkingLevel(requestedThinking?: string): ThinkingEffort;
+  resolveSelectedModel(requestedModel: string | undefined): string | undefined;
+}
+interface ProviderManagerState {
+  config: ByfConfig$1;
+}
+//#endregion
+//#region src/tools/background/manager.d.ts
+/**
+ * `'lost'` is a reconcile-only terminal state. Tasks loaded from disk
+ * that were marked `running` at startup but have no live KaosProcess
+ * (the previous CLI process died) are reclassified as lost.
+ *
+ * `'awaiting_approval'` is a non-terminal state entered when a background
+ * agent task is paused waiting for tool-call approval from the root
+ * agent. The BPM state machine is the single source of truth for "is
+ * this task actively running vs. gated on approval" — UI reads from BPM
+ * instead of reverse-querying the ApprovalRuntime. The loop boundary is
+ * preserved because `awaiting_approval` in BPM does not leak permission
+ * vocabulary into the loop.
+ */
+type BackgroundTaskStatus = 'running' | 'awaiting_approval' | 'completed' | 'failed' | 'killed' | 'lost';
+/** Task kinds with distinct id prefixes. */
+type BackgroundTaskKind = 'bash' | 'agent';
+/** Lifecycle phases observed by `onLifecycle` subscribers. */
+type BackgroundLifecycleEvent = 'started' | 'updated' | 'terminated';
+interface BackgroundTaskInfo$1 {
+  readonly taskId: string;
+  readonly command: string;
+  readonly description: string;
+  readonly status: BackgroundTaskStatus;
+  readonly pid: number;
+  readonly exitCode: number | null;
+  readonly startedAt: number;
+  readonly endedAt: number | null;
+  /** Populated only while `status === 'awaiting_approval'`. */
+  readonly approvalReason?: string | undefined;
+  /** True when an agent task was aborted by its deadline. */
+  readonly timedOut?: boolean | undefined;
+  /** Reason recorded when a task is explicitly stopped. */
+  readonly stopReason?: string | undefined;
+  /**
+   * Deadline (ms) supplied to `registerAgentTask`. Surfaced so shutdown
+   * wait-caps and UI can read the originally-requested timeout without
+   * round-tripping the call site. `undefined` means no deadline.
+   */
+  readonly timeoutMs?: number | undefined;
+  /** Identifier of the spawned subagent (agent tasks only). */
+  readonly agentId?: string | undefined;
+  /** Profile name of the spawned subagent (agent tasks only). */
+  readonly subagentType?: string | undefined;
+  /**
+   * Human-readable reason recorded when a non-terminal task is reclassified
+   * via reconcile (e.g. a stale heartbeat → lost).
+   */
+  readonly failureReason?: string | undefined;
+}
+/**
+ * Terminal-state info for tasks reconciled as lost on resume. They
+ * have no live KaosProcess and no captured output (the buffer died
+ * with the previous process), so list/get returns this minimal record.
+ */
+interface ReconcileResult {
+  /** Task IDs that were marked `lost` because their process is gone. */
+  readonly lost: readonly string[];
+  /** Snapshot of each lost task's persisted info for terminal notifications. */
+  readonly lostInfo: readonly BackgroundTaskInfo$1[];
+}
+interface BackgroundProcessManagerOptions {
+  readonly maxRunningTasks?: number;
+  readonly sessionDir?: string;
+}
+interface BackgroundTaskReservation {
+  release(): void;
+}
+interface BackgroundTaskOutputSnapshot {
+  readonly outputPath?: string;
+  readonly outputSizeBytes: number;
+  readonly previewBytes: number;
+  readonly truncated: boolean;
+  readonly fullOutputAvailable: boolean;
+  readonly preview: string;
+}
+declare class BackgroundProcessManager {
+  private readonly options;
+  private readonly processes;
+  private reservedTaskSlots;
+  /**
+   * Ghosts: tasks loaded from disk during reconcile that have no live
+   * KaosProcess. They appear in `list()` / `getTask()` with status
+   * `lost` so users see what was running before the crash/restart.
+   */
+  private readonly ghosts;
+  /** When set, register/lifecycle changes persist to disk. */
+  private sessionDir;
+  /**
+   * Registered terminal-state callbacks. Fired once per task when the
+   * task reaches a terminal state (completed / failed / killed).
+   */
+  private readonly terminalCallbacks;
+  /**
+   * Registered lifecycle callbacks. Fired for every observable
+   * transition (started / updated / terminated). Errors thrown by
+   * callbacks are silently swallowed so the BPM main flow never breaks
+   * because of a buggy subscriber.
+   */
+  private readonly lifecycleCallbacks;
+  constructor(options?: BackgroundProcessManagerOptions);
+  /**
+   * Register a callback that fires when any task reaches a terminal
+   * state. The callback receives the task's `BackgroundTaskInfo`
+   * snapshot. Multiple callbacks may be registered; they are invoked in
+   * registration order. Errors thrown by callbacks are silently swallowed.
+   */
+  onTerminal(callback: (info: BackgroundTaskInfo$1) => void | Promise<void>): void;
+  /**
+   * Register a callback that fires on every lifecycle transition:
+   *   - 'started':    task just registered (either bash or agent)
+   *   - 'updated':    awaiting_approval entered / cleared
+   *   - 'terminated': task reached a terminal state (also triggers
+   *                   onTerminal); fires exactly once per task.
+   *
+   * Synchronous callback. Errors are swallowed so the BPM lifecycle
+   * machinery (status updates, persistence, waiters) cannot be blocked
+   * by a buggy subscriber. Use it for fan-out to RPC events; do not put
+   * heavy work in it (defer to microtask if needed).
+   */
+  onLifecycle(callback: (event: BackgroundLifecycleEvent, info: BackgroundTaskInfo$1) => void): void;
+  /** Fan out a lifecycle event to subscribers. */
+  private fireLifecycle;
+  /**
+   * Subclasses can react to live task completion here. Restored disk
+   * tasks reconciled as lost do not call this hook.
+   */
+  protected onLiveTaskTerminal(_info: BackgroundTaskInfo$1): void | Promise<void>;
+  /**
+   * Fire all registered terminal callbacks for a task. Idempotent: the
+   * second invocation for the same task is a no-op so `reconcile()` /
+   * a lagging `wait()` resolver / a race between `stop()` and natural
+   * exit cannot yield duplicate notifications. This is the manager-side
+   * half of the dedupe pact with `NotificationManager.dedupe_key`.
+   */
+  private fireTerminalCallbacks;
+  private fireTerminalSubscribers;
+  private resolveWaiters;
+  assertCanRegister(): void;
+  reserveSlot(): BackgroundTaskReservation;
+  private activeTaskCount;
+  /**
+   * Register a KaosProcess as a background task.
+   * Starts capturing stdout/stderr and monitors lifecycle via `wait()`.
+   * Returns the assigned task ID.
+   *
+   * `opts.kind` picks the id prefix. Defaults to `'bash'` because bash
+   * subprocess registration is the only caller on the process path
+   * today; agent tasks go through `registerAgentTask` which forces
+   * `'agent'`.
+   */
+  register(proc: KaosProcess, command: string, description: string, opts?: {
+    kind?: BackgroundTaskKind;
+    /**
+     * Optional shell metadata. Carried so the `/task` UI and the
+     * background persist snapshot can surface which dialect a
+     * task was launched under. Legacy callers omitting this
+     * field keep the implicit 'bash' default.
+     */
+    shellInfo?: {
+      shellName: string;
+      shellPath: string;
+      cwd: string;
+    };
+    reservation?: BackgroundTaskReservation;
+  } | undefined): string;
+  /** Get info about a specific task. Falls back to reconcile ghosts. */
+  getTask(taskId: string): BackgroundTaskInfo$1 | undefined;
+  /**
+   * Give just-ended processes a short grace period to settle their `wait()`
+   * promise, then return with whatever lifecycle state has been finalized.
+   */
+  settlePendingExits(): Promise<void>;
+  /**
+   * List tasks, optionally filtering to active-only.
+   *
+   * When `activeOnly=false`, includes reconcile ghosts (lost tasks
+   * from a prior CLI process) so the user sees what survived the
+   * restart. Active-only mode never shows ghosts (they're terminal).
+   */
+  list(activeOnly?: boolean, limit?: number): BackgroundTaskInfo$1[];
+  /**
+   * Await all pending `output.log` appends for a task to settle.
+   *
+   * Output chunks are persisted to disk on an async queue, so a task can
+   * reach a terminal state before its final chunks have landed on disk.
+   * Callers that read the on-disk log (`getOutputSizeBytes` /
+   * `readOutputBytesFromDisk`) should `await flushOutput()` first so they
+   * observe the complete log. No-op for unknown/ghost tasks.
+   */
+  flushOutput(taskId: string): Promise<void>;
+  /**
+   * Total byte size of a task's full output as stored on disk.
+   *
+   * Reads `<sessionDir>/tasks/<id>/output.log`, which is the complete,
+   * never-truncated log — unlike the in-memory ring buffer it never drops
+   * old chunks. Returns 0 when the manager is detached, the task is
+   * unknown, or the task has produced no output yet.
+   */
+  getOutputSizeBytes(taskId: string): Promise<number>;
+  /**
+   * Read a byte range of a task's full output from the on-disk log.
+   *
+   * Reads up to `maxBytes` bytes starting at `offset` of `output.log`,
+   * straight from disk so it never loses the head of a large task the way
+   * the in-memory ring buffer would. Callers derive `offset` and `maxBytes`
+   * from a single `getOutputSizeBytes` snapshot, so the bytes returned stay
+   * consistent with the size used for metadata even when a still-running
+   * task keeps growing its log. Returns an empty string when the manager
+   * is detached, the task is unknown, or the log is absent.
+   */
+  readOutputBytesFromDisk(taskId: string, offset: number, maxBytes: number): Promise<string>;
+  /**
+   * Return the output snapshot used by TaskOutput.
+   *
+   * Persisted logs are preferred when the task was registered with an
+   * output session directory and `output.log` has actually been created,
+   * because they are the complete, never-truncated source. Detached managers,
+   * tasks registered before a session dir was attached, and silent tasks with
+   * no persisted log fall back to the live ring buffer.
+   */
+  getOutputSnapshot(taskId: string, maxPreviewBytes: number): Promise<BackgroundTaskOutputSnapshot>;
+  /** Get the combined output of a task (tail of the ring buffer). */
+  getOutput(taskId: string, tail?: number): string;
+  readOutput(taskId: string, tail?: number): Promise<string>;
+  getOutputPath(taskId: string): string | undefined;
+  /** Stop a running task. SIGTERM → 5s grace → SIGKILL. */
+  stop(taskId: string, reason?: string): Promise<BackgroundTaskInfo$1 | undefined>;
+  stopAll(reason?: string): Promise<readonly BackgroundTaskInfo$1[]>;
+  /**
+   * Wait for a task to reach a terminal state.
+   * Returns immediately if already terminal. Times out after `timeoutMs`.
+   */
+  wait(taskId: string, timeoutMs?: number): Promise<BackgroundTaskInfo$1 | undefined>;
+  /**
+   * Register a Promise-based agent task (no KaosProcess). Used by
+   * AgentTool for background subagent dispatch. Agent tasks appear in
+   * `list()` / `getTask()` but have pid=0 and empty output.
+   *
+   * `opts.timeoutMs` wraps the completion in an external deadline. On
+   * deadline fire, the task is marked `failed` with `timedOut=true`
+   * (distinct from a caller-driven `stop()` which uses `killed`, and
+   * distinct from an internal `TimeoutError` rejection which is a
+   * generic `failed` with `timedOut` left unset).
+   */
+  registerAgentTask(completion: Promise<{
+    result: string;
+  }>, description: string, opts?: {
+    timeoutMs?: number;
+    abort?: () => void;
+    reservation?: BackgroundTaskReservation; /** Subagent identifier; surfaced on task info. */
+    agentId?: string; /** Subagent profile name; surfaced on task info. */
+    subagentType?: string;
+  }): string;
+  /**
+   * Mark a running task as paused pending approval. The approval reason
+   * (tool call description) is retained until the task either returns
+   * to `'running'` via `clearAwaitingApproval()` or reaches a terminal
+   * state. Calls on terminal or unknown tasks are silently ignored so
+   * the ApprovalRuntime callback path is race-safe.
+   */
+  markAwaitingApproval(taskId: string, reason: string): void;
+  /**
+   * Drop the approval gate and return to `'running'`. Clears the stored
+   * reason so stale text cannot leak into a future `awaiting_approval`
+   * cycle. No-op unless the task is currently in the awaiting_approval
+   * state.
+   */
+  clearAwaitingApproval(taskId: string): void;
+  /**
+   * Resolve when the task reaches a terminal state. If the task is
+   * already terminal, resolves synchronously on the next microtask.
+   * Intended for integration code that wants to `await` a specific
+   * task's exit without installing a full `onTerminal` subscriber.
+   * Returns `undefined` for unknown ids (matching `getTask`). Ghost
+   * (reconciled-lost) entries are considered terminal from the
+   * manager's perspective.
+   */
+  waitForTerminal(taskId: string): Promise<BackgroundTaskInfo$1 | undefined>;
+  /** Reset internal state (for testing). */
+  _reset(): void;
+  /**
+   * Attach the manager to a session directory for persistence. Tasks
+   * created via `register()` after this call are written to
+   * `<sessionDir>/tasks/<task_id>.json` and updated on lifecycle change.
+   * Tasks created before attach are NOT retroactively persisted.
+   */
+  attachSessionDir(sessionDir: string): void;
+  /**
+   * Load persisted task records into the ghost map. Does NOT reconcile
+   * (call `reconcile()` after `loadFromDisk()`). Idempotent; subsequent
+   * calls overwrite the ghost map.
+   *
+   * Requires `attachSessionDir()` first; no-op otherwise.
+   */
+  loadFromDisk(): Promise<void>;
+  /**
+   * Reconcile loaded ghost tasks. Any ghost with status `running` is
+   * reclassified as `lost` (its previous CLI process died without
+   * writing a terminal state). Updates the on-disk record and returns
+   * the lost task ids so the caller can emit user-facing notifications.
+   */
+  protected markLoadedTasksLost(): Promise<ReconcileResult>;
+  reconcile(): Promise<ReconcileResult>;
+  /** Drop a persisted task from disk and ghost map. */
+  forgetTask(taskId: string): Promise<void>;
+  /**
+   * Persist the current state of a live ManagedProcess. Called from
+   * `register()` and the lifecycle finally block. No-op unless attached.
+   */
+  private persistLive;
+  private appendOutput;
+  private outputSessionDirFor;
+  private settleProcessExit;
+  private observedExitCompletions;
+  private toInfo;
+  private finalizeTerminal;
+}
+//#endregion
+//#region src/tools/display/schemas.d.ts
+declare const ToolInputDisplaySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"command">;
+  command: z.ZodString;
+  cwd: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  language: z.ZodOptional<z.ZodLiteral<"bash">>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"file_io">;
+  operation: z.ZodEnum<{
+    read: "read";
+    write: "write";
+    edit: "edit";
+    glob: "glob";
+    grep: "grep";
+  }>;
+  path: z.ZodString;
+  detail: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"diff">;
+  path: z.ZodString;
+  before: z.ZodString;
+  after: z.ZodString;
+  hunks: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"search">;
+  query: z.ZodString;
+  scope: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"url_fetch">;
+  url: z.ZodString;
+  method: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"agent_call">;
+  agent_name: z.ZodString;
+  prompt: z.ZodString;
+  background: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"skill_call">;
+  skill_name: z.ZodString;
+  args: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"todo_list">;
+  items: z.ZodArray<z.ZodObject<{
+    title: z.ZodString;
+    status: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"background_task">;
+  task_id: z.ZodString;
+  status: z.ZodString;
+  description: z.ZodString;
+  task_kind: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"task_stop">;
+  task_id: z.ZodString;
+  task_description: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"plan_review">;
+  plan: z.ZodString;
+  path: z.ZodOptional<z.ZodString>;
+  options: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodString;
+  }, z.core.$strip>>>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"generic">;
+  summary: z.ZodString;
+  detail: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>], "kind">;
+type ToolInputDisplay = z.infer<typeof ToolInputDisplaySchema>;
+//#endregion
+//#region src/loop/tool-access.d.ts
+type ToolFileAccessOperation = 'read' | 'write' | 'readwrite' | 'search';
+type ToolResourceAccess = {
+  readonly kind: 'file';
+  readonly operation: ToolFileAccessOperation;
+  /**
+   * Canonical file path when the access can be narrowed. Omitted means the
+   * operation may touch any file in the backend file namespace.
+   */
+  readonly path?: string;
+  readonly recursive?: boolean;
+} | {
+  /**
+   * Arbitrary side effects or resources that cannot be represented as a
+   * file access. This is intentionally operation-less and globally
+   * exclusive for concurrency.
+   */
+  readonly kind: 'all';
+};
+type ToolAccesses = readonly ToolResourceAccess[];
+declare const ToolAccesses: {
+  none(): ToolAccesses;
+  all(): ToolAccesses;
+  file(operation: ToolFileAccessOperation, path?: string, options?: {
+    readonly recursive?: boolean;
+  }): ToolAccesses;
+  readFile(path: string): ToolAccesses;
+  readTree(path: string): ToolAccesses;
+  readAnyFile(): ToolAccesses;
+  writeFile(path: string): ToolAccesses;
+  writeTree(path: string): ToolAccesses;
+  writeAnyFile(): ToolAccesses;
+  readWriteFile(path: string): ToolAccesses;
+  readWriteTree(path: string): ToolAccesses;
+  readWriteAnyFile(): ToolAccesses;
+  searchTree(path: string): ToolAccesses;
+  searchAnyFile(): ToolAccesses;
+  conflict(left: ToolAccesses, right: ToolAccesses): boolean;
+};
+//#endregion
+//#region src/loop/llm.d.ts
+interface ToolCallDelta {
+  readonly toolCallId: string;
+  readonly name?: string | undefined;
+  readonly argumentsPart?: string | undefined;
+}
+interface LLMRequestLogContext {
+  readonly turnId?: string;
+  readonly step?: number;
+  readonly stepUuid?: string;
+  readonly attempt?: number;
+  readonly maxAttempts?: number;
+}
+interface LLMChatParams {
+  messages: Message[];
+  tools: readonly Tool[];
+  signal: AbortSignal;
+  requestLogContext?: LLMRequestLogContext;
+  onTextDelta?: ((delta: string) => void) | undefined;
+  onThinkDelta?: ((delta: string) => void) | undefined;
+  onToolCallDelta?: ((delta: ToolCallDelta) => void) | undefined;
+  /**
+   * Fires once per completed text block. Additive relative to
+   * `onTextDelta` — deltas still fire chunk-by-chunk for UI streaming.
+   * Returned promises are awaited by the adapter to preserve transcript append
+   * order. Durable transcript writes receive completed blocks only.
+   */
+  onTextPart?: ((part: TextPart) => Promise<void> | void) | undefined;
+  /**
+   * Fires once per completed thinking block. Additive relative to
+   * `onThinkDelta` — deltas still fire chunk-by-chunk for UI streaming.
+   * Returned promises are awaited by the adapter to preserve transcript append
+   * order. Durable transcript writes receive completed blocks only.
+   */
+  onThinkPart?: ((part: ThinkPart) => Promise<void> | void) | undefined;
+}
+interface LLMChatResponse {
+  toolCalls: ToolCall[];
+  providerFinishReason?: FinishReason | undefined;
+  rawFinishReason?: string | undefined;
+  usage: TokenUsage;
+}
+interface LLM {
+  readonly systemPrompt: string;
+  readonly modelName: string;
+  readonly capability?: ModelCapability | undefined;
+  isRetryableError?(error: unknown): boolean;
+  chat(params: LLMChatParams): Promise<LLMChatResponse>;
+}
+//#endregion
+//#region src/loop/types.d.ts
+/**
+ * Stop reason for one completed model step.
+ *
+ * `tool_use` is a loop-control signal: the loop executes the requested tools and
+ * continues with another step. The other values are terminal for the current
+ * turn unless a host hook explicitly asks the loop to continue.
+ */
+type LoopStepStopReason = 'end_turn' | 'max_tokens' | 'tool_use' | 'filtered' | 'paused' | 'unknown';
+type LoopTerminalStepStopReason = Exclude<LoopStepStopReason, 'tool_use'>;
+/**
+ * Stop reasons that can be returned in a normal `TurnResult`.
+ *
+ * `tool_use` is intentionally absent because it cannot be the final result of a
+ * completed turn. Errors and max-step exhaustion are represented by thrown
+ * errors, not by this union. Compaction is a host-level retry concern rather
+ * than a stop reason.
+ */
+type LoopTurnStopReason = LoopTerminalStepStopReason | 'aborted';
+type ExecutableToolOutput = string | ContentPart[];
+interface ExecutableToolSuccessResult {
+  readonly output: ExecutableToolOutput;
+  readonly isError?: false | undefined;
+  /**
+   * Optional human-readable side channel for tool-result metadata that
+   * should not contaminate the data stream the model sees (e.g. a
+   * "Task snapshot retrieved." brief for TaskOutput). Distinct from
+   * `output`: callers rendering tool results decide whether to surface
+   * this to the user.
+   */
+  readonly message?: string | undefined;
+}
+interface ExecutableToolErrorResult {
+  readonly output: ExecutableToolOutput;
+  readonly isError: true;
+  /** See {@link ExecutableToolSuccessResult.message}. */
+  readonly message?: string | undefined;
+  /**
+   * Internal loop-control hint. Tool result events strip this field before
+   * persistence; it only tells the current turn whether another model step is
+   * allowed after this tool batch.
+   */
+  readonly stopTurn?: boolean | undefined;
+}
+type ExecutableToolResult = ExecutableToolSuccessResult | ExecutableToolErrorResult;
+interface ToolUpdate$1 {
+  kind: 'stdout' | 'stderr' | 'progress' | 'status' | 'custom';
+  text?: string | undefined;
+  percent?: number | undefined;
+  /** Vendor-defined event identifier when `kind === 'custom'`. */
+  customKind?: string | undefined;
+  /** Opaque payload paired with `customKind`. */
+  customData?: unknown;
+}
+/**
+ * Per-call context passed to tool implementations.
+ */
+interface ExecutableToolContext {
+  readonly turnId: string;
+  readonly toolCallId: string;
+  readonly metadata?: unknown;
+  readonly signal: AbortSignal;
+  readonly onUpdate?: ((update: ToolUpdate$1) => void) | undefined;
+}
+interface RunnableToolExecution {
+  readonly isError?: false | undefined;
+  readonly accesses?: ToolAccesses | undefined;
+  readonly display?: ToolInputDisplay | undefined;
+  readonly description?: string;
+  readonly execute: (ctx: ExecutableToolContext) => Promise<ExecutableToolResult>;
+}
+type ToolExecution = RunnableToolExecution | ExecutableToolErrorResult;
+interface ExecutableTool<Input = unknown> extends Tool {
+  resolveExecution(input: Input): ToolExecution;
+}
+/**
+ * Step hooks are aligned to recorded phase boundaries: `beforeStep` runs before
+ * `step.begin`, while `afterStep` runs after `step.end`.
+ */
+interface LoopStepHookContext {
+  readonly turnId: string;
+  readonly stepNumber: number;
+  readonly signal: AbortSignal;
+  readonly llm: LLM;
+}
+interface ToolExecutionHookContext extends LoopStepHookContext {
+  readonly toolCall: ToolCall$1;
+  readonly tool?: ExecutableTool | undefined;
+  readonly args: unknown;
+}
+interface PrepareToolExecutionResult {
+  readonly block?: boolean | undefined;
+  readonly reason?: string | undefined;
+  readonly updatedArgs?: unknown;
+  readonly syntheticResult?: ExecutableToolResult | undefined;
+  readonly executionMetadata?: unknown;
+}
+//#endregion
+//#region src/loop/events.d.ts
+interface LoopStepBeginEvent {
+  readonly type: 'step.begin';
+  readonly uuid: string;
+  readonly turnId: string;
+  readonly step: number;
+}
+interface LoopStepEndEvent {
+  readonly type: 'step.end';
+  readonly uuid: string;
+  readonly turnId: string;
+  readonly step: number;
+  readonly usage?: TokenUsage | undefined;
+  readonly finishReason?: LoopStepStopReason | undefined;
+  /**
+   * Provider diagnostics are optional and must not drive loop control.
+   * Use `finishReason` for normalized behavior.
+   */
+  readonly providerFinishReason?: FinishReason | undefined;
+  readonly rawFinishReason?: string | undefined;
+}
+interface LoopContentPartEvent {
+  readonly type: 'content.part';
+  readonly uuid: string;
+  readonly turnId: string;
+  readonly step: number;
+  readonly stepUuid: string;
+  readonly part: TextPart | ThinkPart;
+}
+interface LoopToolCallEvent {
+  readonly type: 'tool.call';
+  readonly uuid: string;
+  readonly turnId: string;
+  readonly step: number;
+  readonly stepUuid: string;
+  readonly toolCallId: string;
+  readonly name: string;
+  readonly args: unknown;
+  readonly description?: string | undefined;
+  readonly display?: ToolInputDisplay | undefined;
+}
+interface LoopToolResultEvent {
+  readonly type: 'tool.result';
+  readonly parentUuid: string;
+  readonly toolCallId: string;
+  readonly result: ExecutableToolResult;
+}
+type LoopRecordedEvent = LoopStepBeginEvent | LoopStepEndEvent | LoopContentPartEvent | LoopToolCallEvent | LoopToolResultEvent;
+//#endregion
+//#region src/tools/store.d.ts
+interface ToolStoreData {}
+type ToolStoreKey = Extract<keyof ToolStoreData, string>;
+interface ToolStore {
+  get<K extends ToolStoreKey>(key: K): ToolStoreData[K] | undefined;
+  set<K extends ToolStoreKey>(key: K, value: ToolStoreData[K]): void;
+}
+interface ToolStoreUpdate<K extends ToolStoreKey = ToolStoreKey> {
+  readonly key: K;
+  readonly value: ToolStoreData[K];
+}
+//#endregion
+//#region src/agent/tool/types.d.ts
+type ToolSource = 'builtin' | 'user' | 'mcp';
+type BuiltinTool<Input = unknown> = ExecutableTool<Input>;
+interface UserToolRegistration {
+  readonly name: string;
+  readonly description: string;
+  readonly parameters: Record<string, unknown>;
+}
+interface ToolInfo$1 {
+  readonly name: string;
+  readonly description: string;
+  readonly active: boolean;
+  readonly source: ToolSource;
+}
+interface McpToolCollision {
+  readonly qualified: string;
+  readonly toolName: string;
+  readonly collidesWith: {
+    readonly kind: 'same_server';
+    readonly toolName: string;
+  } | {
+    readonly kind: 'other_server';
+    readonly serverName: string;
+  };
+}
+interface McpServerRegistrationResult {
+  readonly registered: readonly string[];
+  readonly collisions: readonly McpToolCollision[];
+}
+//#endregion
+//#region src/agent/tool/index.d.ts
+interface McpToolEntry {
+  readonly tool: ExecutableTool;
+  readonly serverName: string;
+}
+declare class ToolManager {
+  protected readonly agent: Agent;
+  protected builtinTools: Map<string, BuiltinTool>;
+  protected readonly userTools: Map<string, ExecutableTool>;
+  protected readonly mcpTools: Map<string, McpToolEntry>;
+  /** server name → list of qualified tool names registered for that server. */
+  protected readonly mcpToolsByServer: Map<string, string[]>;
+  protected enabledTools: Set<string>;
+  /** Glob patterns (e.g. `mcp__*`, `mcp__github__*`) gating which MCP tools the profile exposes. */
+  private mcpAccessPatterns;
+  protected readonly store: Partial<ToolStoreData>;
+  private mcpToolStatusUnsubscribe;
+  constructor(agent: Agent);
+  protected get toolStore(): ToolStore;
+  attachMcpTools(): void;
+  updateStore<K extends ToolStoreKey>(key: K, value: ToolStoreData[K]): void;
+  registerUserTool(input: UserToolRegistration): void;
+  unregisterUserTool(name: string): void;
+  registerMcpServer(serverName: string, client: MCPClient, tools: readonly Tool[], enabledTools?: ReadonlySet<string>): McpServerRegistrationResult;
+  unregisterMcpServer(serverName: string): boolean;
+  private handleMcpServerStatusChange;
+  private registerNeedsAuthMcpServer;
+  private registerConnectedMcpServer;
+  private emitMcpToolCollisions;
+  setActiveTools(names: readonly string[]): void;
+  private isMcpToolEnabled;
+  toolInfos(): Iterable<ToolInfo$1>;
+  data(): readonly ToolInfo$1[];
+  storeData(): Readonly<Record<string, unknown>>;
+  initializeBuiltinTools(): void;
+  private createVideoUploader;
+  get loopTools(): readonly ExecutableTool[];
+}
+//#endregion
+//#region src/logging/logger.d.ts
+declare function getRootLogger(): RootLogger;
+declare function flushDiagnosticLogs(): Promise<boolean>;
+/**
+ * Root logger. Import and use directly for events that don't belong to any
+ * session (CLI startup, harness construction, etc.):
+ *
+ *   import { log } from 'byf-sdk';
+ *   log.info('byf starting', { version });
+ *
+ * For events scoped to a session or agent, use the parent's `log` field:
+ *
+ *   session.log.error('mcp initial load failed', error);
+ *   agent.log.error('turn failed', { turnId, error });
+ *
+ * Late-binding: methods look up the current `RootLogger` on every call, so
+ * importing `log` at module load (before `ByfHarness` configures the root)
+ * is safe — calls during the pre-configure window are silent noops.
+ */
+declare const log: Logger;
+declare function redact<T>(value: T): T;
+declare function resolveGlobalLogPath(homeDir: string): string;
+//#endregion
+//#region src/agent/compaction/types.d.ts
+interface CompactionResult$1 {
+  summary: string;
+  compactedCount: number;
+  tokensBefore: number;
+  tokensAfter: number;
+}
+interface CompactionBeginData {
+  instruction?: string;
+  source: 'manual' | 'auto';
+}
+//#endregion
+//#region src/agent/compaction/full.d.ts
+interface CompactionStrategy {
+  shouldCompact(usedSize: number, maxSize: number): boolean;
+  shouldBlock(usedSize: number, maxSize: number): boolean;
+  computeCompactCount(messages: readonly Message[], maxSize: number): number;
+  readonly checkAfterStep: boolean;
+  readonly maxCompactionPerTurn: number;
+}
+interface CompactedHistory {
+  text: string;
+}
+type CompactionTelemetryTrigger = CompactionBeginData['source'] | 'manual-with-prompt' | 'unknown';
+declare class FullCompaction {
+  protected readonly agent: Agent;
+  protected compactionCountInTurn: number;
+  protected compacting: {
+    abortController: AbortController;
+    startedAt: number;
+    telemetryTrigger: CompactionTelemetryTrigger;
+    promise: Promise<void>;
+  } | null;
+  protected _compactedHistory: CompactedHistory[];
+  protected readonly strategy: CompactionStrategy;
+  constructor(agent: Agent, strategy?: CompactionStrategy);
+  get isCompacting(): boolean;
+  begin(data: Readonly<CompactionBeginData>): void;
+  private startCompactionWorker;
+  cancel(): void;
+  private markCanceled;
+  complete(result: CompactionResult$1, llmUsage?: TokenUsage | undefined, retryCount?: number): void;
+  private get tokenCountWithPending();
+  private get maxContextSize();
+  private get shouldCompact();
+  private get shouldBlock();
+  resetForTurn(): void;
+  handleOverflowError(signal: AbortSignal, error: unknown): Promise<void>;
+  beforeStep(signal: AbortSignal): Promise<void>;
+  afterStep(): Promise<void>;
+  private checkAutoCompaction;
+  private beginAutoCompaction;
+  private block;
+  private compactionWorker;
+  private generateCompactionResponse;
+  get compactedHistory(): readonly CompactedHistory[];
+  private triggerPreCompactHook;
+  private triggerPostCompactHook;
+  private computeCompactableCount;
+}
+//#endregion
+//#region src/agent/context/types.d.ts
+interface UserPromptOrigin {
+  readonly kind: 'user';
+  readonly blockedByHook?: string | undefined;
+}
+declare const USER_PROMPT_ORIGIN: UserPromptOrigin;
+interface SkillActivationOrigin {
+  readonly kind: 'skill_activation';
+  readonly activationId: string;
+  readonly skillName: string;
+  readonly skillArgs?: string | undefined;
+  readonly trigger: 'user-slash' | 'model-tool' | 'nested-skill';
+  readonly skillType?: string | undefined;
+  readonly skillPath?: string | undefined;
+  readonly skillSource?: SkillSource | undefined;
+}
+interface InjectionOrigin {
+  readonly kind: 'injection';
+  readonly variant: string;
+}
+interface CompactionSummaryOrigin {
+  readonly kind: 'compaction_summary';
+}
+interface SystemTriggerOrigin {
+  readonly kind: 'system_trigger';
+  readonly name: string;
+}
+interface BackgroundTaskOrigin {
+  readonly kind: 'background_task';
+  readonly taskId: string;
+  readonly status: BackgroundTaskStatus;
+  readonly notificationId: string;
+}
+interface HookResultOrigin {
+  readonly kind: 'hook_result';
+  readonly event: string;
+  readonly blocked?: boolean;
+}
+type PromptOrigin = UserPromptOrigin | SkillActivationOrigin | InjectionOrigin | CompactionSummaryOrigin | SystemTriggerOrigin | BackgroundTaskOrigin | HookResultOrigin;
+type ContextMessage$1 = Message & {
+  readonly origin?: PromptOrigin | undefined;
+  readonly isError?: boolean;
+};
+interface AgentContextData$1 {
+  history: readonly ContextMessage$1[];
+  tokenCount: number;
+}
+//#endregion
+//#region src/agent/context/index.d.ts
+declare class ContextMemory {
+  protected readonly agent: Agent;
+  private _history;
+  private _tokenCount;
+  private tokenCountCoveredMessageCount;
+  private openSteps;
+  private pendingToolResultIds;
+  private deferredMessages;
+  constructor(agent: Agent);
+  appendUserMessage(content: readonly ContentPart[], origin?: PromptOrigin): void;
+  appendSystemReminder(content: string, origin: PromptOrigin): void;
+  markLastUserPromptBlocked(hookEvent: string): void;
+  clear(): void;
+  applyCompaction(summary: CompactionResult$1): void;
+  data(): AgentContextData$1;
+  get tokenCount(): number;
+  get tokenCountWithPending(): number;
+  get history(): readonly ContextMessage$1[];
+  get messages(): Message[];
+  appendLoopEvent(event: LoopRecordedEvent): void;
+  appendMessage(message: ContextMessage$1): void;
+  private flushDeferredMessagesIfToolExchangeClosed;
+  private hasOpenToolExchange;
+  private pushHistory;
+}
+//#endregion
+//#region src/agent/hooks/types.d.ts
+declare const HOOK_EVENT_TYPES: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "UserPromptSubmit", "Stop", "StopFailure", "SessionStart", "SessionEnd", "SubagentStart", "SubagentStop", "PreCompact", "PostCompact", "Notification"];
+type HookEventType = (typeof HOOK_EVENT_TYPES)[number];
+interface HookDef {
+  readonly event: HookEventType;
+  readonly matcher?: string;
+  readonly command: string;
+  readonly timeout?: number;
+}
+interface HookResult {
+  readonly action: 'allow' | 'block';
+  readonly message?: string;
+  readonly reason?: string;
+  readonly stdout?: string;
+  readonly stderr?: string;
+  readonly exitCode?: number;
+  readonly timedOut?: boolean;
+  readonly structuredOutput?: boolean;
+}
+interface HookBlockDecision {
+  readonly block: true;
+  readonly reason: string;
+}
+type HookMatcherValue = string | readonly ContentPart[];
+interface HookEngineTriggerArgs {
+  readonly matcherValue?: HookMatcherValue;
+  readonly inputData?: Record<string, unknown>;
+  readonly signal?: AbortSignal;
+}
+type HookTriggeredCallback = (event: string, target: string, count: number) => void;
+type HookResolvedCallback = (event: string, target: string, action: string, reason: string | undefined, durationMs: number) => void;
+interface HookEngineOptions {
+  readonly cwd?: string;
+  readonly sessionId?: string;
+  readonly onTriggered?: HookTriggeredCallback;
+  readonly onResolved?: HookResolvedCallback;
+}
+//#endregion
+//#region src/agent/hooks/engine.d.ts
+declare class HookEngine {
+  private readonly options;
+  private readonly byEvent;
+  private readonly pendingTriggers;
+  constructor(hooks?: readonly HookDef[], options?: HookEngineOptions);
+  get summary(): Record<string, number>;
+  trigger(event: string, args?: HookEngineTriggerArgs): Promise<HookResult[]>;
+  triggerBlock(event: string, args?: HookEngineTriggerArgs): Promise<HookBlockDecision | undefined>;
+  fireAndForgetTrigger(event: string, args?: HookEngineTriggerArgs): Promise<HookResult[]>;
+  private triggerInner;
+  private matchingHooks;
+  private emitTriggered;
+  private emitResolved;
+}
+//#endregion
+//#region src/agent/permission/types.d.ts
+type PermissionRuleDecision = 'allow' | 'deny' | 'ask';
+/**
+ * Rule provenance. `session-runtime` is the value used by the runtime
+ * "approve for session" path; `turn-override`, `project`, and `user`
+ * are reserved for static-loaded rules surfaced by external callers.
+ */
+type PermissionRuleScope = 'turn-override' | 'session-runtime' | 'project' | 'user';
+/**
+ * Top-level user-facing permission posture. Controls how non-deny rules
+ * are treated when the closure is constructed. Independent of rule
+ * merging: deny rules always fire regardless of mode.
+ *
+ *   - `manual` — rule set drives decision; unmatched tool calls ask
+ *   - `yolo`   — only deny rules can block; everything else allows
+ *   - `auto`   — caller may bypass rule checks entirely
+ */
+type PermissionMode$1 = 'manual' | 'yolo' | 'auto';
+/**
+ * A single permission rule. `pattern` is the DSL form (`Read(/etc/**)`,
+ * `Bash(rm *)`, or bare `Write`). See `parse-pattern.ts` for the parser
+ * and `matches-rule.ts` for the matcher.
+ */
+interface PermissionRule {
+  readonly decision: PermissionRuleDecision;
+  readonly scope: PermissionRuleScope;
+  readonly pattern: string;
+  readonly reason?: string | undefined;
+}
+interface ApprovalResponse$1 {
+  decision: 'approved' | 'rejected' | 'cancelled';
+  scope?: 'session';
+  feedback?: string;
+  selectedLabel?: string;
+}
+interface PermissionApprovalResultRecord$1 {
+  readonly turnId: number;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly action: string;
+  readonly result: ApprovalResponse$1;
+}
+interface PermissionData$1 {
+  mode: PermissionMode$1;
+  rules: PermissionRule[];
+}
+//#endregion
+//#region src/agent/permission/policy.d.ts
+interface PermissionPolicyContext {
+  readonly agent: Agent;
+  readonly mode: PermissionMode$1;
+  readonly toolCallContext: ToolExecutionHookContext;
+  /**
+   * The rule matched by `checkPermission()`, if any.
+   *
+   * Policies that want to defer to user-defined rules (e.g. a default-allow
+   * policy that should not override an explicit `ask`/`deny` rule) inspect
+   * this to decide whether to fire. `undefined` means the decision came
+   * from the built-in default permission table rather than a user rule.
+   */
+  readonly matchedRule: PermissionRule | undefined;
+  readonly recordApprovalResult: (record: PermissionApprovalResultRecord$1) => void;
+}
+type PermissionPolicyResult = {
+  readonly kind: 'allow';
+  readonly executionMetadata?: unknown;
+} | {
+  readonly kind: 'result';
+  readonly result: PrepareToolExecutionResult;
+} | {
+  readonly kind: 'ask';
+  readonly action?: string | undefined;
+  readonly display?: ToolInputDisplay | undefined;
+};
+interface PermissionPolicy {
+  readonly name: string;
+  evaluate(context: PermissionPolicyContext): PermissionPolicyResult | undefined | Promise<PermissionPolicyResult | undefined>;
+}
+//#endregion
+//#region src/agent/permission/index.d.ts
+interface PermissionManagerOptions {
+  readonly initialRules?: readonly PermissionRule[] | undefined;
+  readonly policies?: readonly PermissionPolicy[] | undefined;
+  readonly parent?: PermissionManager | undefined;
+}
+declare class PermissionManager {
+  protected readonly agent: Agent;
+  rules: PermissionRule[];
+  private modeOverride;
+  private readonly parent;
+  private readonly sessionApprovedActions;
+  private readonly policies;
+  constructor(agent: Agent, options?: PermissionManagerOptions);
+  get mode(): PermissionMode$1;
+  set mode(mode: PermissionMode$1);
+  data(): PermissionData$1;
+  setMode(mode: PermissionMode$1): void;
+  recordApprovalResult(record: PermissionApprovalResultRecord$1): void;
+  beforeToolCall(context: ToolExecutionHookContext): Promise<PrepareToolExecutionResult | undefined>;
+  private requestToolApproval;
+  private evaluatePolicies;
+  private checkPermission;
+  private checkMatchingPermissionRules;
+  private effectiveRules;
+  private wouldAskInManualMode;
+  private permissionPolicyResultToPrepare;
+  private hasRule;
+  protected formatMessage(toolName: string, reason?: string): string;
+  protected formatApprovalRejectionMessage(toolName: string, result: {
+    decision: 'approved' | 'rejected' | 'cancelled';
+    feedback?: string;
+  }): string;
+  private pathMatchOptions;
+  private trackToolApproved;
+}
+//#endregion
+//#region src/telemetry.d.ts
+type TelemetryPropertyValue = boolean | number | string | null;
+type TelemetryProperties = Readonly<Record<string, TelemetryPropertyValue>>;
+interface TelemetryContextPatch {
+  readonly sessionId?: string | null;
+}
+interface TelemetryClient {
+  track(event: string, properties?: TelemetryProperties): void;
+  withContext?(patch: TelemetryContextPatch): TelemetryClient;
+  setContext?(patch: TelemetryContextPatch): void;
+}
+declare const noopTelemetryClient: TelemetryClient;
+declare function withTelemetryContext(telemetry: TelemetryClient, patch: TelemetryContextPatch): TelemetryClient;
+//#endregion
+//#region src/session/index.d.ts
+interface SessionConfig {
+  readonly runtime: RuntimeConfig;
+  readonly id?: string | undefined;
+  readonly homedir: string;
+  readonly byfHomeDir?: string;
+  readonly rpc: SDKSessionRPC;
+  readonly cwd?: string;
+  readonly initializeMainAgent?: boolean | undefined;
+  readonly providerManager?: ProviderManager | undefined;
+  readonly background?: BackgroundConfig | undefined;
+  readonly hooks?: readonly HookDef[];
+  readonly permissionRules?: readonly PermissionRule[];
+  readonly skills?: SessionSkillConfig;
+  readonly mcpConfig?: SessionMcpConfig;
+  readonly telemetry?: TelemetryClient | undefined;
+}
+interface SessionSkillConfig {
+  readonly userHomeDir?: string;
+  readonly explicitDirs?: readonly string[];
+  readonly extraDirs?: readonly string[];
+  readonly mergeAllAvailableSkills?: boolean;
+  readonly builtinDir?: string;
+}
+interface AgentMeta {
+  readonly homedir: string;
+  readonly type: AgentType$1;
+  readonly parentAgentId: string | null;
+}
+interface SessionMeta$1 {
+  createdAt: string;
+  updatedAt: string;
+  title: string;
+  isCustomTitle: boolean;
+  lastPrompt?: string;
+  forkedFrom?: string;
+  agents: Record<string, AgentMeta>;
+  custom: Record<string, any>;
+}
+declare class Session {
+  readonly config: SessionConfig;
+  readonly rpc: SDKSessionRPC;
+  readonly telemetry: TelemetryClient;
+  readonly skills: SkillRegistry;
+  readonly agents: Map<string, Agent>;
+  readonly mcp: McpConnectionManager;
+  readonly log: Logger;
+  private readonly logHandle;
+  readonly hookEngine: HookEngine;
+  private agentIdCounter;
+  private readonly skillsReady;
+  metadata: SessionMeta$1;
+  private writeMetadataPromise;
+  constructor(config: SessionConfig);
+  createMain(): Promise<Agent>;
+  resume(): Promise<{
+    warning?: string;
+  }>;
+  close(): Promise<void>;
+  private stopBackgroundTasksOnExit;
+  createAgent(config: Partial<AgentConfig>, profile?: ResolvedAgentProfile, parentAgentId?: string | undefined): Promise<{
+    readonly id: string;
+    readonly agent: Agent;
+  }>;
+  /**
+   * Applies a profile's derived config — cwd, system prompt, active tools — to
+   * an agent. Fresh creation and resume-of-an-incomplete-wire both route
+   * through here so the two paths cannot drift apart.
+   */
+  private bootstrapAgentProfile;
+  generateAgentsMd(): Promise<void>;
+  get hasActiveTurn(): boolean;
+  protected get metadataPath(): string;
+  writeMetadata(): Promise<void>;
+  readMetadata(): Promise<SessionMeta$1>;
+  flushMetadata(): Promise<void>;
+  listSkills(): Promise<readonly SkillSummary$1[]>;
+  private loadSkills;
+  private loadMcpServers;
+  private emitInitialMcpLoadError;
+  private onMcpServerStatusChange;
+  private backgroundTaskTimeoutMs;
+  private refreshAgentBuiltinTools;
+  private instantiateAgent;
+  private permissionOptions;
+  private ensureResumeAgentInstantiated;
+  private nextGeneratedAgentId;
+  private requireMainAgent;
+  private triggerSessionStart;
+  private triggerSessionEnd;
+}
+//#endregion
+//#region src/session/subagent-host.d.ts
+type RunSubagentOptions = {
+  readonly parentToolCallId: string;
+  readonly parentToolCallUuid?: string | undefined;
+  readonly prompt: string;
+  readonly description: string;
+  readonly runInBackground: boolean;
+  readonly origin?: PromptOrigin | undefined;
+  readonly signal: AbortSignal;
+};
+type SubagentCompletion = {
+  readonly result: string;
+  readonly usage?: TokenUsage;
+};
+type SubagentHandle = {
+  readonly agentId: string;
+  readonly profileName: string;
+  readonly resumed: boolean;
+  readonly completion: Promise<SubagentCompletion>;
+};
+declare class SessionSubagentHost {
+  private readonly session;
+  private readonly ownerAgentId;
+  readonly backgroundTaskTimeoutMs?: number | undefined;
+  private readonly activeChildren;
+  constructor(session: Session, ownerAgentId: string, backgroundTaskTimeoutMs?: number | undefined);
+  spawn(profileName: string, options: RunSubagentOptions): Promise<SubagentHandle>;
+  resume(agentId: string, options: RunSubagentOptions): Promise<SubagentHandle>;
+  cancelAll(): void;
+  getProfileName(agentId: string): string | undefined;
+  private resolveProfile;
+  private runChild;
+  private configureChild;
+  private triggerSubagentStart;
+  private triggerSubagentStop;
+}
+//#endregion
+//#region src/tools/builtin/state/todo-list.d.ts
+type TodoStatus = 'pending' | 'in_progress' | 'done';
+interface TodoItem {
+  readonly title: string;
+  readonly status: TodoStatus;
+}
+declare module '../../store' {
+  interface ToolStoreData {
+    todo: readonly TodoItem[];
+  }
+}
+//#endregion
+//#region src/tools/builtin/web/fetch-url.d.ts
+/**
+ * How the returned content relates to the original response body.
+ *
+ * - `passthrough` — the body was already plain text / markdown and is
+ *   returned verbatim, in full.
+ * - `extracted` — the body was an HTML page; only the main article text
+ *   was extracted and returned.
+ */
+type UrlFetchKind = 'passthrough' | 'extracted';
+interface UrlFetchResult {
+  /** The text handed to the LLM. */
+  content: string;
+  /** Whether `content` is a verbatim passthrough or extracted main text. */
+  kind: UrlFetchKind;
+}
+interface UrlFetcher {
+  fetch(url: string, options?: {
+    toolCallId?: string;
+  }): Promise<UrlFetchResult>;
+}
+//#endregion
+//#region src/tools/builtin/web/web-search.d.ts
+interface WebSearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+  date?: string | undefined;
+  content?: string | undefined;
+}
+interface WebSearchProvider {
+  search(query: string, options?: {
+    limit?: number;
+    includeContent?: boolean;
+    toolCallId?: string;
+  }): Promise<WebSearchResult[]>;
+}
+//#endregion
+//#region src/runtime-types.d.ts
+interface RuntimeConfig {
+  readonly kaos: Kaos;
+  readonly osEnv: Environment;
+  readonly urlFetcher?: UrlFetcher | undefined;
+  readonly webSearcher?: WebSearchProvider | undefined;
+}
+//#endregion
+//#region src/utils/types.d.ts
+type Promisify<T> = [T] extends [Promise<any>] ? T : Promise<T>;
+type Promisable<T> = [T] extends [Promise<any>] ? T | Awaited<T> : T | Promise<T>;
+type PromisableMethods<T> = { [K in keyof T]: T[K] extends ((...args: infer Args) => infer Return) ? (...args: Args) => Promisable<Return> : never };
+//#endregion
+//#region src/agent/background/index.d.ts
+declare class BackgroundManager extends BackgroundProcessManager {
+  readonly agent: Agent;
+  private readonly scheduledNotificationKeys;
+  private readonly deliveredNotificationKeys;
+  constructor(agent: Agent, options?: BackgroundProcessManagerOptions);
+  reconcile(): Promise<ReconcileResult>;
+  protected onLiveTaskTerminal(info: BackgroundTaskInfo$1): void | Promise<void>;
+  private restoreBackgroundTaskNotifications;
+  private notifyBackgroundTask;
+  private restoreBackgroundTaskNotification;
+  private buildBackgroundTaskNotificationContext;
+  private fireNotificationHook;
+  markDeliveredNotification(origin: BackgroundTaskOrigin): void;
+  private hasDeliveredNotification;
+  stop(taskId: string, reason?: string): Promise<BackgroundTaskInfo$1 | undefined>;
+  _reset(): void;
+}
+//#endregion
+//#region src/agent/config/types.d.ts
+interface AgentConfigData$1 {
+  cwd: string;
+  provider?: ProviderConfig;
+  modelAlias?: string;
+  modelCapabilities: ModelCapability;
+  profileName?: string;
+  thinkingLevel: string;
+  systemPrompt: string;
+}
+type AgentConfigUpdateData$1 = Partial<{
+  cwd: string;
+  modelAlias: string;
+  profileName: string;
+  thinkingLevel: string;
+  systemPrompt: string;
+}>;
+//#endregion
+//#region src/agent/config/index.d.ts
+declare class ConfigState {
+  protected readonly agent: Agent;
+  private _cwd;
+  private _modelAlias;
+  private _profileName;
+  private _thinkingLevel;
+  private _systemPrompt;
+  constructor(agent: Agent);
+  update(input: AgentConfigUpdateData$1): void;
+  data(): AgentConfigData$1;
+  get cwd(): string;
+  get hasModel(): boolean;
+  get hasProvider(): boolean;
+  get providerConfig(): ProviderConfig;
+  get provider(): ChatProvider;
+  get model(): string;
+  get modelAlias(): string | undefined;
+  get thinkingLevel(): ThinkingEffort;
+  get profileName(): string | undefined;
+  get systemPrompt(): string;
+  get modelCapabilities(): ModelCapability;
+  private get resolvedProviderConfig();
+  private tryResolvedProviderConfig;
+}
+//#endregion
+//#region src/agent/injection/manager.d.ts
+declare class InjectionManager {
+  protected readonly agent: Agent;
+  private readonly injectors;
+  constructor(agent: Agent);
+  inject(): Promise<void>;
+  onContextClear(): void;
+  onContextCompacted(compactedCount: number): void;
+}
+//#endregion
+//#region src/agent/plan/index.d.ts
+type PlanData$1 = null | {
+  id: string;
+  exists: boolean;
+  content: string;
+  path: string;
+};
+type PlanFilePath = string | null;
+declare class PlanMode {
+  protected readonly agent: Agent;
+  protected _isActive: boolean;
+  protected _planId: null | string;
+  protected _planFilePath: PlanFilePath;
+  constructor(agent: Agent);
+  createPlanId(): string;
+  enter(id?: string, createFile?: boolean, emitStatus?: boolean): Promise<void>;
+  restoreEnter({
+    id
+  }: {
+    readonly id: string;
+  }): void;
+  cancel(id?: string): void;
+  clear(): Promise<void>;
+  exit(id?: string): void;
+  get isActive(): boolean;
+  get planFilePath(): PlanFilePath;
+  data(): Promise<PlanData$1>;
+  materializeCurrentPlanFile(): Promise<void>;
+  private materializePlanFile;
+  private ensurePlanDirectory;
+  private planFilePathFor;
+  private planFileExists;
+  private trackPlanLifecycle;
+}
+//#endregion
+//#region src/agent/usage/index.d.ts
+type UsageRecordScope = 'session' | 'turn';
+declare class UsageRecorder {
+  protected readonly agent?: Agent | undefined;
+  private readonly byModel;
+  private currentTurn;
+  constructor(agent?: Agent | undefined);
+  beginTurn(): void;
+  endTurn(): void;
+  record(model: string, usage: TokenUsage, scope?: UsageRecordScope): void;
+  data(): UsageStatus;
+  status(): UsageStatus | undefined;
+  private byModelSnapshot;
+}
+//#endregion
+//#region src/agent/records/types.d.ts
+interface AgentRecordEvents {
+  metadata: {
+    protocol_version: string;
+    created_at: number;
+  };
+  'turn.prompt': {
+    input: readonly ContentPart[];
+    origin: PromptOrigin;
+  };
+  'turn.steer': {
+    input: readonly ContentPart[];
+    origin: PromptOrigin;
+  };
+  'turn.cancel': {
+    turnId?: number;
+  };
+  'config.update': AgentConfigUpdateData$1;
+  'permission.set_mode': {
+    mode: PermissionMode$1;
+  };
+  'permission.record_approval_result': PermissionApprovalResultRecord$1;
+  'full_compaction.begin': CompactionBeginData;
+  'plan_mode.enter': {
+    id: string;
+  };
+  'plan_mode.cancel': {
+    id?: string;
+  };
+  'plan_mode.exit': {
+    id?: string;
+  };
+  'tools.register_user_tool': UserToolRegistration;
+  'tools.unregister_user_tool': {
+    name: string;
+  };
+  'tools.set_active_tools': {
+    names: readonly string[];
+  };
+  'background.stop': {
+    taskId: string;
+  };
+  'usage.record': {
+    model: string;
+    usage: TokenUsage;
+    usageScope?: UsageRecordScope | undefined;
+  };
+  'full_compaction.cancel': {};
+  'full_compaction.complete': CompactionResult$1;
+  'context.append_message': {
+    message: ContextMessage$1;
+  };
+  'context.mark_last_user_prompt_blocked': {
+    hookEvent: string;
+  };
+  'context.append_loop_event': {
+    event: LoopRecordedEvent;
+  };
+  'context.clear': {};
+  'context.apply_compaction': CompactionResult$1;
+  'tools.update_store': ToolStoreUpdate;
+}
+type AgentRecord = { [K in keyof AgentRecordEvents]: Readonly<AgentRecordEvents[K]> & {
+  readonly type: K;
+  readonly time?: number;
+} }[keyof AgentRecordEvents];
+type AgentRecordOf<K extends keyof AgentRecordEvents> = Extract<AgentRecord, {
+  readonly type: K;
+}>;
+interface AgentRecordPersistence {
+  read(): AsyncIterable<AgentRecord>;
+  append(input: AgentRecord): void;
+  rewrite(records: readonly AgentRecord[]): void;
+  flush(): Promise<void>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/agent/records/index.d.ts
+declare class AgentRecords {
+  private readonly agent;
+  private readonly persistence?;
+  private _restoring;
+  private metadataInitialized;
+  constructor(agent: Agent, persistence?: AgentRecordPersistence | undefined);
+  get restoring(): boolean;
+  logRecord(record: AgentRecord): void;
+  restore(record: AgentRecord): void;
+  replay(): Promise<{
+    warning?: string;
+  }>;
+  flush(): Promise<void>;
+}
+//#endregion
+//#region src/agent/replay/index.d.ts
+declare class ReplayBuilder {
+  readonly agent: Agent;
+  protected readonly records: AgentReplayRecord[];
+  constructor(agent: Agent);
+  push(record: AgentReplayRecord): void;
+  buildResult(): readonly AgentReplayRecord[];
+}
+//#endregion
+//#region src/agent/skill/index.d.ts
+declare class SkillManager {
+  protected readonly agent: Agent;
+  readonly registry: SkillRegistry;
+  constructor(agent: Agent, registry: SkillRegistry);
+  activate(input: ActivateSkillPayload): void;
+  recordActivation(origin: SkillActivationOrigin, input?: readonly ContentPart[] | undefined): void;
+}
+//#endregion
+//#region src/errors/codes.d.ts
+/**
+ * Error codes for Byf Core's public error protocol.
+ *
+ * `ErrorCodes` is the source of truth for every code Byf Core may emit.
+ * Downstream consumers (SDK, RPC clients, telemetry, agent-facing docs)
+ * should depend on these string values rather than on class identity.
+ *
+ * Codes follow `domain.reason`. Adding a code is a minor change; renaming
+ * or removing one is a major change.
+ */
+declare const ErrorCodes: {
+  readonly CONFIG_INVALID: "config.invalid";
+  readonly SESSION_NOT_FOUND: "session.not_found";
+  readonly SESSION_ALREADY_EXISTS: "session.already_exists";
+  readonly SESSION_ID_INVALID: "session.id_invalid";
+  readonly SESSION_ID_REQUIRED: "session.id_required";
+  readonly SESSION_ID_EMPTY: "session.id_empty";
+  readonly SESSION_TITLE_EMPTY: "session.title_empty";
+  readonly SESSION_STATE_NOT_FOUND: "session.state_not_found";
+  readonly SESSION_STATE_INVALID: "session.state_invalid";
+  readonly SESSION_FORK_ACTIVE_TURN: "session.fork_active_turn";
+  readonly SESSION_EXPORT_NOT_FOUND: "session.export_not_found";
+  readonly SESSION_EXPORT_MISSING_VERSION: "session.export_missing_version";
+  readonly SESSION_CLOSED: "session.closed";
+  readonly SESSION_PERMISSION_MODE_INVALID: "session.permission_mode_invalid";
+  readonly SESSION_THINKING_EMPTY: "session.thinking_empty";
+  readonly SESSION_MODEL_EMPTY: "session.model_empty";
+  readonly SESSION_PLAN_MODE_INVALID: "session.plan_mode_invalid";
+  readonly SESSION_APPROVAL_HANDLER_ERROR: "session.approval_handler_error";
+  readonly SESSION_QUESTION_HANDLER_ERROR: "session.question_handler_error";
+  readonly SESSION_INIT_FAILED: "session.init_failed";
+  readonly AGENT_NOT_FOUND: "agent.not_found";
+  readonly TURN_AGENT_BUSY: "turn.agent_busy";
+  readonly MODEL_NOT_CONFIGURED: "model.not_configured";
+  readonly MODEL_CONFIG_INVALID: "model.config_invalid";
+  readonly AUTH_LOGIN_REQUIRED: "auth.login_required";
+  readonly CONTEXT_OVERFLOW: "context.overflow";
+  readonly LOOP_MAX_STEPS_EXCEEDED: "loop.max_steps_exceeded";
+  readonly PROVIDER_API_ERROR: "provider.api_error";
+  readonly PROVIDER_RATE_LIMIT: "provider.rate_limit";
+  readonly PROVIDER_AUTH_ERROR: "provider.auth_error";
+  readonly PROVIDER_CONNECTION_ERROR: "provider.connection_error";
+  readonly SKILL_NOT_FOUND: "skill.not_found";
+  readonly SKILL_TYPE_UNSUPPORTED: "skill.type_unsupported";
+  readonly SKILL_NAME_EMPTY: "skill.name_empty";
+  readonly RECORDS_WRITE_FAILED: "records.write_failed";
+  readonly COMPACTION_FAILED: "compaction.failed";
+  readonly BACKGROUND_TASK_ID_EMPTY: "background.task_id_empty";
+  readonly MCP_SERVER_NOT_FOUND: "mcp.server_not_found";
+  readonly MCP_SERVER_DISABLED: "mcp.server_disabled";
+  readonly MCP_STARTUP_FAILED: "mcp.startup_failed";
+  readonly MCP_TOOL_NAME_COLLISION: "mcp.tool_name_collision";
+  readonly REQUEST_INVALID: "request.invalid";
+  readonly REQUEST_WORK_DIR_REQUIRED: "request.work_dir_required";
+  readonly REQUEST_PROMPT_INPUT_EMPTY: "request.prompt_input_empty";
+  readonly SHELL_GIT_BASH_NOT_FOUND: "shell.git_bash_not_found";
+  readonly NOT_IMPLEMENTED: "not_implemented";
+  readonly INTERNAL: "internal";
+};
+type ByfErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+interface ByfErrorInfo {
+  readonly title: string;
+  readonly retryable: boolean;
+  /**
+   * Whether the code is a stable public contract. `false` reserves the
+   * right to rename or remove without a major version bump.
+   */
+  readonly public: boolean;
+  readonly action?: string;
+}
+declare const BYF_ERROR_INFO: {
+  readonly 'config.invalid': {
+    readonly title: "Invalid configuration";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Check config.toml and provider/model settings.";
+  };
+  readonly 'session.not_found': {
+    readonly title: "Session not found";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Check the session id or list available sessions.";
+  };
+  readonly 'session.already_exists': {
+    readonly title: "Session already exists";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Use a different session id or remove the existing session first.";
+  };
+  readonly 'session.id_invalid': {
+    readonly title: "Invalid session id";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Use a session id without path-traversal characters.";
+  };
+  readonly 'session.id_required': {
+    readonly title: "Session id required";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Provide a session id when calling this method.";
+  };
+  readonly 'session.id_empty': {
+    readonly title: "Session id is empty";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Provide a non-empty session id.";
+  };
+  readonly 'session.title_empty': {
+    readonly title: "Session title is empty";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Provide a non-empty session title.";
+  };
+  readonly 'session.state_not_found': {
+    readonly title: "Session state missing";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "The session directory is corrupted or missing state.json.";
+  };
+  readonly 'session.state_invalid': {
+    readonly title: "Session state invalid";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "The session state.json is corrupted; remove the session or repair the file.";
+  };
+  readonly 'session.fork_active_turn': {
+    readonly title: "Cannot fork session during active turn";
+    readonly retryable: true;
+    readonly public: true;
+    readonly action: "Wait for the active turn to complete before forking.";
+  };
+  readonly 'session.export_not_found': {
+    readonly title: "Session export directory missing";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "The session has not been persisted to disk yet.";
+  };
+  readonly 'session.export_missing_version': {
+    readonly title: "Export version is missing";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Provide a version when exporting the session.";
+  };
+  readonly 'session.closed': {
+    readonly title: "Session is closed";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Create a new session.";
+  };
+  readonly 'session.permission_mode_invalid': {
+    readonly title: "Invalid permission mode";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Use one of: yolo / manual / auto.";
+  };
+  readonly 'session.thinking_empty': {
+    readonly title: "Thinking value is empty";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Provide a non-empty thinking option.";
+  };
+  readonly 'session.model_empty': {
+    readonly title: "Model is empty";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Provide a non-empty model identifier.";
+  };
+  readonly 'session.plan_mode_invalid': {
+    readonly title: "Invalid plan mode";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Provide a boolean plan mode.";
+  };
+  readonly 'session.approval_handler_error': {
+    readonly title: "Approval handler threw";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Inspect the SDK approval handler for an unhandled exception.";
+  };
+  readonly 'session.question_handler_error': {
+    readonly title: "Question handler threw";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Inspect the SDK question handler for an unhandled exception.";
+  };
+  readonly 'session.init_failed': {
+    readonly title: "Session init failed";
+    readonly retryable: false;
+    readonly public: false;
+    readonly action: "Review the init failure details and try again.";
+  };
+  readonly 'agent.not_found': {
+    readonly title: "Agent not found";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Check the agent id or list available agents.";
+  };
+  readonly 'turn.agent_busy': {
+    readonly title: "Agent is busy";
+    readonly retryable: true;
+    readonly public: true;
+    readonly action: "Wait for the current turn to finish or steer it.";
+  };
+  readonly 'model.not_configured': {
+    readonly title: "No model configured";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Set a default model in config.toml or via setModel.";
+  };
+  readonly 'model.config_invalid': {
+    readonly title: "Invalid model configuration";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Check the model and provider entries in config.toml.";
+  };
+  readonly 'auth.login_required': {
+    readonly title: "Login required";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Run the login flow for the provider before retrying.";
+  };
+  readonly 'context.overflow': {
+    readonly title: "Context window overflow";
+    readonly retryable: true;
+    readonly public: true;
+    readonly action: "Compact the conversation or start a new session.";
+  };
+  readonly 'loop.max_steps_exceeded': {
+    readonly title: "Turn exceeded max steps";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Increase loop_control.max_steps_per_turn or split the task.";
+  };
+  readonly 'provider.api_error': {
+    readonly title: "Provider API error";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Inspect details.statusCode / details.requestId; check provider status.";
+  };
+  readonly 'provider.rate_limit': {
+    readonly title: "Provider rate limit";
+    readonly retryable: true;
+    readonly public: true;
+    readonly action: "Retry after a delay or reduce request frequency.";
+  };
+  readonly 'provider.auth_error': {
+    readonly title: "Provider authentication error";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Re-authenticate with the provider.";
+  };
+  readonly 'provider.connection_error': {
+    readonly title: "Provider connection error";
+    readonly retryable: true;
+    readonly public: true;
+    readonly action: "Check network connectivity and retry.";
+  };
+  readonly 'skill.not_found': {
+    readonly title: "Skill not found";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "List available skills via the skill registry.";
+  };
+  readonly 'skill.type_unsupported': {
+    readonly title: "Skill type not supported";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Only inline skills can be activated by the user.";
+  };
+  readonly 'skill.name_empty': {
+    readonly title: "Skill name is empty";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Provide a non-empty skill name.";
+  };
+  readonly 'records.write_failed': {
+    readonly title: "Failed to write records";
+    readonly retryable: true;
+    readonly public: true;
+    readonly action: "Check disk space and permissions on the session directory.";
+  };
+  readonly 'compaction.failed': {
+    readonly title: "Compaction failed";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Inspect logs and consider increasing compaction limits.";
+  };
+  readonly 'background.task_id_empty': {
+    readonly title: "Background task id is empty";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Provide a non-empty task id.";
+  };
+  readonly 'mcp.server_not_found': {
+    readonly title: "MCP server not found";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "List configured MCP servers and check the requested name.";
+  };
+  readonly 'mcp.server_disabled': {
+    readonly title: "MCP server is disabled";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Enable the MCP server entry in config before reconnecting.";
+  };
+  readonly 'mcp.startup_failed': {
+    readonly title: "MCP server startup failed";
+    readonly retryable: true;
+    readonly public: true;
+    readonly action: "Inspect the MCP server log or call reconnect once the server is healthy.";
+  };
+  readonly 'mcp.tool_name_collision': {
+    readonly title: "MCP tool name collision";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Rename one of the colliding MCP tools or servers so their qualified names are unique.";
+  };
+  readonly 'request.invalid': {
+    readonly title: "Invalid request";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Check the input shape matches the API contract.";
+  };
+  readonly 'request.work_dir_required': {
+    readonly title: "workDir is required";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Provide workDir in the request payload.";
+  };
+  readonly 'request.prompt_input_empty': {
+    readonly title: "Prompt input is empty";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Provide non-empty prompt input.";
+  };
+  readonly 'shell.git_bash_not_found': {
+    readonly title: "Git Bash not found";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Install Git for Windows from https://gitforwindows.org/ or set BYF_SHELL_PATH to a bash.exe.";
+  };
+  readonly not_implemented: {
+    readonly title: "Not implemented";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "This feature is not implemented yet.";
+  };
+  readonly internal: {
+    readonly title: "Internal error";
+    readonly retryable: false;
+    readonly public: true;
+    readonly action: "Inspect logs or report the issue with diagnostics.";
+  };
+};
+//#endregion
+//#region src/errors/classes.d.ts
+interface ByfErrorOptions {
+  /** JSON-serializable structured details. */
+  readonly details?: Record<string, unknown>;
+  /** Original error or value. Local-only; never serialized to the wire. */
+  readonly cause?: unknown;
+}
+/**
+ * The single Byf error class.
+ *
+ * Discrimination is always by `code`. Cross-process consumers receive
+ * `ByfErrorPayload` and must branch on `code` rather than class identity.
+ */
+declare class ByfError extends Error {
+  readonly code: ByfErrorCode;
+  readonly details?: Record<string, unknown>;
+  readonly cause?: unknown;
+  constructor(code: ByfErrorCode, message: string, options?: ByfErrorOptions);
+}
+//#endregion
+//#region src/errors/serialize.d.ts
+/**
+ * Wire-safe payload of a Byf error.
+ *
+ * The structure passed across process / language boundaries (RPC, events,
+ * telemetry, SDK wrappers). Class identity does not survive the boundary;
+ * downstream code must branch on `code` rather than `instanceof`.
+ *
+ * `details` is JSON-serialized. `cause` is intentionally absent -- it is
+ * local-only diagnostic state and must not cross the boundary.
+ */
+interface ByfErrorPayload {
+  readonly code: ByfErrorCode;
+  readonly message: string;
+  readonly name?: string;
+  readonly details?: Record<string, unknown>;
+  readonly retryable: boolean;
+}
+/** Type guard for ByfError. */
+declare function isByfError(error: unknown): error is ByfError;
+/**
+ * Build a ByfErrorPayload directly from a code + message (no Error instance
+ * needed). Use this for synthetic error events that are signaled, not thrown
+ * -- e.g. "turn busy" or "compaction failed". `retryable` is filled from
+ * BYF_ERROR_INFO so callers cannot drift out of sync with the registry.
+ */
+declare function makeErrorPayload(code: ByfErrorCode, message: string, options?: {
+  readonly details?: Record<string, unknown>;
+  readonly name?: string;
+}): ByfErrorPayload;
+/**
+ * Normalize any value into a ByfErrorPayload.
+ *
+ * Recognized errors:
+ * - `ByfError`: passthrough.
+ * - `APIStatusError`: 429 -> rate_limit, 401 -> auth_error, otherwise -> api_error.
+ * - `APIConnectionError` / `APITimeoutError`: connection_error.
+ * - `ChatProviderError`: api_error.
+ * - Heuristic "Model not set" / "Provider not set" messages: model.not_configured.
+ *
+ * Anything else collapses to `internal`. We never echo `cause` or stack on
+ * the wire.
+ */
+declare function toByfErrorPayload(error: unknown): ByfErrorPayload;
+/**
+ * Rehydrate a ByfErrorPayload into a ByfError. Used by SDK boundary code
+ * receiving errors over RPC to re-surface them with a real class so
+ * in-process consumers can still use `instanceof`.
+ */
+declare function fromByfErrorPayload(payload: ByfErrorPayload): ByfError;
+//#endregion
+//#region src/rpc/events.d.ts
+interface UsageStatus$1 {
+  readonly byModel?: Record<string, TokenUsage> | undefined;
+  readonly currentTurn?: TokenUsage | undefined;
+  readonly total?: TokenUsage | undefined;
+}
+interface ToolUpdate {
+  readonly kind: 'stdout' | 'stderr' | 'progress' | 'status' | 'custom';
+  readonly text?: string | undefined;
+  readonly percent?: number | undefined;
+  readonly customKind?: string | undefined;
+  readonly customData?: unknown;
+}
+declare const MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE = "mcp.oauth.authorization_url";
+interface McpOAuthAuthorizationUrlUpdateData {
+  readonly serverName: string;
+  readonly authorizationUrl: string;
+}
+interface CompactionResult {
+  readonly summary: string;
+  readonly compactedCount: number;
+  readonly tokensBefore: number;
+  readonly tokensAfter: number;
+}
+type TurnEndReason = 'completed' | 'cancelled' | 'failed';
+interface AgentStatusUpdatedEvent {
+  readonly type: 'agent.status.updated';
+  readonly model?: string | undefined;
+  readonly contextTokens?: number | undefined;
+  readonly maxContextTokens?: number | undefined;
+  readonly contextUsage?: number | undefined;
+  readonly planMode?: boolean | undefined;
+  readonly permission?: PermissionMode$1 | undefined;
+  readonly usage?: UsageStatus$1 | undefined;
+}
+interface SessionMetaUpdatedEvent {
+  readonly type: 'session.meta.updated';
+  readonly title?: string | undefined;
+  readonly patch?: Record<string, unknown> | undefined;
+}
+interface SkillActivatedEvent {
+  readonly type: 'skill.activated';
+  readonly activationId: string;
+  readonly skillName: string;
+  readonly skillArgs?: string | undefined;
+  readonly trigger: 'user-slash' | 'model-tool' | 'nested-skill';
+  readonly skillPath?: string | undefined;
+  readonly skillSource?: SkillSource | undefined;
+}
+interface ErrorEvent extends ByfErrorPayload {
+  readonly type: 'error';
+}
+interface WarningEvent {
+  readonly type: 'warning';
+  readonly message: string;
+  readonly code?: string | undefined;
+}
+interface TurnStartedEvent {
+  readonly type: 'turn.started';
+  readonly turnId: number;
+  readonly origin: PromptOrigin;
+}
+interface TurnEndedEvent {
+  readonly type: 'turn.ended';
+  readonly turnId: number;
+  readonly reason: TurnEndReason;
+  readonly error?: ByfErrorPayload | undefined;
+}
+interface TurnStepStartedEvent {
+  readonly type: 'turn.step.started';
+  readonly turnId: number;
+  readonly step: number;
+  readonly stepId?: string | undefined;
+}
+interface TurnStepCompletedEvent {
+  readonly type: 'turn.step.completed';
+  readonly turnId: number;
+  readonly step: number;
+  readonly stepId?: string | undefined;
+  readonly usage?: TokenUsage | undefined;
+  readonly finishReason?: string | undefined;
+  readonly providerFinishReason?: FinishReason | undefined;
+  readonly rawFinishReason?: string | undefined;
+}
+interface TurnStepRetryingEvent {
+  readonly type: 'turn.step.retrying';
+  readonly turnId: number;
+  readonly step: number;
+  readonly stepId?: string;
+  readonly failedAttempt: number;
+  readonly nextAttempt: number;
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+  readonly errorName: string;
+  readonly errorMessage: string;
+  readonly statusCode?: number;
+}
+interface TurnStepInterruptedEvent {
+  readonly type: 'turn.step.interrupted';
+  readonly turnId: number;
+  readonly step: number;
+  readonly stepId?: string | undefined;
+  readonly reason: string;
+  readonly message?: string | undefined;
+}
+interface AssistantDeltaEvent {
+  readonly type: 'assistant.delta';
+  readonly turnId: number;
+  readonly delta: string;
+}
+interface HookResultEvent {
+  readonly type: 'hook.result';
+  readonly turnId: number;
+  readonly hookEvent: string;
+  readonly content: string;
+  readonly blocked?: boolean | undefined;
+}
+interface ThinkingDeltaEvent {
+  readonly type: 'thinking.delta';
+  readonly turnId: number;
+  readonly delta: string;
+}
+interface ToolCallDeltaEvent {
+  readonly type: 'tool.call.delta';
+  readonly turnId: number;
+  readonly toolCallId: string;
+  readonly name?: string | undefined;
+  readonly argumentsPart?: string | undefined;
+}
+interface ToolCallStartedEvent {
+  readonly type: 'tool.call.started';
+  readonly turnId: number;
+  readonly toolCallId: string;
+  readonly name: string;
+  readonly args: unknown;
+  readonly description?: string | undefined;
+  readonly display?: ToolInputDisplay | undefined;
+}
+interface ToolProgressEvent {
+  readonly type: 'tool.progress';
+  readonly turnId: number;
+  readonly toolCallId: string;
+  readonly update: ToolUpdate;
+}
+interface ToolResultEvent {
+  readonly type: 'tool.result';
+  readonly turnId: number;
+  readonly toolCallId: string;
+  readonly output: unknown;
+  readonly isError?: boolean | undefined;
+  readonly synthetic?: boolean | undefined;
+}
+interface SubagentSpawnedEvent {
+  readonly type: 'subagent.spawned';
+  readonly subagentId: string;
+  readonly subagentName: string;
+  readonly parentToolCallId: string;
+  readonly parentToolCallUuid?: string | undefined;
+  readonly parentAgentId?: string | undefined;
+  readonly description?: string | undefined;
+  readonly runInBackground: boolean;
+}
+interface SubagentCompletedEvent {
+  readonly type: 'subagent.completed';
+  readonly subagentId: string;
+  readonly parentToolCallId: string;
+  readonly resultSummary: string;
+  readonly usage?: TokenUsage | undefined;
+}
+interface SubagentFailedEvent {
+  readonly type: 'subagent.failed';
+  readonly subagentId: string;
+  readonly parentToolCallId: string;
+  readonly error: string;
+}
+interface CompactionStartedEvent {
+  readonly type: 'compaction.started';
+  readonly trigger: 'manual' | 'auto';
+  readonly instruction?: string | undefined;
+}
+interface CompactionBlockedEvent {
+  readonly type: 'compaction.blocked';
+  readonly turnId?: number | undefined;
+}
+interface CompactionCancelledEvent {
+  readonly type: 'compaction.cancelled';
+}
+interface CompactionCompletedEvent {
+  readonly type: 'compaction.completed';
+  readonly result: CompactionResult;
+}
+interface BackgroundTaskStartedEvent {
+  readonly type: 'background.task.started';
+  readonly info: BackgroundTaskInfo$1;
+}
+interface BackgroundTaskUpdatedEvent {
+  readonly type: 'background.task.updated';
+  readonly info: BackgroundTaskInfo$1;
+}
+interface BackgroundTaskTerminatedEvent {
+  readonly type: 'background.task.terminated';
+  readonly info: BackgroundTaskInfo$1;
+}
+type ToolListUpdatedReason = 'mcp.connected' | 'mcp.disconnected' | 'mcp.failed';
+interface ToolListUpdatedEvent {
+  readonly type: 'tool.list.updated';
+  readonly reason: ToolListUpdatedReason;
+  readonly serverName: string;
+}
+interface McpServerStatusEvent {
+  readonly type: 'mcp.server.status';
+  readonly server: McpServerStatusPayload;
+}
+interface McpServerStatusPayload {
+  readonly name: string;
+  readonly transport: 'stdio' | 'http';
+  readonly status: 'pending' | 'connected' | 'failed' | 'disabled' | 'needs-auth';
+  readonly toolCount: number;
+  readonly error?: string | undefined;
+}
+type AgentEvent$1 = ErrorEvent | WarningEvent | AgentStatusUpdatedEvent | SessionMetaUpdatedEvent | SkillActivatedEvent | TurnStartedEvent | TurnEndedEvent | TurnStepStartedEvent | TurnStepCompletedEvent | TurnStepRetryingEvent | TurnStepInterruptedEvent | AssistantDeltaEvent | HookResultEvent | ThinkingDeltaEvent | ToolCallDeltaEvent | ToolCallStartedEvent | ToolProgressEvent | ToolResultEvent | ToolListUpdatedEvent | McpServerStatusEvent | SubagentSpawnedEvent | SubagentCompletedEvent | SubagentFailedEvent | CompactionStartedEvent | CompactionBlockedEvent | CompactionCancelledEvent | CompactionCompletedEvent | BackgroundTaskStartedEvent | BackgroundTaskUpdatedEvent | BackgroundTaskTerminatedEvent;
+type Event = AgentEvent$1 & {
+  agentId: string;
+  sessionId: string;
+};
+//#endregion
+//#region src/rpc/resumed.d.ts
+type AgentReplayRecord = {
+  type: 'message';
+  message: ContextMessage;
+} | {
+  type: 'plan_updated';
+  enabled: boolean;
+} | {
+  type: 'config_updated';
+  config: AgentConfigUpdateData;
+} | {
+  type: 'permission_updated';
+  mode: PermissionMode;
+} | {
+  type: 'approval_result';
+  record: PermissionApprovalResultRecord;
+};
+interface ResumedAgentState {
+  readonly type: AgentType;
+  readonly config: AgentConfigData;
+  readonly context: AgentContextData;
+  readonly replay: readonly AgentReplayRecord[];
+  readonly permission: PermissionData;
+  readonly plan: PlanData;
+  readonly usage: UsageStatus$1;
+  readonly tools: readonly ToolInfo[];
+  readonly toolStore?: Readonly<Record<string, unknown>>;
+  readonly background: readonly BackgroundTaskInfo[];
+}
+interface ResumeSessionResult extends SessionSummary {
+  readonly sessionMetadata: SessionMeta;
+  readonly agents: Readonly<Record<string, ResumedAgentState>>;
+  readonly warning?: string | undefined;
+}
+//#endregion
+//#region src/rpc/types.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type WithExtraPayload<T, U> = { [K in keyof T]: T[K] extends ((payload: infer P) => infer R) ? (payload: Prettify<P & U>) => R : never };
+type WithAgentId<T> = WithExtraPayload<T, {
+  readonly agentId: string;
+}>;
+type WithSessionId<T> = WithExtraPayload<T, {
+  readonly sessionId: string;
+}>;
+declare function proxyWithExtraPayload<T, U>(methods: RPCMethods<WithExtraPayload<T, U>>, extraPayload: U): RPCMethods<T>;
+//#endregion
+//#region src/rpc/core-api.d.ts
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+  readonly [key: string]: JsonValue;
+};
+type JsonObject = {
+  readonly [key: string]: JsonValue;
+};
+type Unsubscribe = () => void;
+type TextPromptPart = Extract<ContentPart, {
+  type: 'text';
+}>;
+type PromptPart = Extract<ContentPart, {
+  type: 'text' | 'image_url' | 'video_url';
+}>;
+type PromptInput = readonly PromptPart[];
+type EmptyPayload = {};
+type SessionMetadataPatch = Partial<Omit<SessionMeta, 'agents'>>;
+interface CreateSessionPayload {
+  readonly id?: string | undefined;
+  readonly workDir: string;
+  readonly model?: string | undefined;
+  readonly thinking?: string | undefined;
+  readonly permission?: PermissionMode | undefined;
+  readonly metadata?: JsonObject | undefined;
+}
+interface CloseSessionPayload {
+  readonly sessionId: string;
+}
+interface ResumeSessionPayload {
+  readonly sessionId: string;
+}
+interface ForkSessionPayload {
+  readonly sessionId: string;
+  readonly id?: string;
+  readonly title?: string;
+  readonly metadata?: JsonObject;
+}
+interface ExportSessionPayload {
+  readonly sessionId: string;
+  readonly outputPath?: string | undefined;
+  /**
+   * When true, the active global diagnostic log (`$BYF_HOME/logs/byf.log`)
+   * is copied into the zip at `logs/global/byf.log`. Off by default to
+   * avoid bundling events from concurrent sessions / other projects.
+   */
+  readonly includeGlobalLog?: boolean | undefined;
+  /** Host version to record in the export manifest. */
+  readonly version: string;
+}
+interface ExportSessionManifest {
+  readonly sessionId: string;
+  readonly exportedAt: string;
+  readonly byfCodeVersion: string;
+  readonly wireProtocolVersion: string;
+  readonly os: string;
+  readonly nodejsVersion: string;
+  readonly sessionFirstActivity?: string | undefined;
+  readonly sessionLastActivity?: string | undefined;
+  readonly title?: string | undefined;
+  readonly workspaceDir?: string | undefined;
+  /** zip-relative path to the session diagnostic log when present. */
+  readonly sessionLogPath?: string | undefined;
+  /** zip-relative path to the bundled global diagnostic log (only when --include-global-log). */
+  readonly globalLogPath?: string | undefined;
+}
+interface ExportSessionResult {
+  readonly zipPath: string;
+  readonly entries: readonly string[];
+  readonly sessionDir: string;
+  readonly manifest: ExportSessionManifest;
+}
+interface ListSessionsPayload {
+  readonly workDir: string;
+}
+interface CoreInfo {
+  readonly version: string;
+}
+interface SessionSummary {
+  readonly id: string;
+  readonly title?: string | undefined;
+  readonly lastPrompt?: string;
+  readonly workDir: string;
+  readonly sessionDir: string;
+  readonly createdAt: number;
+  readonly updatedAt: number;
+  readonly archived?: boolean | undefined;
+  readonly metadata?: JsonObject | undefined;
+}
+interface PromptPayload {
+  readonly input: readonly ContentPart[];
+}
+interface SteerPayload {
+  readonly input: readonly ContentPart[];
+}
+interface CancelPayload {
+  readonly turnId?: number;
+}
+interface SetThinkingPayload {
+  readonly level: string;
+}
+interface SetPermissionPayload {
+  readonly mode: PermissionMode;
+}
+interface SetModelPayload {
+  readonly model: string;
+}
+interface SetModelResult {
+  readonly model: string;
+  readonly providerName?: string | undefined;
+}
+interface CancelPlanPayload {
+  readonly id?: string;
+}
+interface BeginCompactionPayload {
+  readonly instruction?: string;
+}
+interface RegisterToolPayload {
+  readonly name: string;
+  readonly description: string;
+  readonly parameters: Record<string, unknown>;
+}
+interface UnregisterToolPayload {
+  readonly name: string;
+}
+interface SetActiveToolsPayload {
+  readonly names: readonly string[];
+}
+interface StopBackgroundPayload {
+  readonly taskId: string;
+  /** Free-form human-readable reason persisted with the task record. */
+  readonly reason?: string;
+}
+interface GetBackgroundOutputPayload {
+  readonly taskId: string;
+  readonly tail?: number;
+}
+interface GetBackgroundOutputPathPayload {
+  readonly taskId: string;
+}
+interface GetBackgroundPayload {
+  /**
+   * When omitted, returns all tasks (including terminal/lost). Pass
+   * `true` to filter down to active-only — useful for model-facing
+   * surfaces. UI/TUI consumers should leave it undefined.
+   */
+  readonly activeOnly?: boolean;
+  /** Caps the number of tasks returned. When omitted, returns all matching tasks. */
+  readonly limit?: number;
+}
+interface SkillSummary {
+  readonly name: string;
+  readonly description: string;
+  readonly path: string;
+  readonly source: 'builtin' | 'user' | 'extra' | 'project';
+  readonly type?: string | undefined;
+  readonly disableModelInvocation?: boolean | undefined;
+}
+interface ActivateSkillPayload$1 {
+  readonly name: string;
+  readonly args?: string | undefined;
+}
+interface McpServerInfo {
+  readonly name: string;
+  readonly transport: 'stdio' | 'http';
+  readonly status: 'pending' | 'connected' | 'failed' | 'disabled' | 'needs-auth';
+  readonly toolCount: number;
+  readonly error?: string;
+}
+interface McpStartupMetrics {
+  readonly durationMs: number;
+}
+interface ReconnectMcpServerPayload {
+  readonly name: string;
+}
+interface RenameSessionPayload {
+  readonly title: string;
+}
+interface UpdateSessionMetadataPayload {
+  readonly metadata: SessionMetadataPatch;
+}
+type SetByfConfigPayload = ByfConfigPatch;
+interface RemoveByfProviderPayload {
+  readonly providerId: string;
+}
+interface ShellExecPayload {
+  readonly sessionId: string;
+  readonly command: string;
+  readonly cwd?: string;
+  readonly timeout?: number;
+}
+interface ShellExecResult {
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly exitCode: number;
+  readonly timedOut: boolean;
+}
+interface AgentAPI$1 {
+  prompt: (payload: PromptPayload) => void;
+  steer: (payload: SteerPayload) => void;
+  cancel: (payload: CancelPayload) => void;
+  setThinking: (payload: SetThinkingPayload) => void;
+  setPermission: (payload: SetPermissionPayload) => void;
+  setModel: (payload: SetModelPayload) => SetModelResult;
+  getModel: (payload: EmptyPayload) => string;
+  enterPlan: (payload: EmptyPayload) => void;
+  cancelPlan: (payload: CancelPlanPayload) => void;
+  clearPlan: (payload: EmptyPayload) => void;
+  beginCompaction: (payload: BeginCompactionPayload) => void;
+  cancelCompaction: (payload: EmptyPayload) => void;
+  registerTool: (payload: RegisterToolPayload) => void;
+  unregisterTool: (payload: UnregisterToolPayload) => void;
+  setActiveTools: (payload: SetActiveToolsPayload) => void;
+  stopBackground: (payload: StopBackgroundPayload) => void;
+  clearContext: (payload: EmptyPayload) => void;
+  activateSkill: (payload: ActivateSkillPayload$1) => void;
+  getBackgroundOutput: (payload: GetBackgroundOutputPayload) => string;
+  getBackgroundOutputPath: (payload: GetBackgroundOutputPathPayload) => string | undefined;
+  getContext: (payload: EmptyPayload) => AgentContextData;
+  getConfig: (payload: EmptyPayload) => AgentConfigData;
+  getPermission: (payload: EmptyPayload) => PermissionData;
+  getPlan: (payload: EmptyPayload) => PlanData;
+  getUsage: (payload: EmptyPayload) => UsageStatus$1;
+  getTools: (payload: EmptyPayload) => readonly ToolInfo[];
+  getBackground: (payload: GetBackgroundPayload) => readonly BackgroundTaskInfo[];
+}
+type AgentAPIWithId = WithAgentId<AgentAPI$1>;
+interface SessionAPI extends AgentAPIWithId {
+  renameSession: (payload: RenameSessionPayload) => void;
+  updateSessionMetadata: (payload: UpdateSessionMetadataPayload) => void;
+  getSessionMetadata: (payload: EmptyPayload) => SessionMeta;
+  listSkills: (payload: EmptyPayload) => readonly SkillSummary[];
+  listMcpServers: (payload: EmptyPayload) => readonly McpServerInfo[];
+  getMcpStartupMetrics: (payload: EmptyPayload) => McpStartupMetrics;
+  reconnectMcpServer: (payload: ReconnectMcpServerPayload) => void;
+  generateAgentsMd: (payload: EmptyPayload) => void;
+  shellExec: (payload: Omit<ShellExecPayload, 'sessionId'>) => Promise<ShellExecResult>;
+}
+type SessionAPIWithId = WithSessionId<SessionAPI>;
+interface CoreAPI extends SessionAPIWithId {
+  getCoreInfo: (payload: EmptyPayload) => CoreInfo;
+  getByfConfig: (payload: EmptyPayload) => ByfConfig;
+  setByfConfig: (payload: SetByfConfigPayload) => ByfConfig;
+  removeByfProvider: (payload: RemoveByfProviderPayload) => ByfConfig;
+  createSession: (payload: CreateSessionPayload) => SessionSummary;
+  closeSession: (payload: CloseSessionPayload) => void;
+  resumeSession: (payload: ResumeSessionPayload) => ResumeSessionResult;
+  forkSession: (payload: ForkSessionPayload) => ResumeSessionResult;
+  listSessions: (payload: ListSessionsPayload) => readonly SessionSummary[];
+  exportSession: (payload: ExportSessionPayload) => ExportSessionResult;
+}
+//#endregion
+//#region src/rpc/sdk-api.d.ts
+type ApprovalDecision = 'approved' | 'rejected' | 'cancelled';
+type ApprovalScope = 'session';
+interface ApprovalResponse {
+  readonly decision: ApprovalDecision;
+  readonly scope?: ApprovalScope | undefined;
+  readonly feedback?: string | undefined;
+  readonly selectedLabel?: string | undefined;
+}
+interface ApprovalRequest {
+  readonly turnId?: number | undefined;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly action: string;
+  readonly display: ToolInputDisplay;
+}
+interface QuestionOption {
+  readonly label: string;
+  readonly description?: string;
+}
+interface QuestionItem {
+  readonly question: string;
+  readonly header?: string;
+  readonly body?: string;
+  readonly options: readonly QuestionOption[];
+  readonly multiSelect?: boolean;
+  readonly otherLabel?: string;
+  readonly otherDescription?: string;
+}
+type QuestionAnswerMethod = 'enter' | 'space' | 'number_key';
+type QuestionAnswers = Record<string, string | true>;
+interface QuestionResponse {
+  readonly answers: QuestionAnswers;
+  readonly method?: QuestionAnswerMethod | undefined;
+}
+type QuestionResult = null | QuestionAnswers | QuestionResponse;
+interface QuestionRequest {
+  readonly turnId?: number;
+  readonly toolCallId?: string;
+  readonly questions: readonly QuestionItem[];
+}
+interface ToolCallRequest {
+  readonly turnId?: number | undefined;
+  readonly toolCallId: string;
+  readonly args: unknown;
+}
+interface ToolCallResponse {
+  readonly output: string | ContentPart[];
+  readonly isError?: boolean | undefined;
+}
+interface SDKAgentAPI {
+  emitEvent: (event: AgentEvent$1) => void;
+  requestApproval: (request: ApprovalRequest) => Promise<ApprovalResponse>;
+  requestQuestion: (request: QuestionRequest) => Promise<QuestionResult>;
+  toolCall: (request: ToolCallRequest) => Promise<ToolCallResponse>;
+}
+type SDKAgentRPC$1 = RPCMethods<SDKAgentAPI>;
+type SDKSessionAPI = WithAgentId<SDKAgentAPI>;
+type SDKSessionRPC$1 = RPCMethods<SDKSessionAPI>;
+type SDKAPI = WithSessionId<SDKSessionAPI>;
+type SDKRPC = RPCMethods<SDKAPI>;
+//#endregion
+//#region src/rpc/client.d.ts
+interface RPCCallOptions {
+  signal?: AbortSignal;
+}
+type RPCMethods<T> = { [K in keyof T]: T[K] extends ((payload: infer Payload) => infer Return) ? (payload: Payload, options?: RPCCallOptions) => Promisify<Return> : never };
+type RPCClient<Self extends Record<string, any>, Other extends Record<string, any>> = (self: PromisableMethods<Self>) => Promise<RPCMethods<Other>>;
+declare function createRPC<Left extends Record<string, any>, Right extends Record<string, any>>(): [RPCClient<Left, Right>, RPCClient<Right, Left>];
+type CoreRPCClient = RPCClient<CoreAPI, SDKAPI>;
+type SDKRPCClient = RPCClient<SDKAPI, CoreAPI>;
+type CoreRPC = RPCMethods<CoreAPI>;
+//#endregion
+//#region src/rpc/core-impl.d.ts
+type AgentScopedPayload<T> = T & {
+  readonly agentId: string;
+};
+type SessionScopedPayload<T> = T & {
+  readonly sessionId: string;
+};
+type SessionAgentPayload<T> = SessionScopedPayload<AgentScopedPayload<T>>;
+type RenameSessionRequest = SessionScopedPayload<RenameSessionPayload>;
+type UpdateSessionMetadataRequest = SessionScopedPayload<UpdateSessionMetadataPayload>;
+interface ByfCoreOptions {
+  readonly homeDir?: string | undefined;
+  readonly configPath?: string | undefined;
+  readonly runtime?: RuntimeConfig | undefined;
+  readonly byfRequestHeaders?: Record<string, string> | undefined;
+  readonly resolveOAuthTokenProvider?: OAuthTokenProviderResolver | undefined;
+  readonly skillDirs?: readonly string[];
+  readonly telemetry?: TelemetryClient | undefined;
+}
+declare class ByfCore implements PromisableMethods<CoreAPI> {
+  protected readonly rpcClient: CoreRPCClient;
+  readonly sdk: Promise<SDKRPC>;
+  readonly homeDir: string;
+  readonly configPath: string;
+  readonly sessions: Map<string, Session>;
+  readonly telemetry: TelemetryClient;
+  private runtime;
+  private readonly userHomeDir;
+  private readonly byfRequestHeaders;
+  private readonly resolveOAuthTokenProvider;
+  private readonly skillDirs;
+  private readonly providerManager;
+  private readonly sessionStore;
+  constructor(rpcClient: CoreRPCClient, options?: ByfCoreOptions);
+  createSession(input: CreateSessionPayload): Promise<SessionSummary>;
+  getCoreInfo(): CoreInfo;
+  closeSession({
+    sessionId
+  }: CloseSessionPayload): Promise<void>;
+  resumeSession(input: ResumeSessionPayload): Promise<ResumeSessionResult>;
+  forkSession(input: ForkSessionPayload): Promise<ResumeSessionResult>;
+  listSessions(input: ListSessionsPayload): Promise<readonly SessionSummary[]>;
+  renameSession({
+    sessionId,
+    ...payload
+  }: RenameSessionRequest): Promise<void>;
+  exportSession(input: ExportSessionPayload): Promise<ExportSessionResult>;
+  getByfConfig(input?: EmptyPayload): Promise<ByfConfig$1>;
+  setByfConfig(input: SetByfConfigPayload): Promise<ByfConfig$1>;
+  removeByfProvider(input: RemoveByfProviderPayload): Promise<ByfConfig$1>;
+  prompt({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<PromptPayload>): Promise<void>;
+  steer({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<SteerPayload>): void | Promise<void>;
+  cancel({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<CancelPayload>): void | Promise<void>;
+  setModel({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<SetModelPayload>): Promise<SetModelResult>;
+  setThinking({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<SetThinkingPayload>): void | Promise<void>;
+  setPermission({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<SetPermissionPayload>): void | Promise<void>;
+  getModel({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<EmptyPayload>): string | Promise<string>;
+  enterPlan({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<EmptyPayload>): void | Promise<void>;
+  cancelPlan({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<CancelPlanPayload>): void | Promise<void>;
+  clearPlan({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<EmptyPayload>): void | Promise<void>;
+  beginCompaction({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<BeginCompactionPayload>): void | Promise<void>;
+  cancelCompaction({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<EmptyPayload>): void | Promise<void>;
+  registerTool({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<RegisterToolPayload>): void | Promise<void>;
+  unregisterTool({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<UnregisterToolPayload>): void | Promise<void>;
+  setActiveTools({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<SetActiveToolsPayload>): void | Promise<void>;
+  stopBackground({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<StopBackgroundPayload>): void | Promise<void>;
+  clearContext({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<EmptyPayload>): void | Promise<void>;
+  activateSkill({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<ActivateSkillPayload$1>): Promise<void>;
+  getBackgroundOutput({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<GetBackgroundOutputPayload>): string | Promise<string>;
+  getBackgroundOutputPath({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<GetBackgroundOutputPathPayload>): string | Promise<string | undefined> | undefined;
+  getContext({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<EmptyPayload>): AgentContextData$1 | Promise<AgentContextData$1>;
+  getConfig({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<EmptyPayload>): AgentConfigData$1 | Promise<AgentConfigData$1>;
+  getPermission({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<EmptyPayload>): PermissionData$1 | Promise<PermissionData$1>;
+  getPlan({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<EmptyPayload>): PlanData$1 | Promise<PlanData$1>;
+  getUsage({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<EmptyPayload>): UsageStatus$1 | Promise<UsageStatus$1>;
+  getTools({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<EmptyPayload>): readonly ToolInfo$1[] | Promise<readonly ToolInfo$1[]>;
+  getBackground({
+    sessionId,
+    ...payload
+  }: SessionAgentPayload<GetBackgroundPayload>): readonly BackgroundTaskInfo$1[] | Promise<readonly BackgroundTaskInfo$1[]>;
+  updateSessionMetadata({
+    sessionId,
+    ...payload
+  }: UpdateSessionMetadataRequest): Promise<void>;
+  getSessionMetadata({
+    sessionId,
+    ...payload
+  }: SessionScopedPayload<EmptyPayload>): SessionMeta$1;
+  listSkills({
+    sessionId,
+    ...payload
+  }: SessionScopedPayload<EmptyPayload>): Promise<readonly SkillSummary[]>;
+  listMcpServers({
+    sessionId,
+    ...payload
+  }: SessionScopedPayload<EmptyPayload>): readonly McpServerInfo[];
+  getMcpStartupMetrics({
+    sessionId,
+    ...payload
+  }: SessionScopedPayload<EmptyPayload>): Promise<McpStartupMetrics>;
+  reconnectMcpServer({
+    sessionId,
+    ...payload
+  }: SessionScopedPayload<ReconnectMcpServerPayload>): Promise<void>;
+  generateAgentsMd({
+    sessionId,
+    ...payload
+  }: SessionScopedPayload<EmptyPayload>): Promise<void>;
+  shellExec({
+    sessionId,
+    ...payload
+  }: SessionScopedPayload<Omit<ShellExecPayload, 'sessionId'>>): Promise<ShellExecResult>;
+  private resolveRuntime;
+  private resolveSessionSkillConfig;
+  private sessionApi;
+  private reloadProviderManager;
+  private refreshSessionRuntimeConfig;
+}
+//#endregion
+//#region src/agent/turn/index.d.ts
+interface TurnEndResult {
+  readonly event: TurnEndedEvent;
+  readonly stopReason?: LoopTurnStopReason;
+}
+declare class TurnFlow {
+  protected readonly agent: Agent;
+  private steerBuffer;
+  private turnId;
+  private activeTurn;
+  private readonly toolCallStartedAt;
+  private readonly toolCallDupType;
+  private readonly stepToolCallKeys;
+  private readonly telemetryModeByTurn;
+  private readonly currentStepByTurn;
+  private readonly interruptedTelemetryTurnIds;
+  private readonly stepFailureByTurn;
+  private currentStep;
+  constructor(agent: Agent);
+  prompt(input: readonly ContentPart[], origin?: PromptOrigin): number | null;
+  steer(input: readonly ContentPart[], origin?: PromptOrigin): number | null;
+  private launch;
+  restorePrompt(): void;
+  restoreSteer(input: readonly ContentPart[], origin: PromptOrigin): void;
+  cancel(turnId?: number): void;
+  get currentId(): number;
+  get hasActiveTurn(): boolean;
+  waitForCurrentTurn(signal?: AbortSignal | undefined): Promise<TurnEndResult>;
+  private abortTurn;
+  private flushSteerBuffer;
+  finishResume(): void;
+  private turnWorker;
+  private applyUserPromptHook;
+  private runTurn;
+  private buildDispatchEvent;
+  private trackLoopTelemetry;
+  private beginTrackedStep;
+  private trackToolLifecycle;
+  private trackDuplicateToolCall;
+  private hasPriorStepToolCallKey;
+  private trackTurnInterrupted;
+  private telemetryMode;
+  private shouldTrackApiError;
+}
+//#endregion
+//#region src/agent/index.d.ts
+type AgentType$1 = 'main' | 'sub' | 'independent';
+interface AgentConfig {
+  readonly runtime: RuntimeConfig;
+  readonly homedir?: string;
+  readonly skills?: SkillRegistry;
+  readonly rpc: SDKAgentRPC;
+  readonly persistence?: AgentRecordPersistence;
+  readonly type?: AgentType$1;
+  readonly generate?: typeof generate;
+  readonly compactionStrategy?: CompactionStrategy;
+  readonly providerManager?: ProviderManager | undefined;
+  readonly sessionId?: string;
+  readonly subagentHost?: SessionSubagentHost | undefined;
+  readonly mcp?: McpConnectionManager;
+  readonly hookEngine?: HookEngine;
+  readonly backgroundMaxRunningTasks?: number;
+  readonly backgroundSessionDir?: string;
+  readonly permission?: PermissionManagerOptions | undefined;
+  /** Parent logger; the agent appends its own ctx (agentId already bound by session). */
+  readonly log?: Logger;
+  readonly telemetry?: TelemetryClient | undefined;
+}
+declare class Agent {
+  readonly runtime: RuntimeConfig;
+  readonly homedir?: string;
+  readonly skills?: SkillManager;
+  readonly rawGenerate: typeof generate;
+  readonly rpc: SDKAgentRPC;
+  readonly telemetry: TelemetryClient;
+  readonly providerManager: ProviderManager | undefined;
+  readonly subagentHost: SessionSubagentHost | undefined;
+  readonly mcp: McpConnectionManager | undefined;
+  readonly hooks: HookEngine | undefined;
+  readonly type: AgentType$1;
+  readonly records: AgentRecords;
+  readonly fullCompaction: FullCompaction;
+  readonly context: ContextMemory;
+  readonly config: ConfigState;
+  readonly turn: TurnFlow;
+  readonly injection: InjectionManager;
+  readonly permission: PermissionManager;
+  readonly planMode: PlanMode;
+  readonly usage: UsageRecorder;
+  readonly tools: ToolManager;
+  readonly background: BackgroundManager;
+  readonly replayBuilder: ReplayBuilder;
+  readonly log: Logger;
+  private lastLlmConfigLogSignature?;
+  constructor(config: AgentConfig);
+  get generate(): typeof generate;
+  private logLlmRequest;
+  private logLlmConfigIfChanged;
+  useProfile(profile: ResolvedAgentProfile, context?: PreparedSystemPromptContext): void;
+  resume(): Promise<{
+    warning?: string;
+  }>;
+  get rpcMethods(): PromisableMethods<AgentAPI>;
+  emitEvent(event: AgentEvent): void;
+  emitStatusUpdated(): void;
+  private emitRecordsWriteError;
+}
+//#endregion
+//#region src/session/export/wire-scan.d.ts
+interface SessionWireScan {
+  readonly firstActivityMs?: number | undefined;
+  readonly lastActivityMs?: number | undefined;
+  readonly lastUserMessageMs?: number | undefined;
+  readonly firstUserInput?: string | undefined;
+}
+declare function scanSessionWire(sessionDir: string): Promise<SessionWireScan>;
+declare function normalizeTimestampMs(value: number): number | undefined;
+//#endregion
+//#region src/session/export/manifest.d.ts
+declare const WIRE_PROTOCOL_VERSION = "1.1";
+declare function buildExportManifest(args: {
+  readonly summary: SessionSummary;
+  readonly now: Date;
+  readonly version: string;
+  readonly wireProtocolVersion?: string | undefined;
+  readonly sessionScan: SessionWireScan;
+  readonly sessionLogPath?: string | undefined;
+  readonly globalLogPath?: string | undefined;
+}): ExportSessionManifest;
+//#endregion
+//#region src/session/export/session-export.d.ts
+declare function exportSessionDirectory(input: {
+  readonly request: ExportSessionPayload;
+  readonly summary: SessionSummary;
+  readonly homeDir?: string | undefined;
+  readonly globalLogPath?: string | undefined;
+}): Promise<ExportSessionResult>;
+//#endregion
+//#region src/session/export/zip.d.ts
+declare function collectFilesRecursive(root: string): Promise<string[]>;
+type ExtraZipEntry = {
+  /** Absolute path on disk. */readonly source: string; /** zip-relative target path. */
+  readonly target: string;
+} | {
+  readonly data: Buffer; /** zip-relative target path. */
+  readonly target: string;
+};
+declare function writeExportZip(args: {
+  readonly outputPath: string;
+  readonly manifest: ExportSessionManifest;
+  readonly sessionDir: string;
+  readonly sessionFiles: readonly string[];
+  readonly extraEntries?: readonly ExtraZipEntry[];
+}): Promise<readonly string[]>;
+//#endregion
+//#region src/logging/resolve-config.d.ts
+interface ResolveLoggingInput {
+  readonly homeDir: string;
+  readonly env?: NodeJS.ProcessEnv | undefined;
+}
+/**
+ * Build the runtime `LoggingConfig` from env vars + defaults.
+ *
+ * v1 deliberately does not read `config.toml [logging]` — the schema is in
+ * flux and reading it adds a startup-time failure surface. Users who need to
+ * override the defaults set env vars:
+ *
+ *   BYF_LOG_LEVEL=debug
+ *   BYF_LOG_GLOBAL_MAX_BYTES=... BYF_LOG_GLOBAL_FILES=...
+ *   BYF_LOG_SESSION_MAX_BYTES=... BYF_LOG_SESSION_FILES=...
+ */
+declare function resolveLoggingConfig(input: ResolveLoggingInput): LoggingConfig;
+//#endregion
+export { CreateSessionPayload as $, SessionConfig as $n, resolveByfHome as $r, CompactionCancelledEvent as $t, QuestionItem as A, ProviderType as Ai, WarningEvent as An, LoopStepEndEvent as Ar, SetThinkingPayload as At, SDKSessionRPC$1 as B, LogEntry as Bi, ByfErrorInfo as Bn, BackgroundTaskStatus as Br, WithAgentId as Bt, createRPC as C, PermissionConfigSchema as Ci, TurnEndedEvent as Cn, ToolInfo$1 as Cr, SessionMetadataPatch as Ct, ApprovalScope as D, PermissionRuleScopeSchema as Di, TurnStepRetryingEvent as Dn, LoopContentPartEvent as Dr, SetModelPayload as Dt, ApprovalResponse as E, PermissionRuleSchema as Ei, TurnStepInterruptedEvent as En, ToolStoreUpdate as Er, SetByfConfigPayload as Et, SDKAPI as F, ThinkingConfigSchema as Fi, toByfErrorPayload as Fn, ExecutableToolSuccessResult as Fr, StopBackgroundPayload as Ft, BeginCompactionPayload as G, RootLogger as Gi, AgentRecordPersistence as Gn, parseConfigString as Gr, ResumedAgentState as Gt, ToolCallResponse as H, LogPayload as Hi, AgentRecord as Hn, OAuthTokenProviderResolver as Hr, proxyWithExtraPayload as Ht, SDKAgentAPI as I, formatConfigValidationError as Ii, ByfError as In, ToolInputDisplay as Ir, TextPromptPart as It, CancelPayload as J, RuntimeConfig as Jn, writeConfigFile as Jr, AssistantDeltaEvent as Jt, ByfConfig as K, SessionAttachInput as Ki, UsageRecordScope as Kn, readConfigFile as Kr, AgentEvent$1 as Kt, SDKAgentRPC$1 as L, getDefaultConfig as Li, ByfErrorOptions as Ln, BackgroundLifecycleEvent as Lr, UnregisterToolPayload as Lt, QuestionRequest as M, ServicesConfig as Mi, fromByfErrorPayload as Mn, LoopToolResultEvent as Mr, ShellExecResult as Mt, QuestionResponse as N, ServicesConfigSchema as Ni, isByfError as Nn, ExecutableToolErrorResult as Nr, SkillSummary as Nt, QuestionAnswerMethod as O, ProviderConfig$1 as Oi, TurnStepStartedEvent as On, LoopRecordedEvent as Or, SetModelResult as Ot, QuestionResult as P, ThinkingConfig as Pi, makeErrorPayload as Pn, ExecutableToolResult as Pr, SteerPayload as Pt, CoreInfo as Q, Session as Qn, ensureByfHome as Qr, CompactionBlockedEvent as Qt, SDKRPC as R, validateConfig as Ri, BYF_ERROR_INFO as Rn, BackgroundTaskInfo$1 as Rr, Unsubscribe as Rt, SDKRPCClient as S, PermissionConfig as Si, TurnEndReason as Sn, BuiltinTool as Sr, SessionAPI as St, ApprovalRequest as T, PermissionRuleDecisionSchema as Ti, TurnStepCompletedEvent as Tn, UserToolRegistration as Tr, SetActiveToolsPayload as Tt, ActivateSkillPayload$1 as U, Logger as Ui, AgentRecordEvents as Un, configToTomlData as Ur, AgentReplayRecord as Ut, ToolCallRequest as V, LogLevel as Vi, ErrorCodes as Vn, BearerTokenProvider as Vr, WithSessionId as Vt, AgentAPI$1 as W, LoggingConfig as Wi, AgentRecordOf as Wn, ensureConfigFile as Wr, ResumeSessionResult as Wt, CloseSessionPayload as X, SubagentHandle as Xn, parseBooleanEnv as Xr, BackgroundTaskTerminatedEvent as Xt, CancelPlanPayload as Y, SessionSubagentHost as Yn, ResolveConfigValueInput as Yr, BackgroundTaskStartedEvent as Yt, CoreAPI as Z, AgentMeta as Zn, resolveConfigValue as Zr, BackgroundTaskUpdatedEvent as Zt, CoreRPC as _, McpServerStdioConfigSchema as _i, ToolListUpdatedEvent as _n, flushDiagnosticLogs as _r, ReconnectMcpServerPayload as _t, writeExportZip as a, ByfConfigSchema as ai, MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE as an, TelemetryPropertyValue as ar, GetBackgroundOutputPathPayload as at, RPCClient as b, OAuthRef$1 as bi, ToolResultEvent as bn, redact as br, RenameSessionPayload as bt, buildExportManifest as c, HookDefConfig as ci, McpServerStatusPayload as cn, PermissionApprovalResultRecord$1 as cr, JsonObject as ct, scanSessionWire as d, LoopControlSchema as di, SubagentCompletedEvent as dn, ContextMessage$1 as dr, ListSessionsPayload as dt, resolveConfigPath as ei, CompactionCompletedEvent as en, SessionMeta$1 as er, EmptyPayload as et, Agent as f, McpServerConfig as fi, SubagentFailedEvent as fn, PromptOrigin as fr, McpServerInfo as ft, ByfCoreOptions as g, McpServerStdioConfig as gi, ToolCallStartedEvent as gn, CompactionResult$1 as gr, PromptPayload as gt, ByfCore as h, McpServerHttpConfigSchema as hi, ToolCallDeltaEvent as hn, CompactionBeginData as hr, PromptPart as ht, collectFilesRecursive as i, ByfConfigPatchSchema as ii, HookResultEvent as in, TelemetryProperties as ir, ForkSessionPayload as it, QuestionOption as j, ProviderTypeSchema as ji, ByfErrorPayload as jn, LoopToolCallEvent as jr, ShellExecPayload as jt, QuestionAnswers as k, ProviderConfigSchema as ki, UsageStatus$1 as kn, LoopStepBeginEvent as kr, SetPermissionPayload as kt, SessionWireScan as l, HookDefSchema as li, SessionMetaUpdatedEvent as ln, PermissionMode$1 as lr, JsonPrimitive as lt, AgentType$1 as m, McpServerHttpConfig as mi, ThinkingDeltaEvent as mn, UserPromptOrigin as mr, PromptInput as mt, resolveLoggingConfig as n, BackgroundConfig as ni, ErrorEvent as nn, TelemetryClient as nr, ExportSessionPayload as nt, exportSessionDirectory as o, ByfServiceConfig as oi, McpOAuthAuthorizationUrlUpdateData as on, noopTelemetryClient as or, GetBackgroundOutputPayload as ot, AgentConfig as p, McpServerConfigSchema as pi, SubagentSpawnedEvent as pn, USER_PROMPT_ORIGIN as pr, McpStartupMetrics as pt, ByfConfigPatch as q, SessionLogHandle as qi, AgentConfigUpdateData$1 as qn, transformTomlData as qr, AgentStatusUpdatedEvent as qt, ExtraZipEntry as r, BackgroundConfigSchema as ri, Event as rn, TelemetryContextPatch as rr, ExportSessionResult as rt, WIRE_PROTOCOL_VERSION as s, ByfServiceConfigSchema as si, McpServerStatusEvent as sn, withTelemetryContext as sr, GetBackgroundPayload as st, ResolveLoggingInput as t, mergeConfigPatch as ti, CompactionStartedEvent as tn, SessionSkillConfig as tr, ExportSessionManifest as tt, normalizeTimestampMs as u, LoopControl as ui, SkillActivatedEvent as un, AgentContextData$1 as ur, JsonValue as ut, CoreRPCClient as v, ModelAlias as vi, ToolListUpdatedReason as vn, getRootLogger as vr, RegisterToolPayload as vt, ApprovalDecision as w, PermissionModeSchema as wi, TurnStartedEvent as wn, ToolSource as wr, SessionSummary as wt, RPCMethods as x, OAuthRefSchema as xi, ToolUpdate as xn, resolveGlobalLogPath as xr, ResumeSessionPayload as xt, RPCCallOptions as y, ModelAliasSchema as yi, ToolProgressEvent as yn, log as yr, RemoveByfProviderPayload as yt, SDKSessionAPI as z, LogContext as zi, ByfErrorCode as zn, BackgroundTaskKind as zr, UpdateSessionMetadataPayload as zt };