fengming 0.3.8 → 0.3.10

package/dist/agent-harness-runtime-C0bo62eY.d.ts

@@ -0,0 +1,913 @@
+import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { M as MemoryCitationsMode } from "./types.tools-CNVUa3Mn.js";
+import { l as ImageContent } from "./types-Bmp2ni51.js";
+import { o as ModelCompatConfig } from "./types.models-tLzRKUhq.js";
+import { _ as PromptImageOrderEntry, a as SourceReplyDeliveryMode } from "./types-CrmoEuWv.js";
+import { Fr as AgentToolUpdateCallback, Pr as AgentToolResult, jr as AgentTool, kr as AgentMessage } from "./proxy-Cap_Cuz3.js";
+import { Aa as ContextEngineRuntimeContext, As as ProviderRuntimePluginHandle, Bi as NormalizedUsage, Dr as CodexAppServerExtensionFactory, Er as CodexAppServerExtensionContext, Gr as AgentToolResultMiddlewareEvent, Hi as AgentRuntimePlan, La as TranscriptRewriteResult, Li as EmbeddedRunAttemptParams, Ri as EmbeddedRunAttemptResult, Sa as ContextEngine, Ui as BuildAgentRuntimePlanParams, Ur as AgentToolResultMiddleware, Wr as AgentToolResultMiddlewareContext, Xr as FengMingAgentToolResult, Zi as requestDeferredPluginToolApproval, _s as ExecToolDefaults, ka as ContextEnginePromptCacheInfo, kr as CodexAppServerToolResultEvent, ks as ProviderRuntimeModel, qi as ToolOutcomeObserver, ss as EmbeddedRunTrigger, xa as CompactResult, ya as AssembleResult, zi as PreemptiveCompactionRoute } from "./types-BQw1qXGl.js";
+import { d as InboundEventKind } from "./templating-suu09Bb-.js";
+import { n as SkillSnapshot } from "./types-Wc-qcoWB.js";
+import { s as SandboxFsBridge } from "./backend-handle.types-D7afWmft.js";
+import { t as DiagnosticTraceContext } from "./diagnostic-trace-context-DKGBqNVx.js";
+import { n as FailoverReason } from "./types-7Vl6d1IJ.js";
+import { r as AnyAgentTool } from "./common-qxbnVgma.js";
+import { s as AuthProfileStore } from "./types-BmXgNGah.js";
+import { Dr as ToolDefinition } from "./index-B0VJdRJQ2.js";
+import { t as SubsystemLogger } from "./subsystem-CfQVin8T.js";
+import { t as ModelAuthMode } from "./model-auth-Cw0HyYbs.js";
+import { P as PluginHookContextWindowSource, X as PluginHookLlmOutputEvent, Y as PluginHookLlmInputEvent, d as PluginHookBeforeAgentFinalizeEvent, l as PluginHookAgentContext, u as PluginHookAgentEndEvent } from "./hook-types-CSFVKhpv.js";
+import { t as OperatorScope } from "./operator-scopes-ijAvkvEk.js";
+import { t as getGlobalHookRunner } from "./hook-runner-global-y4VDdCfJ.js";
+import { t as BundleMcpDiagnostic } from "./bundle-mcp-DABlFCpS.js";
+import { s as EmbeddedAgentQueueMessageOptions } from "./runs-BKnbMejR.js";
+import { t as ProcessToolDefaults } from "./bash-tools.process-BKy5qLNB.js";
+import { M as SandboxContext } from "./sandbox-CIX5U_O2.js";
+import { t as SessionWriteLockAcquireTimeoutConfig } from "./session-write-lock-20UNZM3a.js";
+import { TSchema } from "typebox";
+
+//#region src/agents/codex-mcp-config.types.d.ts
+type CodexMcpServersConfig = Record<string, Record<string, unknown>>;
+type CodexBundleMcpThreadConfig = {
+  configPatch?: {
+    mcp_servers: CodexMcpServersConfig;
+  };
+  diagnostics: BundleMcpDiagnostic[];
+  evaluated: boolean;
+  fingerprint?: string;
+};
+type LoadCodexBundleMcpThreadConfigParams = {
+  workspaceDir: string;
+  cfg?: FengMingConfig;
+  toolsEnabled?: boolean;
+  disableTools?: boolean;
+  toolsAllow?: string[];
+};
+//#endregion
+//#region src/agents/harness/native-hook-relay.d.ts
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+declare const NATIVE_HOOK_RELAY_EVENTS: readonly ["pre_tool_use", "post_tool_use", "permission_request", "before_agent_finalize"];
+declare const NATIVE_HOOK_RELAY_PROVIDERS: readonly ["codex"];
+type NativeHookRelayEvent = (typeof NATIVE_HOOK_RELAY_EVENTS)[number];
+type NativeHookRelayProvider = (typeof NATIVE_HOOK_RELAY_PROVIDERS)[number];
+type NativeHookRelayInvocation = {
+  provider: NativeHookRelayProvider;
+  relayId: string;
+  event: NativeHookRelayEvent;
+  nativeEventName?: string;
+  agentId?: string;
+  sessionId: string;
+  sessionKey?: string;
+  runId: string;
+  cwd?: string;
+  model?: string;
+  turnId?: string;
+  transcriptPath?: string;
+  permissionMode?: string;
+  stopHookActive?: boolean;
+  lastAssistantMessage?: string;
+  toolName?: string;
+  toolUseId?: string;
+  rawPayload: JsonValue;
+  receivedAt: string;
+};
+type NativeHookRelayProcessResponse = {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+};
+type NativeHookRelayRegistration = {
+  relayId: string;
+  provider: NativeHookRelayProvider;
+  generationMismatchGraceExpiresAtMs?: number;
+  generationMismatchGraceAcceptedGeneration?: string;
+  agentId?: string;
+  sessionId: string;
+  sessionKey?: string;
+  config?: FengMingConfig;
+  runId: string;
+  channelId?: string;
+  allowedEvents: readonly NativeHookRelayEvent[];
+  expiresAtMs: number;
+  signal?: AbortSignal;
+};
+type NativeHookRelayRegistrationHandle = NativeHookRelayRegistration & {
+  generation?: string;
+  shouldRelayEvent: (event: NativeHookRelayEvent) => boolean;
+  commandForEvent: (event: NativeHookRelayEvent) => string;
+  renew: (ttlMs?: number) => void;
+  unregister: () => void;
+};
+type RegisterNativeHookRelayParams = {
+  provider: NativeHookRelayProvider;
+  relayId?: string;
+  generation?: string;
+  generationMismatchGraceMs?: number;
+  agentId?: string;
+  sessionId: string;
+  sessionKey?: string;
+  config?: FengMingConfig;
+  runId: string;
+  channelId?: string;
+  allowedEvents?: readonly NativeHookRelayEvent[];
+  ttlMs?: number;
+  command?: NativeHookRelayCommandOptions;
+  signal?: AbortSignal;
+};
+type NativeHookRelayCommandOptions = {
+  executable?: string;
+  nice?: number | false;
+  nodeExecutable?: string;
+  timeoutMs?: number;
+};
+type InvokeNativeHookRelayParams = {
+  provider: unknown;
+  relayId: unknown;
+  generation?: unknown;
+  event: unknown;
+  rawPayload: unknown;
+  requireGeneration?: boolean;
+};
+type NativeHookRelayPermissionDecision = "allow" | "deny";
+type NativeHookRelayPermissionApprovalResult = NativeHookRelayPermissionDecision | "allow-always" | "defer";
+type ActiveNativeHookRelayRegistrationHandle = NativeHookRelayRegistrationHandle & {
+  generation: string;
+};
+type NativeHookRelayPermissionApprovalRequest = {
+  provider: NativeHookRelayProvider;
+  agentId?: string;
+  sessionId: string;
+  sessionKey?: string;
+  runId: string;
+  toolName: string;
+  toolCallId?: string;
+  cwd?: string;
+  model?: string;
+  toolInput: Record<string, JsonValue>;
+  signal?: AbortSignal;
+};
+type NativeHookRelayPermissionApprovalRequester = (request: NativeHookRelayPermissionApprovalRequest) => Promise<NativeHookRelayPermissionApprovalResult>;
+type NativeHookRelayDeferredToolApprovalRequester = typeof requestDeferredPluginToolApproval;
+type NativeHookRelayDeferredApprovalOutcome = {
+  handled: true;
+  outcome: "approved-once";
+} | {
+  handled: true;
+  outcome: "denied";
+  reason: string;
+};
+declare function registerNativeHookRelay(params: RegisterNativeHookRelayParams): ActiveNativeHookRelayRegistrationHandle;
+declare function buildNativeHookRelayCommand(params: {
+  provider: NativeHookRelayProvider;
+  relayId: string;
+  generation?: string;
+  event: NativeHookRelayEvent;
+  timeoutMs?: number;
+  executable?: string;
+  nice?: number | false;
+  nodeExecutable?: string;
+}): string;
+declare function invokeNativeHookRelay(params: InvokeNativeHookRelayParams): Promise<NativeHookRelayProcessResponse>;
+declare function hasNativeHookRelayInvocation(params: {
+  relayId: string;
+  event: NativeHookRelayEvent;
+  toolUseId?: string;
+}): boolean;
+declare function resolveNativeHookRelayDeferredToolApproval(params: {
+  relayId: string;
+  toolUseId?: string;
+  signal?: AbortSignal;
+}): Promise<NativeHookRelayDeferredApprovalOutcome | undefined>;
+declare const testing: {
+  readonly clearNativeHookRelaysForTests: () => void;
+  readonly getNativeHookRelayInvocationsForTests: () => NativeHookRelayInvocation[];
+  readonly getNativeHookRelayRegistrationForTests: (relayId: string) => NativeHookRelayRegistration | undefined;
+  readonly getNativeHookRelayBridgeDirForTests: () => string;
+  readonly getNativeHookRelayBridgeRegistryPathForTests: (relayId: string) => string;
+  readonly getNativeHookRelayBridgeRecordForTests: (relayId: string) => Record<string, unknown> | undefined;
+  readonly isNativeHookRelayBridgeLookupRetryableForTests: (error: unknown, elapsedMs?: number) => boolean;
+  readonly formatPermissionApprovalDescriptionForTests: (request: NativeHookRelayPermissionApprovalRequest) => string;
+  readonly permissionRequestContentFingerprintForTests: (request: NativeHookRelayPermissionApprovalRequest) => string;
+  readonly permissionRequestToolInputKeyFingerprintForTests: (toolInput: Record<string, unknown>) => string;
+  readonly setNativeHookRelayPermissionApprovalRequesterForTests: (requester: NativeHookRelayPermissionApprovalRequester) => void;
+  readonly setNativeHookRelayDeferredToolApprovalRequesterForTests: (requester: NativeHookRelayDeferredToolApprovalRequester) => void;
+};
+//#endregion
+//#region src/plugins/hook-agent-context.d.ts
+declare function buildAgentHookContextChannelFields(params: {
+  sessionKey?: string | null;
+  messageChannel?: string | null;
+  messageProvider?: string | null;
+  currentChannelId?: string | null;
+  messageTo?: string | null;
+}): Pick<PluginHookAgentContext, "channelId" | "messageProvider">;
+//#endregion
+//#region src/agents/run-cleanup-timeout.d.ts
+type AgentCleanupLogger = {
+  warn: (message: string) => void;
+};
+declare function runAgentCleanupStep(params: {
+  runId: string;
+  sessionId: string;
+  step: string;
+  cleanup: () => Promise<void>;
+  getTimeoutDetails?: () => string | undefined;
+  log: AgentCleanupLogger;
+  env?: NodeJS.ProcessEnv;
+  timeoutMs?: number;
+}): Promise<void>;
+//#endregion
+//#region src/agents/embedded-agent-runner/logger.d.ts
+declare const log: SubsystemLogger;
+//#endregion
+//#region src/agents/runtime-plan/build.d.ts
+declare function buildAgentRuntimePlan(params: BuildAgentRuntimePlanParams): AgentRuntimePlan;
+//#endregion
+//#region src/agents/model-fallback.d.ts
+type ModelFallbackResultClassification = {
+  message: string;
+  reason?: FailoverReason;
+  status?: number;
+  code?: string;
+  rawError?: string;
+} | {
+  error: unknown;
+} | null | undefined;
+//#endregion
+//#region src/agents/embedded-agent-runner/result-fallback-classifier.d.ts
+declare function classifyEmbeddedAgentRunResultForModelFallback(params: {
+  provider: string;
+  model: string;
+  result: unknown;
+  hasDirectlySentBlockReply?: boolean;
+  hasBlockReplyPipelineOutput?: boolean;
+}): ModelFallbackResultClassification;
+//#endregion
+//#region src/agents/tools/gateway.d.ts
+type GatewayCallOptions = {
+  gatewayUrl?: string;
+  gatewayToken?: string;
+  timeoutMs?: number;
+};
+declare function callGatewayTool<T = Record<string, unknown>>(method: string, opts: GatewayCallOptions, params?: unknown, extra?: {
+  expectFinal?: boolean;
+  scopes?: OperatorScope[];
+}): Promise<T>;
+//#endregion
+//#region src/shared/node-list-types.d.ts
+type NodeListNode = {
+  nodeId: string;
+  displayName?: string;
+  platform?: string;
+  version?: string;
+  coreVersion?: string;
+  uiVersion?: string;
+  clientId?: string;
+  clientMode?: string;
+  remoteIp?: string;
+  deviceFamily?: string;
+  modelIdentifier?: string;
+  pathEnv?: string;
+  caps?: string[];
+  commands?: string[];
+  permissions?: Record<string, boolean>;
+  paired?: boolean;
+  connected?: boolean;
+  connectedAtMs?: number;
+  lastSeenAtMs?: number;
+  lastSeenReason?: string;
+  approvedAtMs?: number;
+};
+//#endregion
+//#region src/agents/tools/nodes-utils.d.ts
+type DefaultNodeFallback = "none" | "first";
+type DefaultNodeSelectionOptions = {
+  capability?: string;
+  fallback?: DefaultNodeFallback;
+  preferLocalMac?: boolean;
+};
+declare function selectDefaultNodeFromList(nodes: NodeListNode[], options?: DefaultNodeSelectionOptions): NodeListNode | null;
+declare function listNodes(opts: GatewayCallOptions): Promise<NodeListNode[]>;
+declare function resolveNodeIdFromList(nodes: NodeListNode[], query?: string, allowDefault?: boolean): string;
+//#endregion
+//#region src/auto-reply/tool-meta.d.ts
+type ToolAggregateOptions = {
+  markdown?: boolean;
+};
+declare function formatToolAggregate(toolName?: string, metas?: string[], options?: ToolAggregateOptions): string;
+//#endregion
+//#region src/agents/embedded-agent-messaging.d.ts
+declare function isMessagingTool(toolName: string): boolean;
+declare function isMessagingToolSendAction(toolName: string, args: Record<string, unknown>): boolean;
+//#endregion
+//#region src/agents/embedded-agent-subscribe.tools.d.ts
+declare function filterToolResultMediaUrls(toolName: string | undefined, mediaUrls: string[], result?: unknown, trustedLocalMediaToolNames?: ReadonlySet<string>): string[];
+/**
+ * Extract media file paths from a tool result.
+ *
+ * Strategy (first match wins):
+ * 1. Read structured `details.media` attachments from tool details.
+ * 2. Parse `MEDIA:` directive tokens from text content blocks.
+ * 3. Fall back to `details.path` when image content exists (legacy imageResult).
+ *
+ * Returns an empty array when no media is found (e.g. embedded `read` tool
+ * returns base64 image data but no file path; those need a different delivery
+ * path like saving to a temp file).
+ */
+type ToolResultMediaArtifact = {
+  mediaUrls: string[];
+  audioAsVoice?: boolean;
+  trustedLocalMedia?: boolean;
+};
+declare function extractToolResultMediaArtifact(result: unknown): ToolResultMediaArtifact | undefined;
+//#endregion
+//#region src/agents/model-tool-support.d.ts
+declare function supportsModelTools(model: {
+  compat?: unknown;
+}): boolean;
+//#endregion
+//#region src/agents/embedded-agent-runner/run/attempt.prompt-helpers.d.ts
+declare function resolveAttemptFsWorkspaceOnly(params: {
+  config?: FengMingConfig;
+  sessionAgentId: string;
+}): boolean;
+type AfterTurnRuntimeContextAttempt = Pick<EmbeddedRunAttemptParams, "sessionKey" | "sandboxSessionKey" | "messageChannel" | "messageProvider" | "agentAccountId" | "currentChannelId" | "currentThreadTs" | "currentMessageId" | "config" | "skillsSnapshot" | "senderId" | "provider" | "modelId" | "agentHarnessId" | "thinkLevel" | "reasoningLevel" | "bashElevated" | "extraSystemPrompt" | "ownerNumbers" | "authProfileId"> & {
+  sessionId?: EmbeddedRunAttemptParams["sessionId"];
+};
+/** Build runtime context passed into context-engine afterTurn hooks. */
+declare function buildAfterTurnRuntimeContext(params: {
+  attempt: AfterTurnRuntimeContextAttempt;
+  workspaceDir: string;
+  cwd?: string;
+  agentDir: string;
+  activeAgentId?: string;
+  contextEnginePluginId?: string;
+  tokenBudget?: number;
+  currentTokenCount?: number;
+  promptCache?: ContextEnginePromptCacheInfo;
+}): ContextEngineRuntimeContext;
+declare function buildAfterTurnRuntimeContextFromUsage(params: Omit<Parameters<typeof buildAfterTurnRuntimeContext>[0], "currentTokenCount"> & {
+  lastCallUsage?: NormalizedUsage;
+}): ContextEngineRuntimeContext;
+//#endregion
+//#region src/agents/embedded-agent-runner/run/attempt.thread-helpers.d.ts
+declare function resolveAttemptSpawnWorkspaceDir(params: {
+  sandbox?: {
+    enabled?: boolean;
+    workspaceAccess?: string;
+  } | null;
+  resolvedWorkspace: string;
+}): string | undefined;
+//#endregion
+//#region src/agents/embedded-agent-runner/run/attempt.tool-run-context.d.ts
+declare function buildEmbeddedAttemptToolRunContext(params: {
+  trigger?: EmbeddedRunTrigger;
+  jobId?: string;
+  memoryFlushWritePath?: string;
+  toolsAllow?: string[];
+  trace?: DiagnosticTraceContext;
+}): {
+  trigger?: EmbeddedRunTrigger;
+  jobId?: string;
+  memoryFlushWritePath?: string;
+  runtimeToolAllowlist?: string[];
+  trace?: DiagnosticTraceContext;
+};
+//#endregion
+//#region src/agents/tool-search.d.ts
+type CatalogSource = "fengming" | "mcp" | "client";
+type CatalogTool = AnyAgentTool | ToolDefinition;
+type ToolSearchCatalogToolExecutor = (params: {
+  tool: CatalogTool;
+  toolName: string;
+  toolCallId: string;
+  parentToolCallId?: string;
+  input: unknown;
+  signal?: AbortSignal;
+  onUpdate?: AgentToolUpdateCallback;
+}) => Promise<AgentToolResult<unknown>>;
+type ToolSearchCatalogEntry = {
+  id: string;
+  source: CatalogSource;
+  sourceName?: string;
+  name: string;
+  label?: string;
+  description: string;
+  parameters?: unknown;
+  tool: CatalogTool;
+};
+type ToolSearchCatalogSession = {
+  entries: ToolSearchCatalogEntry[];
+  searchCount: number;
+  describeCount: number;
+  callCount: number;
+};
+type ToolSearchCatalogRef = {
+  current?: ToolSearchCatalogSession;
+};
+//#endregion
+//#region src/agents/agent-tools.d.ts
+type FengMingCodingToolConstructionPlan = {
+  includeBaseCodingTools: boolean;
+  includeShellTools: boolean;
+  includeChannelTools: boolean;
+  includeFengMingTools: boolean;
+  includePluginTools: boolean;
+};
+declare function createFengMingCodingTools(options?: {
+  agentId?: string;
+  exec?: ExecToolDefaults & ProcessToolDefaults;
+  messageProvider?: string;
+  agentAccountId?: string;
+  messageTo?: string;
+  messageThreadId?: string | number;
+  sandbox?: SandboxContext | null;
+  sessionKey?: string;
+  /**
+   * The actual live run session key. When the tool set is constructed with a
+   * sandbox/policy session key, this allows `session_status({sessionKey:"current"})`
+   * to resolve to the live run session instead of the stale sandbox key.
+   */
+  runSessionKey?: string; /** Ephemeral session UUID — regenerated on /new and /reset. */
+  sessionId?: string; /** Stable run identifier for this agent invocation. */
+  runId?: string; /** Diagnostic trace context for hook/log correlation during this run. */
+  trace?: DiagnosticTraceContext; /** What initiated this run (for trigger-specific tool restrictions). */
+  trigger?: string; /** Stable cron job identifier populated for cron-triggered runs. */
+  jobId?: string; /** Relative workspace path that memory-triggered writes may append to. */
+  memoryFlushWritePath?: string;
+  agentDir?: string; /** Task working directory for coding tools. Defaults to workspaceDir. */
+  cwd?: string;
+  workspaceDir?: string;
+  /**
+   * Workspace directory that spawned subagents should inherit.
+   * When sandboxing uses a copied workspace (`ro` or `none`), workspaceDir is the
+   * sandbox copy but subagents should inherit the real agent workspace instead.
+   * Defaults to workspaceDir when not set.
+   */
+  spawnWorkspaceDir?: string;
+  config?: FengMingConfig;
+  abortSignal?: AbortSignal; /** Disable hook-owned diagnostics when an outer runtime owns tool diagnostics. */
+  emitBeforeToolCallDiagnostics?: boolean;
+  /**
+   * Provider of the currently selected model (used for provider-specific tool quirks).
+   * Example: "anthropic", "openai", "google", "openai-codex".
+   */
+  modelProvider?: string; /** Model id for the current provider (used for model-specific tool gating). */
+  modelId?: string; /** Model API for the current provider (used for provider-native tool arbitration). */
+  modelApi?: string; /** Model context window in tokens (used to scale read-tool output budget). */
+  modelContextWindowTokens?: number; /** Resolved runtime model compatibility hints. */
+  modelCompat?: ModelCompatConfig; /** If false, keep FengMing web_search even when a provider-native search tool is active. */
+  suppressManagedWebSearch?: boolean;
+  /**
+   * Auth mode for the current provider. We only need this for Anthropic OAuth
+   * tool-name blocking quirks.
+   */
+  modelAuthMode?: ModelAuthMode; /** Current channel ID for auto-threading (Slack). */
+  currentChannelId?: string; /** Normalized conversation id exposed to tool hooks. Defaults to currentChannelId. */
+  hookChannelId?: string; /** Current thread timestamp for auto-threading (Slack). */
+  currentThreadTs?: string; /** Current inbound message id for action fallbacks (e.g. Telegram react). */
+  currentMessageId?: string | number; /** Group id for channel-level tool policy resolution. */
+  groupId?: string | null; /** Group channel label (e.g. #general) for channel-level tool policy resolution. */
+  groupChannel?: string | null; /** Group space label (e.g. guild/team id) for channel-level tool policy resolution. */
+  groupSpace?: string | null; /** Trusted provider role ids for the requester in this group turn. */
+  memberRoleIds?: string[]; /** Parent session key for subagent group policy inheritance. */
+  spawnedBy?: string | null;
+  senderId?: string | null;
+  senderName?: string | null;
+  senderUsername?: string | null;
+  senderE164?: string | null; /** Reply-to mode for Slack auto-threading. */
+  replyToMode?: "off" | "first" | "all" | "batched"; /** Mutable ref to track if a reply was sent (for "first" mode). */
+  hasRepliedRef?: {
+    value: boolean;
+  }; /** Allow plugin tools for this run to late-bind the gateway subagent. */
+  allowGatewaySubagentBinding?: boolean; /** Runtime-scoped explicit allowlist used to materialize matching plugin tools. */
+  runtimeToolAllowlist?: string[]; /** If true, the model has native vision capability */
+  modelHasVision?: boolean; /** Require explicit message targets (no implicit last-route sends). */
+  requireExplicitMessageTarget?: boolean; /** Visible source replies must be sent through the message tool when set to message_tool_only. */
+  sourceReplyDeliveryMode?: SourceReplyDeliveryMode;
+  inboundEventKind?: InboundEventKind; /** If true, omit the message tool from the tool list. */
+  disableMessageTool?: boolean; /** Keep the message tool available even when the selected profile omits it. */
+  forceMessageTool?: boolean; /** Include the heartbeat response tool for structured heartbeat outcomes. */
+  enableHeartbeatTool?: boolean; /** Keep the heartbeat response tool available even when the selected profile omits it. */
+  forceHeartbeatTool?: boolean; /** If false, build plugin tools only while preserving the shared policy pipeline. */
+  includeCoreTools?: boolean; /** Include Tool Search control tools when enabled for this run. */
+  includeToolSearchControls?: boolean; /** Executes cataloged tools through the active agent run lifecycle. */
+  toolSearchCatalogExecutor?: ToolSearchCatalogToolExecutor; /** Runtime-local Tool Search catalog ref shared with attempt compaction. */
+  toolSearchCatalogRef?: ToolSearchCatalogRef; /** Limits which tool families are materialized before the shared policy pipeline runs. */
+  toolConstructionPlan?: FengMingCodingToolConstructionPlan; /** Trusted sender identity bit for command/channel-action auth; does not filter model tools. */
+  senderIsOwner?: boolean; /** 认证配置s already loaded for this run; used for prompt-time tool availability. */
+  authProfileStore?: AuthProfileStore; /** Callback invoked when sessions_yield tool is called. */
+  onYield?: (message: string) => Promise<void> | void; /** Optional instrumentation callback for tool preparation stage timing. */
+  recordToolPrepStage?: (name: string) => void; /** Live observer called after wrapped tool outcomes are recorded. */
+  onToolOutcome?: ToolOutcomeObserver; /** Runtime-only resolved skill paths that the read tool may load under workspaceOnly. */
+  skillsSnapshot?: SkillSnapshot;
+}): AnyAgentTool[];
+//#endregion
+//#region src/agents/embedded-agent-runner/run/attempt-tool-construction-plan.d.ts
+declare function applyEmbeddedAttemptToolsAllow<T extends {
+  name: string;
+}>(tools: T[], toolsAllow?: string[], options?: {
+  toolMeta?: (tool: T) => {
+    pluginId: string;
+  } | undefined;
+}): T[];
+declare function resolveEmbeddedAttemptToolConstructionPlan(params: {
+  disableTools?: boolean;
+  isRawModelRun?: boolean;
+  toolsAllow?: string[];
+  forceMessageTool?: boolean;
+}): {
+  constructTools: boolean;
+  includeCoreTools: boolean;
+  runtimeToolAllowlist?: string[];
+  codingToolConstructionPlan: FengMingCodingToolConstructionPlan;
+};
+//#endregion
+//#region src/agents/harness/registry.d.ts
+declare function disposeRegisteredAgentHarnesses(): Promise<void>;
+//#endregion
+//#region src/agents/runtime-plan/tools.d.ts
+type AgentRuntimeToolPolicyParams<TSchemaType extends TSchema = TSchema, TResult = unknown> = {
+  runtimePlan?: AgentRuntimePlan;
+  tools: AgentTool<TSchemaType, TResult>[];
+  provider: string;
+  config?: FengMingConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  modelId?: string;
+  modelApi?: string | null;
+  model?: ProviderRuntimeModel;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+  allowProviderRuntimePluginLoad?: boolean;
+};
+declare function normalizeAgentRuntimeTools<TSchemaType extends TSchema = TSchema, TResult = unknown>(params: AgentRuntimeToolPolicyParams<TSchemaType, TResult>): AgentTool<TSchemaType, TResult>[];
+declare function logAgentRuntimeToolDiagnostics(params: AgentRuntimeToolPolicyParams): void;
+//#endregion
+//#region src/agents/tool-schema-projection.d.ts
+type RuntimeToolInputSchemaJson = null | boolean | number | string | RuntimeToolInputSchemaJson[] | {
+  [key: string]: RuntimeToolInputSchemaJson;
+};
+type RuntimeToolInputSchemaProjection = {
+  readonly schema: RuntimeToolInputSchemaJson;
+  readonly violations: readonly string[];
+};
+type RuntimeToolSchemaDiagnostic = {
+  readonly toolName: string;
+  readonly toolIndex: number;
+  readonly violations: readonly string[];
+};
+declare function projectRuntimeToolInputSchema(schema: unknown, path?: string): RuntimeToolInputSchemaProjection;
+declare function inspectRuntimeToolInputSchemas(tools: readonly Pick<AnyAgentTool, "name" | "parameters">[]): RuntimeToolSchemaDiagnostic[];
+//#endregion
+//#region src/agents/embedded-agent-runner/tool-schema-runtime.d.ts
+type ProviderToolSchemaParams<TSchemaType extends TSchema = TSchema, TResult = unknown> = {
+  tools: AgentTool<TSchemaType, TResult>[];
+  provider: string;
+  config?: FengMingConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  modelId?: string;
+  modelApi?: string | null;
+  model?: ProviderRuntimeModel;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+  allowRuntimePluginLoad?: boolean;
+};
+/**
+ * Runs provider-owned tool-schema normalization without encoding provider
+ * families in the embedded runner.
+ */
+declare function normalizeProviderToolSchemas<TSchemaType extends TSchema = TSchema, TResult = unknown>(params: ProviderToolSchemaParams<TSchemaType, TResult>): AgentTool<TSchemaType, TResult>[];
+//#endregion
+//#region src/agents/sandbox/fs-paths.d.ts
+declare function resolveWritableSandboxBindHostRoots(binds: readonly string[] | undefined): string[];
+declare function hasSandboxBindContainerPathAliases(binds: readonly string[] | undefined): boolean;
+declare function hasSandboxBindReadonlyHostShadows(binds: readonly string[] | undefined): boolean;
+//#endregion
+//#region src/agents/harness/hook-context.d.ts
+type AgentHarnessHookContext = {
+  runId: string;
+  jobId?: string;
+  agentId?: string;
+  sessionKey?: string;
+  sessionId?: string;
+  workspaceDir?: string;
+  modelProviderId?: string;
+  modelId?: string;
+  messageProvider?: string;
+  trigger?: string;
+  channelId?: string;
+  contextTokenBudget?: number;
+  contextWindowSource?: PluginHookContextWindowSource;
+  contextWindowReferenceTokens?: number;
+};
+//#endregion
+//#region src/agents/harness/prompt-compaction-hook-helpers.d.ts
+type AgentHarnessPromptBuildResult = {
+  prompt: string;
+  developerInstructions: string;
+};
+declare function resolveAgentHarnessBeforePromptBuildResult(params: {
+  prompt: string;
+  developerInstructions: string;
+  messages: unknown[];
+  ctx: AgentHarnessHookContext;
+}): Promise<AgentHarnessPromptBuildResult>;
+declare function runAgentHarnessBeforeCompactionHook(params: {
+  sessionFile: string;
+  messages: AgentMessage[];
+  ctx: AgentHarnessHookContext;
+}): Promise<void>;
+declare function runAgentHarnessAfterCompactionHook(params: {
+  sessionFile: string;
+  messages: AgentMessage[];
+  ctx: AgentHarnessHookContext;
+  compactedCount: number;
+}): Promise<void>;
+//#endregion
+//#region src/agents/harness/codex-app-server-extensions.d.ts
+declare function createCodexAppServerToolResultExtensionRunner(ctx: CodexAppServerExtensionContext, factories?: CodexAppServerExtensionFactory[]): {
+  applyToolResultExtensions(event: CodexAppServerToolResultEvent): Promise<AgentToolResult<unknown>>;
+};
+//#endregion
+//#region src/agents/harness/tool-result-middleware.d.ts
+declare function createAgentToolResultMiddlewareRunner(ctx: AgentToolResultMiddlewareContext, handlers?: AgentToolResultMiddleware[]): {
+  applyToolResultMiddleware(event: AgentToolResultMiddlewareEvent): Promise<FengMingAgentToolResult>;
+};
+//#endregion
+//#region src/agents/harness/context-engine-lifecycle.d.ts
+type HarnessContextEngine = ContextEngine;
+/**
+ * Run optional bootstrap + bootstrap maintenance for a harness-owned context engine.
+ */
+declare function bootstrapHarnessContextEngine(params: {
+  hadSessionFile: boolean;
+  contextEngine?: HarnessContextEngine;
+  sessionId: string;
+  sessionKey?: string;
+  sessionFile: string;
+  sessionManager?: unknown;
+  runtimeContext?: ContextEngineRuntimeContext;
+  runMaintenance?: typeof runHarnessContextEngineMaintenance;
+  config?: SessionWriteLockAcquireTimeoutConfig;
+  warn: (message: string) => void;
+}): Promise<void>;
+/**
+ * Assemble model context through the active harness-owned context engine.
+ */
+declare function assembleHarnessContextEngine(params: {
+  contextEngine?: HarnessContextEngine;
+  sessionId: string;
+  sessionKey?: string;
+  messages: AgentMessage[];
+  tokenBudget?: number;
+  availableTools?: Set<string>;
+  citationsMode?: MemoryCitationsMode;
+  modelId: string;
+  prompt?: string;
+}): Promise<AssembleResult | undefined>;
+/**
+ * Finalize a completed harness turn via afterTurn or ingest fallbacks.
+ */
+declare function finalizeHarnessContextEngineTurn(params: {
+  contextEngine?: HarnessContextEngine;
+  promptError: boolean;
+  aborted: boolean;
+  yieldAborted: boolean;
+  sessionIdUsed: string;
+  sessionKey?: string;
+  sessionFile: string;
+  messagesSnapshot: AgentMessage[];
+  prePromptMessageCount: number;
+  tokenBudget?: number;
+  runtimeContext?: ContextEngineRuntimeContext;
+  runMaintenance?: typeof runHarnessContextEngineMaintenance;
+  sessionManager?: unknown;
+  config?: SessionWriteLockAcquireTimeoutConfig;
+  warn: (message: string) => void;
+}): Promise<{
+  postTurnFinalizationSucceeded: boolean;
+}>;
+/**
+ * Build runtime context passed into harness context-engine hooks.
+ */
+declare function buildHarnessContextEngineRuntimeContext(params: Parameters<typeof buildAfterTurnRuntimeContext>[0]): ContextEngineRuntimeContext;
+/**
+ * Build runtime context passed into harness context-engine hooks from usage data.
+ */
+declare function buildHarnessContextEngineRuntimeContextFromUsage(params: Parameters<typeof buildAfterTurnRuntimeContextFromUsage>[0]): ContextEngineRuntimeContext;
+/**
+ * Run optional transcript maintenance for a harness-owned context engine.
+ */
+declare function runHarnessContextEngineMaintenance(params: {
+  contextEngine?: HarnessContextEngine;
+  sessionId: string;
+  sessionKey?: string;
+  sessionFile: string;
+  reason: "bootstrap" | "compaction" | "turn";
+  sessionManager?: unknown;
+  runtimeContext?: ContextEngineRuntimeContext;
+  executionMode?: "foreground" | "background";
+  onDeferredMaintenance?: (promise: Promise<void>) => void;
+  config?: SessionWriteLockAcquireTimeoutConfig;
+}): Promise<TranscriptRewriteResult | undefined>;
+/**
+ * Return true when a non-legacy context engine should affect plugin harness behavior.
+ */
+declare function isActiveHarnessContextEngine(contextEngine: ContextEngine | undefined): contextEngine is ContextEngine;
+//#endregion
+//#region src/agents/embedded-agent-runner/compaction-safety-timeout.d.ts
+declare function resolveCompactionTimeoutMs(cfg?: FengMingConfig): number;
+/** Parameters for a single {@link ContextEngine.compact} invocation. */
+type ContextEngineCompactParams = Parameters<ContextEngine["compact"]>[0];
+/**
+ * Invoke a plugin-owned {@link ContextEngine.compact} bounded by the same
+ * finite safety timeout that protects native runtime compaction.
+ *
+ * Plugin context engines that advertise `ownsCompaction` previously had their
+ * `compact()` awaited with no timeout, no watchdog, and no abort signal — a
+ * slow or hung plugin compaction would hang the agent turn indefinitely. This
+ * wrapper closes that gap:
+ *  - the call is bounded by `timeoutMs` (host-resolved, default
+ *    {@link EMBEDDED_COMPACTION_TIMEOUT_MS}); on timeout it rejects with a
+ *    "Compaction timed out" error so the caller's existing failure handling
+ *    runs instead of hanging;
+ *  - the timeout signal and caller `abortSignal` are both raced against the
+ *    call (so a non-cooperating engine is still bounded) and threaded into the
+ *    `compact()` params (so cooperating engines can cancel their own in-flight
+ *    work).
+ *
+ * Callers keep their existing try/catch — a timeout or abort surfaces as a
+ * thrown error, never a silent hang.
+ */
+declare function compactContextEngineWithSafetyTimeout(contextEngine: Pick<ContextEngine, "compact">, params: ContextEngineCompactParams, timeoutMs?: number, abortSignal?: AbortSignal): Promise<CompactResult>;
+//#endregion
+//#region src/agents/embedded-agent-runner/run/preemptive-compaction.d.ts
+declare const PREEMPTIVE_OVERFLOW_ERROR_TEXT = "Context overflow: prompt too large for the model (precheck).";
+type PreemptiveCompactionDecision = {
+  route: PreemptiveCompactionRoute;
+  shouldCompact: boolean;
+  estimatedPromptTokens: number;
+  pressureSource?: string;
+  promptBudgetBeforeReserve: number;
+  overflowTokens: number;
+  toolResultReducibleChars: number;
+  effectiveReserveTokens: number;
+};
+type LlmBoundaryTokenPressure = {
+  estimatedPromptTokens: number;
+  source: string;
+  renderedChars?: number;
+};
+declare function estimateRenderedLlmBoundaryTokenPressure(params: {
+  systemPrompt?: string;
+  prompt: string;
+}): number;
+declare function shouldPreemptivelyCompactBeforePrompt(params: {
+  messages: AgentMessage[];
+  unwindowedMessages?: AgentMessage[];
+  systemPrompt?: string;
+  prompt: string;
+  contextTokenBudget: number;
+  reserveTokens: number;
+  toolResultMaxChars?: number;
+  llmBoundaryTokenPressure?: LlmBoundaryTokenPressure;
+}): PreemptiveCompactionDecision;
+declare function formatPrePromptPrecheckLog(params: {
+  result: PreemptiveCompactionDecision;
+  sessionKey?: string;
+  sessionId?: string;
+  provider: string;
+  modelId: string;
+  messageCount: number;
+  unwindowedMessageCount?: number;
+  contextTokenBudget: number;
+  reserveTokens: number;
+  sessionFile?: string;
+}): string;
+//#endregion
+//#region src/agents/harness/hook-helpers.d.ts
+declare function runAgentHarnessAfterToolCallHook(params: {
+  toolName: string;
+  toolCallId: string;
+  runId?: string;
+  agentId?: string;
+  sessionId?: string;
+  sessionKey?: string;
+  channelId?: string;
+  startArgs: Record<string, unknown>;
+  result?: unknown;
+  error?: string;
+  startedAt?: number;
+}): Promise<void>;
+declare function runAgentHarnessBeforeMessageWriteHook(params: {
+  message: AgentMessage;
+  agentId?: string;
+  sessionKey?: string;
+}): AgentMessage | null;
+//#endregion
+//#region src/agents/harness/lifecycle-hook-helpers.d.ts
+type AgentHarnessHookRunner = ReturnType<typeof getGlobalHookRunner>;
+declare function getAgentHarnessHookRunner(): AgentHarnessHookRunner;
+declare function runAgentHarnessLlmInputHook(params: {
+  event: PluginHookLlmInputEvent;
+  ctx: AgentHarnessHookContext;
+  hookRunner?: AgentHarnessHookRunner;
+}): void;
+declare function runAgentHarnessLlmOutputHook(params: {
+  event: PluginHookLlmOutputEvent;
+  ctx: AgentHarnessHookContext;
+  hookRunner?: AgentHarnessHookRunner;
+}): void;
+declare function runAgentHarnessAgentEndHook(params: {
+  event: PluginHookAgentEndEvent;
+  ctx: AgentHarnessHookContext;
+  hookRunner?: AgentHarnessHookRunner;
+}): void;
+declare function awaitAgentHarnessAgentEndHook(params: {
+  event: PluginHookAgentEndEvent;
+  ctx: AgentHarnessHookContext;
+  hookRunner?: AgentHarnessHookRunner;
+}): Promise<void>;
+type AgentHarnessBeforeAgentFinalizeOutcome = {
+  action: "continue";
+} | {
+  action: "revise";
+  reason: string;
+} | {
+  action: "finalize";
+  reason?: string;
+};
+declare function runAgentHarnessBeforeAgentFinalizeHook(params: {
+  event: PluginHookBeforeAgentFinalizeEvent;
+  ctx: AgentHarnessHookContext;
+  hookRunner?: AgentHarnessHookRunner;
+}): Promise<AgentHarnessBeforeAgentFinalizeOutcome>;
+//#endregion
+//#region src/plugin-sdk/agent-harness-runtime.d.ts
+declare const TOOL_PROGRESS_OUTPUT_MAX_CHARS = 8000;
+/**
+ * @deprecated Active-run queueing is an internal runtime concern. This legacy
+ * boolean API only reports immediate queue eligibility and cannot observe async
+ * runtime rejection; runtime-owned delivery paths should use acceptance-aware
+ * steering instead of public SDK queueing.
+ */
+declare function queueAgentHarnessMessage(sessionId: string, text: string, options?: EmbeddedAgentQueueMessageOptions): boolean;
+declare function detectAndLoadAgentHarnessPromptImages(params: {
+  prompt: string;
+  workspaceDir: string;
+  model: {
+    input?: string[];
+  };
+  existingImages?: ImageContent[];
+  imageOrder?: PromptImageOrderEntry[];
+  config?: FengMingConfig;
+  workspaceOnly?: boolean;
+  localRoots?: readonly string[];
+  sandbox?: {
+    root: string;
+    bridge: SandboxFsBridge;
+  };
+}): Promise<{
+  images: ImageContent[];
+  detectedRefs: Array<{
+    raw: string;
+    resolved: string;
+    type: "path" | "media-uri";
+  }>;
+  loadedCount: number;
+  skippedCount: number;
+}>;
+declare function loadCodexBundleMcpThreadConfig(params: LoadCodexBundleMcpThreadConfigParams): Promise<CodexBundleMcpThreadConfig>;
+/**
+ * Derive the same compact user-facing tool detail that embedded FengMing uses for progress logs.
+ */
+type ToolProgressDetailMode = "explain" | "raw";
+declare function inferToolMetaFromArgs(toolName: string, args: unknown, options?: {
+  detailMode?: ToolProgressDetailMode;
+}): string | undefined;
+/**
+ * Prepare verbose tool output for user-facing progress messages.
+ */
+declare function formatToolProgressOutput(output: string, options?: {
+  maxChars?: number;
+}): string | undefined;
+type AgentHarnessTerminalOutcomeInput = {
+  assistantTexts: readonly string[];
+  reasoningText?: string | null;
+  planText?: string | null;
+  promptError?: unknown;
+  turnCompleted: boolean;
+};
+type AgentHarnessTerminalOutcomeClassification = NonNullable<EmbeddedRunAttemptResult["agentHarnessResultClassification"]>;
+/**
+ * Classify terminal harness turns that completed without assistant output that
+ * should advance fallback. Deliberate silent replies such as NO_REPLY count as
+ * intentional output, while whitespace-only text remains fallback-eligible.
+ * This is intentionally SDK-level so plugin harness adapters such as Codex
+ * preserve the same FengMing-owned fallback signals as the built-in FengMing path
+ * without re-implementing terminal-result policy.
+ */
+declare function classifyAgentHarnessTerminalOutcome(params: AgentHarnessTerminalOutcomeInput): AgentHarnessTerminalOutcomeClassification | undefined;
+//#endregion
+export { createFengMingCodingTools as $, buildHarnessContextEngineRuntimeContextFromUsage as A, LoadCodexBundleMcpThreadConfigParams as At, hasSandboxBindReadonlyHostShadows as B, formatPrePromptPrecheckLog as C, buildNativeHookRelayCommand as Ct, assembleHarnessContextEngine as D, resolveNativeHookRelayDeferredToolApproval as Dt, resolveCompactionTimeoutMs as E, registerNativeHookRelay as Et, createCodexAppServerToolResultExtensionRunner as F, RuntimeToolSchemaDiagnostic as G, normalizeProviderToolSchemas as H, resolveAgentHarnessBeforePromptBuildResult as I, logAgentRuntimeToolDiagnostics as J, inspectRuntimeToolInputSchemas as K, runAgentHarnessAfterCompactionHook as L, isActiveHarnessContextEngine as M, runHarnessContextEngineMaintenance as N, bootstrapHarnessContextEngine as O, testing as Ot, createAgentToolResultMiddlewareRunner as P, resolveEmbeddedAttemptToolConstructionPlan as Q, runAgentHarnessBeforeCompactionHook as R, estimateRenderedLlmBoundaryTokenPressure as S, NativeHookRelayRegistrationHandle as St, compactContextEngineWithSafetyTimeout as T, invokeNativeHookRelay as Tt, RuntimeToolInputSchemaJson as U, resolveWritableSandboxBindHostRoots as V, RuntimeToolInputSchemaProjection as W, disposeRegisteredAgentHarnesses as X, normalizeAgentRuntimeTools as Y, applyEmbeddedAttemptToolsAllow as Z, runAgentHarnessAfterToolCallHook as _, runAgentCleanupStep as _t, classifyAgentHarnessTerminalOutcome as a, filterToolResultMediaUrls as at, PREEMPTIVE_OVERFLOW_ERROR_TEXT as b, NativeHookRelayProcessResponse as bt, inferToolMetaFromArgs as c, formatToolAggregate as ct, awaitAgentHarnessAgentEndHook as d, selectDefaultNodeFromList as dt, buildEmbeddedAttemptToolRunContext as et, getAgentHarnessHookRunner as f, NodeListNode as ft, runAgentHarnessLlmOutputHook as g, log as gt, runAgentHarnessLlmInputHook as h, buildAgentRuntimePlan as ht, ToolProgressDetailMode as i, extractToolResultMediaArtifact as it, finalizeHarnessContextEngineTurn as j, buildHarnessContextEngineRuntimeContext as k, CodexBundleMcpThreadConfig as kt, loadCodexBundleMcpThreadConfig as l, listNodes as lt, runAgentHarnessBeforeAgentFinalizeHook as m, classifyEmbeddedAgentRunResultForModelFallback as mt, AgentHarnessTerminalOutcomeInput as n, resolveAttemptFsWorkspaceOnly as nt, detectAndLoadAgentHarnessPromptImages as o, isMessagingTool as ot, runAgentHarnessAgentEndHook as p, callGatewayTool as pt, projectRuntimeToolInputSchema as q, TOOL_PROGRESS_OUTPUT_MAX_CHARS as r, supportsModelTools as rt, formatToolProgressOutput as s, isMessagingToolSendAction as st, AgentHarnessTerminalOutcomeClassification as t, resolveAttemptSpawnWorkspaceDir as tt, queueAgentHarnessMessage as u, resolveNodeIdFromList as ut, runAgentHarnessBeforeMessageWriteHook as v, buildAgentHookContextChannelFields as vt, shouldPreemptivelyCompactBeforePrompt as w, hasNativeHookRelayInvocation as wt, PreemptiveCompactionDecision as x, NativeHookRelayProvider as xt, LlmBoundaryTokenPressure as y, NativeHookRelayEvent as yt, hasSandboxBindContainerPathAliases as z };