fengming 0.3.8 → 0.3.10

package/dist/types-BzMoU6-C.d.ts

@@ -0,0 +1,111 @@
+import { _ as PromptImageOrderEntry, a as SourceReplyDeliveryMode, h as InputProvenance } from "./types-CrmoEuWv.js";
+import { gs as ExecElevatedDefaults, hs as ClientToolDefinition, ls as PromptMode, ms as AgentStreamParams, us as AgentInternalEvent } from "./types-BQw1qXGl.js";
+import { O as ChannelOutboundTargetMode } from "./types.core-BIOUPd66.js";
+//#region src/agents/spawned-context.d.ts
+type SpawnedRunMetadata = {
+  spawnedBy?: string | null;
+  groupId?: string | null;
+  groupChannel?: string | null;
+  groupSpace?: string | null;
+  workspaceDir?: string | null;
+};
+//#endregion
+//#region src/agents/command/types.d.ts
+/** Image content block for Claude API multimodal messages. */
+type ImageContent = {
+  type: "image";
+  data: string;
+  mimeType: string;
+};
+type AgentCommandResultMetaOverrides = {
+  transport?: "embedded";
+  fallbackFrom?: "gateway";
+  fallbackReason?: "gateway_timeout";
+  fallbackSessionId?: string;
+  fallbackSessionKey?: string;
+};
+type AcpTurnSource = "manual_spawn";
+type AgentRunContext = {
+  messageChannel?: string;
+  accountId?: string;
+  groupId?: string | null;
+  groupChannel?: string | null;
+  groupSpace?: string | null;
+  currentChannelId?: string;
+  currentThreadTs?: string;
+  replyToMode?: "off" | "first" | "all" | "batched";
+  hasRepliedRef?: {
+    value: boolean;
+  };
+};
+type AgentCommandOpts = {
+  message: string; /** User-visible transcript body; defaults to message and excludes runtime-only context. */
+  transcriptMessage?: string; /** Optional image attachments for multimodal messages. */
+  images?: ImageContent[]; /** Original inline/offloaded attachment order for inbound images. */
+  imageOrder?: PromptImageOrderEntry[]; /** Optional client-provided tools (OpenResponses hosted tools). */
+  clientTools?: ClientToolDefinition[]; /** Agent id override (must exist in config). */
+  agentId?: string; /** Per-run provider override. */
+  provider?: string; /** Per-run model override. */
+  model?: string;
+  to?: string;
+  sessionId?: string;
+  sessionKey?: string;
+  thinking?: string;
+  thinkingOnce?: string;
+  verbose?: string;
+  json?: boolean;
+  timeout?: string;
+  deliver?: boolean; /** Override delivery target (separate from session routing). */
+  replyTo?: string; /** Override delivery channel (separate from session routing). */
+  replyChannel?: string; /** Override delivery account id (separate from session routing). */
+  replyAccountId?: string; /** Override delivery thread/topic id (separate from session routing). */
+  threadId?: string | number; /** Message channel context. */
+  messageChannel?: string; /** Tool-policy/output surface context. Defaults to messageChannel. */
+  messageProvider?: string; /** Delivery channel. */
+  channel?: string; /** Account ID for multi-account channel routing. */
+  accountId?: string; /** Context for embedded run routing (channel/account/thread). */
+  runContext?: AgentRunContext; /** Internal trusted exec approval follow-up elevated defaults. */
+  bashElevated?: ExecElevatedDefaults; /** Trusted sender identity bit for command/channel-action auth; defaults true for local CLI calls. */
+  senderIsOwner?: boolean; /** Whether this caller is authorized to use provider/model per-run overrides. */
+  allowModelOverride?: boolean; /** Optional runtime tool allow-list; when set, only these tools are exposed for this run. */
+  toolsAllow?: string[]; /** Group/spawn metadata for subagent policy inheritance and routing context. */
+  groupId?: SpawnedRunMetadata["groupId"];
+  groupChannel?: SpawnedRunMetadata["groupChannel"];
+  groupSpace?: SpawnedRunMetadata["groupSpace"];
+  spawnedBy?: SpawnedRunMetadata["spawnedBy"];
+  deliveryTargetMode?: ChannelOutboundTargetMode;
+  bestEffortDeliver?: boolean;
+  abortSignal?: AbortSignal;
+  lane?: string;
+  runId?: string;
+  extraSystemPrompt?: string; /** Bootstrap workspace context injection mode for this run. */
+  bootstrapContextMode?: "full" | "lightweight"; /** Run kind hint for bootstrap context behavior. */
+  bootstrapContextRunKind?: "default" | "heartbeat" | "cron";
+  internalEvents?: AgentInternalEvent[];
+  inputProvenance?: InputProvenance; /** Internal runs can execute against a session without updating visible status/model/usage. */
+  sessionEffects?: "visible" | "internal"; /** Internal handoffs can write transcript turns without changing user-facing model/usage state. */
+  preserveUserFacingSessionModelState?: boolean; /** Visible source replies must be sent through the message tool when set. */
+  sourceReplyDeliveryMode?: SourceReplyDeliveryMode; /** Internal runs can omit the channel message tool entirely. */
+  disableMessageTool?: boolean; /** Gateway ingress that already persisted visible activity can skip the duplicate pre-run touch. */
+  skipInitialSessionTouch?: boolean; /** Per-call stream param overrides (best-effort). */
+  streamParams?: AgentStreamParams; /** Explicit workspace directory override (for subagents to inherit parent workspace). */
+  workspaceDir?: SpawnedRunMetadata["workspaceDir"]; /** Explicit task working directory for this run. Bootstrap still uses workspaceDir. */
+  cwd?: string; /** Force bundled MCP teardown when a one-shot local run completes. */
+  cleanupBundleMcpOnRunEnd?: boolean; /** Force long-lived CLI live session teardown when a one-shot local run completes. */
+  cleanupCliLiveSessionOnRunEnd?: boolean; /** Internal local CLI callers can annotate result metadata before JSON/text output. */
+  resultMetaOverrides?: AgentCommandResultMetaOverrides; /** Called when the actual run model is selected, including fallback retries. */
+  onActiveModelSelected?: (ctx: {
+    provider: string;
+    model: string;
+  }) => void; /** Internal one-shot model probe mode: no tools, no workspace/chat prompt policy. */
+  modelRun?: boolean; /** Internal prompt-mode override for trusted local/gateway callsites. */
+  promptMode?: PromptMode; /** Internal ACP-ready session turn source. Manual spawn turns bypass only the dispatch gate. */
+  acpTurnSource?: AcpTurnSource; /** Internal handoffs can feed the model without writing the synthetic prompt to transcript. */
+  suppressPromptPersistence?: boolean;
+};
+type AgentCommandIngressOpts = Omit<AgentCommandOpts, "senderIsOwner" | "allowModelOverride" | "resultMetaOverrides"> & {
+  /** Trusted sender identity bit for command/channel-action auth; defaults false for ingress. */senderIsOwner?: boolean; /** Ingress callsites must always pass explicit model-override authorization state. */
+  allowModelOverride: boolean;
+};
+//#endregion
+export { AgentCommandOpts as n, AgentCommandResultMetaOverrides as r, AgentCommandIngressOpts as t };

package/dist/types-DltHmoCX.d.ts

@@ -0,0 +1,393 @@
+import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { n as GetReplyOptions, s as ReplyPayload } from "./types-CrmoEuWv.js";
+import { a as CommandTurnKind, d as InboundEventKind, n as MsgContext, t as FinalizedMsgContext } from "./templating-suu09Bb-.js";
+import { r as GroupKeyResolution } from "./types-ClAj0v1O.js";
+import { n as HistoryMediaEntry, t as HistoryEntry } from "./history.types-D_WxL2c8.js";
+import { P as MessageReceipt } from "./types-C4HgagiY.js";
+import { n as ReplyDispatchKind } from "./reply-dispatcher.types-DpeYvsDP.js";
+import { n as RecordInboundSession, t as InboundLastRouteUpdate } from "./session.types-CXhDZ0fW.js";
+import { i as ReplyDispatcherWithTypingOptions, l as GetReplyFromConfig, s as DispatchFromConfigResult, t as DispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher.types-C_ryM1LO.js";
+import { a as OutboundDeliveryQueuePolicy, r as DurableFinalDeliveryRequirements, t as DeliverOutboundPayloadsParams } from "./deliver-BnVp3VbL.js";
+import { n as CreateChannelReplyPipelineParams } from "./reply-pipeline-DYMNI1Tf.js";
+import { a as PairLoopGuardResult, i as PairLoopGuardConfig, s as PairLoopGuardSnapshotEntry } from "./pair-loop-guard-runtime-Dsjpip3a.js";
+
+//#region src/channels/turn/bot-loop-protection.d.ts
+type ChannelBotLoopProtectionFacts = {
+  scopeId: string;
+  conversationId: string;
+  senderId: string;
+  receiverId: string;
+  config?: PairLoopGuardConfig;
+  defaultsConfig?: PairLoopGuardConfig;
+  defaultEnabled: boolean;
+  nowMs?: number;
+};
+declare function recordChannelBotPairLoopAndCheckSuppression(params: ChannelBotLoopProtectionFacts): PairLoopGuardResult;
+declare function clearChannelBotPairLoopGuardForTests(): void;
+declare function listTrackedChannelBotPairsForTests(): PairLoopGuardSnapshotEntry[];
+//#endregion
+//#region src/channels/turn/types.d.ts
+type ChannelTurnAdmission = {
+  kind: "dispatch";
+  reason?: string;
+} | {
+  kind: "observeOnly";
+  reason: string;
+} | {
+  kind: "handled";
+  reason: string;
+} | {
+  kind: "drop";
+  reason: string;
+  recordHistory?: boolean;
+};
+type ChannelEventClass = {
+  kind: "message" | "command" | "interaction" | "reaction" | "lifecycle" | "unknown";
+  canStartAgentTurn: boolean;
+  requiresImmediateAck?: boolean;
+};
+type NormalizedTurnInput = {
+  id: string;
+  timestamp?: number;
+  rawText: string;
+  textForAgent?: string;
+  textForCommands?: string;
+  raw?: unknown;
+};
+type SenderFacts = {
+  id?: string;
+  name?: string;
+  username?: string;
+  tag?: string;
+  roles?: string[];
+  isBot?: boolean;
+  isSelf?: boolean;
+  displayLabel?: string;
+};
+type ConversationFacts = {
+  kind: "direct" | "group" | "channel";
+  id: string;
+  label?: string;
+  spaceId?: string;
+  parentId?: string;
+  threadId?: string;
+  nativeChannelId?: string;
+  routePeer?: {
+    kind: "direct" | "group" | "channel";
+    id: string;
+  };
+};
+type RouteFacts = {
+  agentId: string;
+  accountId?: string;
+  routeSessionKey: string;
+  dispatchSessionKey?: string;
+  persistedSessionKey?: string;
+  parentSessionKey?: string;
+  modelParentSessionKey?: string;
+  mainSessionKey?: string;
+  createIfMissing?: boolean;
+};
+type ReplyPlanFacts = {
+  to: string;
+  originatingTo?: string;
+  nativeChannelId?: string;
+  replyTarget?: string;
+  deliveryTarget?: string;
+  replyToId?: string;
+  replyToIdFull?: string;
+  messageThreadId?: string | number;
+  threadParentId?: string;
+  sourceReplyDeliveryMode?: "thread" | "reply" | "channel" | "direct" | "none";
+};
+type ProjectedAllowlistAccessFacts = {
+  configured: boolean;
+  matched: boolean;
+  reasonCode?: string;
+  matchedEntryIds: string[];
+  invalidEntryCount: number;
+  disabledEntryCount: number;
+  accessGroups: {
+    referenced: string[];
+    matched: string[];
+    missing: string[];
+    unsupported: string[];
+    failed: string[];
+  };
+};
+type ProjectedEventAccessFacts = {
+  kind: "message" | "reaction" | "button" | "postback" | "native-command" | "slash-command" | "system";
+  authMode: "inbound" | "command" | "origin-subject" | "route-only" | "none";
+  mayPair: boolean;
+  authorized: boolean;
+  reasonCode?: string;
+  hasOriginSubject: boolean;
+  originSubjectMatched: boolean;
+};
+type AccessFacts = {
+  dm?: {
+    decision: "allow" | "pairing" | "deny";
+    reason?: string;
+    /**
+     * @deprecated Shared ingress projections redact allowlist entries and return an empty compat list.
+     * Use allowlist diagnostics instead.
+     */
+    allowFrom: string[];
+    allowlist?: ProjectedAllowlistAccessFacts;
+  };
+  group?: {
+    policy: "open" | "allowlist" | "disabled";
+    routeAllowed: boolean;
+    senderAllowed: boolean;
+    /**
+     * @deprecated Shared ingress projections redact allowlist entries and return an empty compat list.
+     * Use allowlist diagnostics instead.
+     */
+    allowFrom: string[];
+    requireMention: boolean;
+    allowlist?: ProjectedAllowlistAccessFacts;
+  };
+  commands?: {
+    authorized?: boolean;
+    shouldBlockControlCommand?: boolean;
+    reasonCode?: string;
+    useAccessGroups: boolean;
+    allowTextCommands: boolean;
+    modeWhenAccessGroupsOff?: "allow" | "deny" | "configured";
+    /**
+     * @deprecated Shared ingress projections do not expose raw authorizer lists.
+     * Use authorized and reasonCode instead.
+     */
+    authorizers: Array<{
+      configured: boolean;
+      allowed: boolean;
+    }>;
+  };
+  event?: ProjectedEventAccessFacts;
+  mentions?: {
+    canDetectMention: boolean;
+    wasMentioned: boolean;
+    hasAnyMention?: boolean;
+    implicitMentionKinds?: Array<"reply_to_bot" | "quoted_bot" | "bot_thread_participant" | "native">;
+    requireMention?: boolean;
+    effectiveWasMentioned?: boolean;
+    shouldSkip?: boolean;
+  };
+};
+type MessageFacts = {
+  inboundEventKind?: InboundEventKind;
+  body?: string;
+  rawBody: string;
+  bodyForAgent?: string;
+  commandBody?: string;
+  envelopeFrom?: string;
+  senderLabel?: string;
+  preview?: string;
+  inboundHistory?: HistoryEntry[];
+};
+type CommandFacts = {
+  kind: CommandTurnKind;
+  body?: string;
+  name?: string;
+  authorized?: boolean;
+};
+type SupplementalContextFacts = {
+  quote?: {
+    id?: string;
+    fullId?: string;
+    body?: string;
+    sender?: string;
+    senderAllowed?: boolean;
+    isExternal?: boolean;
+    isQuote?: boolean;
+  };
+  forwarded?: {
+    from?: string;
+    fromType?: string;
+    fromId?: string;
+    date?: number;
+    senderAllowed?: boolean;
+  };
+  thread?: {
+    id?: string;
+    starterBody?: string;
+    historyBody?: string;
+    label?: string;
+    parentSessionKey?: string;
+    modelParentSessionKey?: string;
+    senderAllowed?: boolean;
+  };
+  untrustedContext?: Array<{
+    label: string;
+    source?: string;
+    type?: string;
+    payload: unknown;
+  }>;
+  groupSystemPrompt?: string; /** Prompt-like group metadata from user-controlled sources; never enters the system prompt. */
+  untrustedGroupSystemPrompt?: string;
+};
+type InboundMediaFacts = {
+  path?: string;
+  url?: string;
+  contentType?: string;
+  kind?: "image" | "video" | "audio" | "document" | "unknown";
+  transcribed?: boolean;
+  messageId?: string;
+};
+type MaybePromise<T> = T | Promise<T>;
+type PreflightFacts = {
+  admission?: ChannelTurnAdmission;
+  command?: CommandFacts;
+  message?: Partial<MessageFacts>;
+  media?: readonly InboundMediaFacts[] | (() => MaybePromise<readonly InboundMediaFacts[] | readonly HistoryMediaEntry[] | null | undefined>);
+  supplemental?: SupplementalContextFacts;
+  history?: ChannelTurnDroppedHistoryOptions;
+};
+type ChannelDeliveryInfo = {
+  kind: ReplyDispatchKind;
+};
+type ChannelDeliveryIntent = {
+  id: string;
+  kind: "outbound_queue";
+  queuePolicy: OutboundDeliveryQueuePolicy;
+};
+type ChannelDeliveryResult = {
+  messageIds?: string[];
+  receipt?: MessageReceipt;
+  threadId?: string;
+  replyToId?: string;
+  visibleReplySent?: boolean;
+  deliveryIntent?: ChannelDeliveryIntent;
+};
+type ChannelTurnDurableDeliveryOptions = Pick<DeliverOutboundPayloadsParams, "deps" | "formatting" | "identity" | "mediaAccess" | "replyToMode" | "silent" | "threadId"> & {
+  to?: string | null;
+  replyToId?: string | null;
+  requiredCapabilities?: DurableFinalDeliveryRequirements;
+};
+type ChannelEventDeliveryAdapter = {
+  preparePayload?: (payload: ReplyPayload, info: ChannelDeliveryInfo) => Promise<ReplyPayload> | ReplyPayload;
+  deliver: (payload: ReplyPayload, info: ChannelDeliveryInfo) => Promise<ChannelDeliveryResult | void>;
+  durable?: false | ChannelTurnDurableDeliveryOptions | ((payload: ReplyPayload, info: ChannelDeliveryInfo) => false | ChannelTurnDurableDeliveryOptions | Promise<false | ChannelTurnDurableDeliveryOptions>);
+  onDelivered?: (payload: ReplyPayload, info: ChannelDeliveryInfo, result: ChannelDeliveryResult | void) => Promise<void> | void;
+  onError?: (err: unknown, info: {
+    kind: string;
+  }) => void;
+};
+type ChannelTurnRecordOptions = {
+  groupResolution?: GroupKeyResolution | null;
+  createIfMissing?: boolean;
+  updateLastRoute?: InboundLastRouteUpdate;
+  onRecordError?: (err: unknown) => void;
+  trackSessionMetaTask?: (task: Promise<unknown>) => void;
+};
+type ChannelTurnHistoryFinalizeOptions = {
+  isGroup?: boolean;
+  historyKey?: string;
+  historyMap?: Map<string, HistoryEntry[]>;
+  limit?: number;
+};
+type ChannelTurnDroppedHistoryOptions = {
+  key: string;
+  limit: number;
+  historyMap: Map<string, HistoryEntry[]>;
+  recordOnDrop?: boolean;
+  mediaLimit?: number;
+  shouldRecord?: () => boolean;
+};
+type ChannelTurnDispatcherOptions = Omit<ReplyDispatcherWithTypingOptions, "deliver" | "onError">;
+type ChannelTurnReplyPipelineOptions = Omit<CreateChannelReplyPipelineParams, "cfg" | "agentId" | "channel" | "accountId">;
+type AssembledChannelTurn = {
+  cfg: FengMingConfig;
+  channel: string;
+  accountId?: string;
+  agentId: string;
+  routeSessionKey: string;
+  storePath: string;
+  ctxPayload: FinalizedMsgContext;
+  recordInboundSession: RecordInboundSession;
+  dispatchReplyWithBufferedBlockDispatcher: DispatchReplyWithBufferedBlockDispatcher;
+  delivery: ChannelEventDeliveryAdapter;
+  replyPipeline?: ChannelTurnReplyPipelineOptions;
+  dispatcherOptions?: ChannelTurnDispatcherOptions;
+  replyOptions?: Omit<GetReplyOptions, "onBlockReply">;
+  replyResolver?: GetReplyFromConfig;
+  record?: ChannelTurnRecordOptions;
+  history?: ChannelTurnHistoryFinalizeOptions;
+  admission?: Extract<ChannelTurnAdmission, {
+    kind: "dispatch" | "observeOnly";
+  }>;
+  botLoopProtection?: ChannelBotLoopProtectionFacts;
+  log?: (event: ChannelTurnLogEvent) => void;
+  messageId?: string;
+};
+type PreparedChannelTurn<TDispatchResult = DispatchFromConfigResult> = {
+  channel: string;
+  accountId?: string;
+  routeSessionKey: string;
+  storePath: string;
+  ctxPayload: FinalizedMsgContext;
+  recordInboundSession: RecordInboundSession;
+  record?: ChannelTurnRecordOptions;
+  history?: ChannelTurnHistoryFinalizeOptions;
+  onPreDispatchFailure?: (err: unknown) => void | Promise<void>;
+  runDispatch: () => Promise<TDispatchResult>;
+  observeOnlyDispatchResult?: TDispatchResult;
+  admission?: Extract<ChannelTurnAdmission, {
+    kind: "dispatch" | "observeOnly";
+  }>;
+  botLoopProtection?: ChannelBotLoopProtectionFacts;
+  log?: (event: ChannelTurnLogEvent) => void;
+  messageId?: string;
+};
+type ChannelTurnResolved<TDispatchResult = DispatchFromConfigResult> = (AssembledChannelTurn & {
+  admission?: Extract<ChannelTurnAdmission, {
+    kind: "dispatch" | "observeOnly";
+  }>;
+}) | (PreparedChannelTurn<TDispatchResult> & {
+  admission?: Extract<ChannelTurnAdmission, {
+    kind: "dispatch" | "observeOnly";
+  }>;
+});
+type ChannelTurnStage = "ingest" | "classify" | "preflight" | "resolve" | "authorize" | "assemble" | "record" | "dispatch" | "finalize";
+type ChannelTurnLogEvent = {
+  stage: ChannelTurnStage;
+  event: "start" | "done" | "drop" | "handled" | "error";
+  channel: string;
+  accountId?: string;
+  messageId?: string;
+  sessionKey?: string;
+  admission?: ChannelTurnAdmission["kind"];
+  reason?: string;
+  error?: unknown;
+};
+type ChannelTurnResult<TDispatchResult = DispatchFromConfigResult> = DispatchedChannelTurnResult<TDispatchResult> | {
+  admission: ChannelTurnAdmission;
+  dispatched: false;
+  ctxPayload?: MsgContext;
+  routeSessionKey?: string;
+};
+type DispatchedChannelTurnResult<TDispatchResult = DispatchFromConfigResult> = {
+  admission: Extract<ChannelTurnAdmission, {
+    kind: "dispatch" | "observeOnly";
+  }>;
+  dispatched: true;
+  ctxPayload: MsgContext;
+  routeSessionKey: string;
+  dispatchResult: TDispatchResult;
+};
+type ChannelTurnAdapter<TRaw, TDispatchResult = DispatchFromConfigResult> = {
+  ingest: (raw: TRaw) => Promise<NormalizedTurnInput | null> | NormalizedTurnInput | null;
+  classify?: (input: NormalizedTurnInput) => Promise<ChannelEventClass> | ChannelEventClass;
+  preflight?: (input: NormalizedTurnInput, eventClass: ChannelEventClass) => Promise<PreflightFacts | ChannelTurnAdmission | null | undefined> | PreflightFacts | ChannelTurnAdmission | null | undefined;
+  resolveTurn: (input: NormalizedTurnInput, eventClass: ChannelEventClass, preflight: PreflightFacts) => Promise<ChannelTurnResolved<TDispatchResult>> | ChannelTurnResolved<TDispatchResult>;
+  onFinalize?: (result: ChannelTurnResult<TDispatchResult>) => Promise<void> | void;
+};
+type RunChannelTurnParams<TRaw, TDispatchResult = DispatchFromConfigResult> = {
+  channel: string;
+  accountId?: string;
+  raw: TRaw;
+  adapter: ChannelTurnAdapter<TRaw, TDispatchResult>;
+  log?: (event: ChannelTurnLogEvent) => void;
+};
+//#endregion
+export { SupplementalContextFacts as A, NormalizedTurnInput as C, RouteFacts as D, ReplyPlanFacts as E, clearChannelBotPairLoopGuardForTests as M, listTrackedChannelBotPairsForTests as N, RunChannelTurnParams as O, recordChannelBotPairLoopAndCheckSuppression as P, MessageFacts as S, PreparedChannelTurn as T, ChannelTurnResult as _, ChannelDeliveryResult as a, DispatchedChannelTurnResult as b, ChannelTurnAdapter as c, ChannelTurnDroppedHistoryOptions as d, ChannelTurnHistoryFinalizeOptions as f, ChannelTurnResolved as g, ChannelTurnReplyPipelineOptions as h, ChannelDeliveryIntent as i, ChannelBotLoopProtectionFacts as j, SenderFacts as k, ChannelTurnAdmission as l, ChannelTurnRecordOptions as m, AssembledChannelTurn as n, ChannelEventClass as o, ChannelTurnLogEvent as p, ChannelDeliveryInfo as r, ChannelEventDeliveryAdapter as s, AccessFacts as t, ChannelTurnDispatcherOptions as u, CommandFacts as v, PreflightFacts as w, InboundMediaFacts as x, ConversationFacts as y };

package/dist/types.public-C_bVIMBl.d.ts

@@ -0,0 +1,70 @@
+import { n as ChannelConfigSchema } from "./types.config-CKJTcS4X.js";
+import { t as ChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { n as ChannelMessageAdapterShape } from "./types-C4HgagiY.js";
+import { n as ChannelOutboundAdapter } from "./outbound.types-DVkbsxo8.js";
+import { E as ChannelMeta, I as ChannelStreamingAdapter, K as ChannelMessageActionName$1, R as ChannelThreadingAdapter, T as ChannelMessagingAdapter, a as ChannelAgentPromptAdapter, c as ChannelCapabilities, o as ChannelAgentTool, s as ChannelAgentToolFactory, v as ChannelMentionAdapter, y as ChannelMessageActionAdapter } from "./types.core-BIOUPd66.js";
+import { n as ChannelSetupWizard, r as ChannelSetupWizardAdapter } from "./setup-wizard-types-BeWI4Fkg.js";
+import { A as ChannelGroupAdapter, B as ChannelSecretsAdapter, D as ChannelElevatedAdapter, H as ChannelSetupAdapter, M as ChannelLifecycleAdapter, O as ChannelGatewayAdapter, S as ChannelDoctorAdapter, U as ChannelStatusAdapter, V as ChannelSecurityAdapter, b as ChannelConversationBindingSupport, g as ChannelConfigAdapter, i as ChannelApprovalCapability, j as ChannelHeartbeatAdapter, m as ChannelCommandAdapter, n as ChannelAllowlistAdapter, u as ChannelAuthAdapter, x as ChannelDirectoryAdapter, y as ChannelConfiguredBindingProvider, z as ChannelResolverAdapter } from "./types.adapters-DSaA0bHm.js";
+import { t as ChannelPairingAdapter } from "./pairing.types-B0SQgllo.js";
+import { t as OperatorScope } from "./operator-scopes-ijAvkvEk.js";
+
+//#region src/channels/plugins/types.plugin.d.ts
+/** Full capability contract for a native channel plugin. */
+type ChannelPluginSetupWizard = ChannelSetupWizard | ChannelSetupWizardAdapter;
+type ChannelGatewayMethodDescriptor = {
+  name: string;
+  scope?: OperatorScope;
+  description?: string;
+};
+type ChannelPlugin<ResolvedAccount = any, Probe = unknown, Audit = unknown> = {
+  id: ChannelId;
+  meta: ChannelMeta;
+  capabilities: ChannelCapabilities;
+  defaults?: {
+    queue?: {
+      debounceMs?: number;
+    };
+  };
+  reload?: {
+    configPrefixes: string[];
+    noopPrefixes?: string[];
+  };
+  setupWizard?: ChannelPluginSetupWizard;
+  config: ChannelConfigAdapter<ResolvedAccount>;
+  configSchema?: ChannelConfigSchema;
+  setup?: ChannelSetupAdapter;
+  pairing?: ChannelPairingAdapter;
+  security?: ChannelSecurityAdapter<ResolvedAccount>;
+  groups?: ChannelGroupAdapter;
+  mentions?: ChannelMentionAdapter;
+  outbound?: ChannelOutboundAdapter;
+  status?: ChannelStatusAdapter<ResolvedAccount, Probe, Audit>;
+  gatewayMethods?: string[];
+  gatewayMethodDescriptors?: ChannelGatewayMethodDescriptor[];
+  gateway?: ChannelGatewayAdapter<ResolvedAccount>;
+  auth?: ChannelAuthAdapter;
+  approvalCapability?: ChannelApprovalCapability;
+  elevated?: ChannelElevatedAdapter;
+  commands?: ChannelCommandAdapter;
+  lifecycle?: ChannelLifecycleAdapter;
+  secrets?: ChannelSecretsAdapter;
+  allowlist?: ChannelAllowlistAdapter;
+  doctor?: ChannelDoctorAdapter;
+  bindings?: ChannelConfiguredBindingProvider;
+  conversationBindings?: ChannelConversationBindingSupport;
+  streaming?: ChannelStreamingAdapter;
+  threading?: ChannelThreadingAdapter;
+  message?: ChannelMessageAdapterShape;
+  messaging?: ChannelMessagingAdapter;
+  agentPrompt?: ChannelAgentPromptAdapter;
+  directory?: ChannelDirectoryAdapter;
+  resolver?: ChannelResolverAdapter;
+  actions?: ChannelMessageActionAdapter;
+  heartbeat?: ChannelHeartbeatAdapter;
+  agentTools?: ChannelAgentToolFactory | ChannelAgentTool[];
+};
+//#endregion
+//#region src/channels/plugins/types.public.d.ts
+type ChannelMessageActionName = ChannelMessageActionName$1;
+//#endregion
+export { ChannelPlugin as n, ChannelMessageActionName as t };

package/dist/web-fetch/runtime.d.ts

@@ -1,5 +1,5 @@
 import { r as FengMingConfig } from "../types.fengming-NdBrgqd4.js";
-import { Go as WebFetchProviderToolDefinition, zo as PluginWebFetchProviderEntry } from "../types-DI62NfFe.js";
+import { Go as WebFetchProviderToolDefinition, zo as PluginWebFetchProviderEntry } from "../types-BQw1qXGl.js";
 import { t as RuntimeWebFetchMetadata } from "../runtime-web-tools.types-Co2KBj4w.js";
 
 //#region src/web-fetch/runtime.d.ts

package/dist/webhook-targets-DW2jhddP.d.ts

@@ -0,0 +1,99 @@
+import { n as registerPluginHttpRoute } from "./http-registry-BDoApjTY.js";
+import { f as FixedWindowRateLimiter, i as WebhookInFlightLimiter } from "./webhook-request-guards-CQf6yUy9.js";
+import { IncomingMessage, ServerResponse } from "node:http";
+
+//#region src/plugin-sdk/webhook-targets.d.ts
+type RegisteredWebhookTarget<T> = {
+  target: T;
+  unregister: () => void;
+};
+type RegisterWebhookTargetOptions<T extends {
+  path: string;
+}> = {
+  onFirstPathTarget?: (params: {
+    path: string;
+    target: T;
+  }) => void | (() => void);
+  onLastPathTargetRemoved?: (params: {
+    path: string;
+  }) => void;
+};
+type RegisterPluginHttpRouteParams = Parameters<typeof registerPluginHttpRoute>[0];
+type RegisterWebhookPluginRouteOptions = Omit<RegisterPluginHttpRouteParams, "path" | "fallbackPath">;
+/** Register a webhook target and lazily install the matching plugin HTTP route on first use. */
+declare function registerWebhookTargetWithPluginRoute<T extends {
+  path: string;
+}>(params: {
+  targetsByPath: Map<string, T[]>;
+  target: T;
+  route: RegisterWebhookPluginRouteOptions;
+  onLastPathTargetRemoved?: RegisterWebhookTargetOptions<T>["onLastPathTargetRemoved"];
+}): RegisteredWebhookTarget<T>;
+/** Add a normalized target to a path bucket and clean up route state when the last target leaves. */
+declare function registerWebhookTarget<T extends {
+  path: string;
+}>(targetsByPath: Map<string, T[]>, target: T, opts?: RegisterWebhookTargetOptions<T>): RegisteredWebhookTarget<T>;
+/** Resolve all registered webhook targets for the incoming request path. */
+declare function resolveWebhookTargets<T>(req: IncomingMessage, targetsByPath: Map<string, T[]>): {
+  path: string;
+  targets: T[];
+} | null;
+/** Run common webhook guards, then dispatch only when the request path resolves to live targets. */
+declare function withResolvedWebhookRequestPipeline<T>(params: {
+  req: IncomingMessage;
+  res: ServerResponse;
+  targetsByPath: Map<string, T[]>;
+  allowMethods?: readonly string[];
+  rateLimiter?: FixedWindowRateLimiter;
+  rateLimitKey?: string;
+  nowMs?: number;
+  requireJsonContentType?: boolean;
+  inFlightLimiter?: WebhookInFlightLimiter;
+  inFlightKey?: string | ((args: {
+    req: IncomingMessage;
+    path: string;
+    targets: T[];
+  }) => string);
+  inFlightLimitStatusCode?: number;
+  inFlightLimitMessage?: string;
+  handle: (args: {
+    path: string;
+    targets: T[];
+  }) => Promise<boolean | void> | boolean | void;
+}): Promise<boolean>;
+type WebhookTargetMatchResult<T> = {
+  kind: "none";
+} | {
+  kind: "single";
+  target: T;
+} | {
+  kind: "ambiguous";
+};
+/** Match exactly one synchronous target or report whether resolution was empty or ambiguous. */
+declare function resolveSingleWebhookTarget<T>(targets: readonly T[], isMatch: (target: T) => boolean): WebhookTargetMatchResult<T>;
+/** Async variant of single-target resolution for auth checks that need I/O. */
+declare function resolveSingleWebhookTargetAsync<T>(targets: readonly T[], isMatch: (target: T) => Promise<boolean>): Promise<WebhookTargetMatchResult<T>>;
+/** Resolve an authorized target and send the standard unauthorized or ambiguous response on failure. */
+declare function resolveWebhookTargetWithAuthOrReject<T>(params: {
+  targets: readonly T[];
+  res: ServerResponse;
+  isMatch: (target: T) => boolean | Promise<boolean>;
+  unauthorizedStatusCode?: number;
+  unauthorizedMessage?: string;
+  ambiguousStatusCode?: number;
+  ambiguousMessage?: string;
+}): Promise<T | null>;
+/** Synchronous variant of webhook auth resolution for cheap in-memory match checks. */
+declare function resolveWebhookTargetWithAuthOrRejectSync<T>(params: {
+  targets: readonly T[];
+  res: ServerResponse;
+  isMatch: (target: T) => boolean;
+  unauthorizedStatusCode?: number;
+  unauthorizedMessage?: string;
+  ambiguousStatusCode?: number;
+  ambiguousMessage?: string;
+}): T | null;
+/** Reject non-POST webhook requests with the conventional Allow header. */
+declare function rejectNonPostWebhookRequest(req: IncomingMessage, res: ServerResponse): boolean;
+//#endregion
+export { registerWebhookTarget as a, resolveSingleWebhookTarget as c, resolveWebhookTargetWithAuthOrRejectSync as d, resolveWebhookTargets as f, WebhookTargetMatchResult as i, resolveSingleWebhookTargetAsync as l, RegisterWebhookTargetOptions as n, registerWebhookTargetWithPluginRoute as o, withResolvedWebhookRequestPipeline as p, RegisteredWebhookTarget as r, rejectNonPostWebhookRequest as s, RegisterWebhookPluginRouteOptions as t, resolveWebhookTargetWithAuthOrReject as u };