@toolpack-sdk/agents 2.0.0-alpha.1

package/dist/interceptors/index.d.ts

@@ -0,0 +1,539 @@
+import { A as AgentInput, h as InterceptorResult, I as Interceptor, e as AgentInstance, C as ChannelInterface, b as IAgentRegistry, f as InterceptorChainConfig, a as AgentResult } from '../types-BWoRx1ZE.js';
+export { g as InterceptorContext, N as NextFunction, S as SKIP_SENTINEL, i as isSkipSentinel, s as skip } from '../types-BWoRx1ZE.js';
+import { Participant, ConversationStore, ConversationScope, StoredMessage } from 'toolpack-sdk';
+import { I as IntentClassification } from '../intent-classifier-agent-BLpDwKVf.js';
+import 'events';
+import '../base-agent-Cx2kWzLF.js';
+
+/**
+ * Composed chain of interceptors ready to execute.
+ */
+interface ComposedChain {
+    /** Execute the chain with the given input */
+    execute(input: AgentInput): Promise<InterceptorResult>;
+}
+/**
+ * Error thrown when invocation depth exceeds the configured maximum.
+ */
+declare class InvocationDepthExceededError extends Error {
+    constructor(currentDepth: number, maxDepth: number);
+}
+/**
+ * Compose an array of interceptors into an executable chain.
+ *
+ * The first interceptor in the array is outermost (runs first on way in,
+ * last on way out). The final handler invokes the agent directly.
+ *
+ * @param interceptors Ordered array of interceptors (empty = direct agent call)
+ * @param agent The agent to invoke at the end of the chain
+ * @param channel The triggering channel
+ * @param registry The agent registry
+ * @param config Chain configuration
+ * @returns Composed chain ready to execute
+ *
+ * @example
+ * ```ts
+ * const chain = composeChain(
+ *   [eventDedup, noiseFilter, intentClassifier],
+ *   agent,
+ *   channel,
+ *   registry,
+ *   { maxInvocationDepth: 5 }
+ * );
+ * const result = await chain.execute(input);
+ * ```
+ */
+declare function composeChain(interceptors: Interceptor[], agent: AgentInstance, channel: ChannelInterface, registry: IAgentRegistry | null, config?: InterceptorChainConfig): ComposedChain;
+/**
+ * Execute a chain with the given input, handling the skip sentinel.
+ *
+ * Returns `null` if the chain was skipped (caller should not send to channel),
+ * otherwise returns the AgentResult.
+ *
+ * @param chain The composed chain
+ * @param input The agent input
+ * @returns AgentResult or null if skipped
+ */
+declare function executeChain(chain: ComposedChain, input: AgentInput): Promise<AgentResult | null>;
+
+/**
+ * Configuration for the event deduplication interceptor.
+ */
+interface EventDedupConfig {
+    /** Maximum number of event IDs to cache (default: 1000) */
+    maxCacheSize?: number;
+    /** Function to extract event ID from input. Defaults to input.conversationId */
+    getEventId?: (input: AgentInput) => string | undefined;
+    /** Optional callback when duplicate is detected */
+    onDuplicate?: (eventId: string, input: AgentInput) => void;
+}
+/**
+ * Creates an event deduplication interceptor.
+ *
+ * Drops duplicate events based on event ID (e.g., Slack retries, webhook redeliveries).
+ * Uses an LRU cache to track recently seen event IDs.
+ *
+ * @example
+ * ```ts
+ * const registry = new AgentRegistry([
+ *   {
+ *     agent: MyAgent,
+ *     channels: [slackChannel],
+ *     interceptors: [
+ *       createEventDedupInterceptor({ maxCacheSize: 500 })
+ *     ]
+ *   }
+ * ]);
+ * ```
+ */
+declare function createEventDedupInterceptor(config?: EventDedupConfig): Interceptor;
+
+/**
+ * Configuration for the noise filter interceptor.
+ */
+interface NoiseFilterConfig {
+    /** List of subtypes to drop (e.g., ['message_changed', 'message_deleted']) */
+    denySubtypes: string[];
+    /** Optional function to extract subtype from input */
+    getSubtype?: (input: AgentInput) => string | undefined;
+    /** Optional callback when noise is filtered */
+    onFiltered?: (subtype: string, input: AgentInput) => void;
+}
+/**
+ * Creates a noise filter interceptor.
+ *
+ * Drops messages whose subtype is in the deny-list.
+ * Useful for filtering out message edits, deletions, bot messages, etc.
+ *
+ * @example
+ * ```ts
+ * const registry = new AgentRegistry([
+ *   {
+ *     agent: MyAgent,
+ *     channels: [slackChannel],
+ *     interceptors: [
+ *       createNoiseFilterInterceptor({
+ *         denySubtypes: ['message_changed', 'message_deleted', 'bot_message']
+ *       })
+ *     ]
+ *   }
+ * ]);
+ * ```
+ */
+declare function createNoiseFilterInterceptor(config: NoiseFilterConfig): Interceptor;
+
+/**
+ * Configuration for the self filter interceptor.
+ */
+interface SelfFilterConfig {
+    /**
+     * Platform-specific agent ID (e.g., Slack user ID "U123456").
+     * If not provided, falls back to the agent's registered name.
+     */
+    agentId?: string;
+    /** Function to extract sender ID from input */
+    getSenderId: (input: AgentInput) => string | undefined;
+    /** Optional callback when self-message is detected */
+    onSelfMessage?: (senderId: string, input: AgentInput) => void;
+}
+/**
+ * Creates a self filter interceptor (loop guard).
+ *
+ * Drops messages where the sender ID equals the agent's own ID.
+ * Prevents infinite loops where the agent responds to its own messages.
+ *
+ * @example
+ * ```ts
+ * const registry = new AgentRegistry([
+ *   {
+ *     agent: MyAgent,
+ *     channels: [slackChannel],
+ *     interceptors: [
+ *       createSelfFilterInterceptor({
+ *         agentId: 'U0123456', // Slack bot user ID
+ *         getSenderId: (input) => input.context?.senderId as string
+ *       })
+ *     ]
+ *   }
+ * ]);
+ * ```
+ */
+declare function createSelfFilterInterceptor(config: SelfFilterConfig): Interceptor;
+
+/**
+ * Configuration for the rate limit interceptor.
+ */
+interface RateLimitConfig {
+    /** Tokens per interval (default: 10) */
+    tokensPerInterval?: number;
+    /** Interval in milliseconds (default: 60000 = 1 minute) */
+    interval?: number;
+    /** Maximum number of buckets to cache (default: 1000). LRU eviction when exceeded. */
+    maxBuckets?: number;
+    /** Function to extract rate limit key from input (e.g., user ID, conversation ID) */
+    getKey: (input: AgentInput) => string;
+    /** Behavior when rate limit exceeded: 'skip' silently or 'reject' with error (default: 'skip') */
+    onExceeded?: 'skip' | 'reject';
+    /** Optional callback when rate limit is hit */
+    onRateLimited?: (key: string, input: AgentInput) => void;
+}
+/**
+ * Creates a rate limit interceptor.
+ *
+ * Token-bucket rate limiting per user or conversation.
+ * Skips or rejects when rate exceeded.
+ *
+ * @example
+ * ```ts
+ * const registry = new AgentRegistry([
+ *   {
+ *     agent: MyAgent,
+ *     channels: [slackChannel],
+ *     interceptors: [
+ *       createRateLimitInterceptor({
+ *         getKey: (input) => input.context?.userId as string || 'default',
+ *         tokensPerInterval: 5,
+ *         interval: 60000, // 5 messages per minute per user
+ *         onExceeded: 'skip'
+ *       })
+ *     ]
+ *   }
+ * ]);
+ * ```
+ */
+declare function createRateLimitInterceptor(config: RateLimitConfig): Interceptor;
+
+/**
+ * Configuration for the participant resolver interceptor.
+ */
+interface ParticipantResolverConfig {
+    /**
+     * Explicit resolver function. Takes precedence over the channel's
+     * `resolveParticipant` hook when provided.
+     *
+     * If omitted, the interceptor will call `ctx.channel.resolveParticipant`
+     * if the channel defines one. If neither is available, the input's
+     * existing `participant` field (populated by `channel.normalize()`) is
+     * passed through unchanged.
+     */
+    resolveParticipant?: (input: AgentInput) => Participant | undefined | Promise<Participant | undefined>;
+    /**
+     * Optional callback fired after a participant is resolved (from any
+     * source, including `channel.normalize()`).
+     */
+    onResolved?: (input: AgentInput, participant: Participant) => void;
+}
+/**
+ * Creates a participant resolver interceptor.
+ *
+ * Resolves the participant from input and enriches the input with participant
+ * information for downstream interceptors. This is a foundational interceptor
+ * that should typically be placed early in the chain so downstream interceptors
+ * have access to participant context.
+ *
+ * Note: This interceptor does NOT write to conversation history. It only
+ * enriches the input with participant metadata. History persistence must be
+ * handled separately by the application layer or a future history interceptor.
+ *
+ * @example
+ * ```ts
+ * const registry = new AgentRegistry([
+ *   {
+ *     agent: MyAgent,
+ *     channels: [slackChannel],
+ *     interceptors: [
+ *       createParticipantResolverInterceptor({
+ *         resolveParticipant: (input) => ({
+ *           kind: 'user',
+ *           id: input.context?.userId as string,
+ *           displayName: input.context?.userName as string
+ *         }),
+ *         onResolved: (input, participant) => {
+ *           // Optionally persist to your own history store
+ *           historyStore.append({ participant, message: input.message });
+ *         }
+ *       })
+ *     ]
+ *   }
+ * ]);
+ * ```
+ */
+declare function createParticipantResolverInterceptor(config?: ParticipantResolverConfig): Interceptor;
+
+/**
+ * Configuration for the capture-history interceptor.
+ */
+interface CaptureHistoryConfig {
+    /**
+     * The conversation store to write messages into.
+     * Typically `new InMemoryConversationStore()` for single-process deployments,
+     * or a database-backed adapter for production.
+     */
+    store: ConversationStore;
+    /**
+     * Derive the scope of an incoming message.
+     * Default: reads `input.context?.channelType` — `'im'` → `'dm'`,
+     * presence of `context?.threadId` → `'thread'`, otherwise `'channel'`.
+     */
+    getScope?: (input: AgentInput) => ConversationScope;
+    /**
+     * Derive a stable message id for dedup.
+     * Default: `input.context?.messageId ?? input.context?.eventId ?? randomUUID()`.
+     * Supply this if your channel puts the platform message id somewhere else.
+     */
+    getMessageId?: (input: AgentInput) => string;
+    /**
+     * Derive explicit @-mention ids from the message for addressed-only filtering.
+     * Default: `(input.context?.mentions as string[] | undefined) ?? []`.
+     */
+    getMentions?: (input: AgentInput) => string[];
+    /**
+     * Called after a message is successfully written to the store.
+     * Useful for metrics or debug logging.
+     */
+    onCaptured?: (message: StoredMessage) => void;
+    /**
+     * When true, the interceptor also writes the agent's reply to the store
+     * as a `kind: 'agent'` turn after `next()` returns.
+     * Default: true.
+     */
+    captureAgentReplies?: boolean;
+}
+/**
+ * Creates a capture-history interceptor.
+ *
+ * **Purpose:** The capture stage runs for *every* allowed inbound message,
+ * regardless of whether the agent ends up replying. It writes the message to
+ * the `ConversationStore` so it is available as future context for the assembler.
+ *
+ * The interceptor wraps `next()`:
+ * 1. Before calling downstream: write the inbound user message.
+ * 2. After `next()` resolves (and the result is not a skip sentinel): write the
+ *    agent's reply as a `kind: 'agent'` turn. This keeps the reply in the log
+ *    automatically without any changes to agent code.
+ *
+ * **Placement:** Put this interceptor *after* `createParticipantResolverInterceptor`
+ * (so `input.participant` is already enriched) and *before*
+ * `createAddressCheckInterceptor` (so even ignored messages are captured).
+ *
+ * @example
+ * ```ts
+ * const store = new InMemoryConversationStore();
+ *
+ * interceptors: [
+ *   createParticipantResolverInterceptor(),
+ *   createCaptureInterceptor({ store }),   // ← before address-check
+ *   createAddressCheckInterceptor({ agentName: 'kael', ... }),
+ *   createIntentClassifierInterceptor({ ... }),
+ * ]
+ * ```
+ */
+/**
+ * Symbol stamped onto every interceptor function returned by `createCaptureInterceptor`.
+ * Used by `BaseAgent._bindChannel` to detect whether a capture interceptor has already
+ * been wired — preventing the auto-inserted one from duplicating an explicit one.
+ */
+declare const CAPTURE_INTERCEPTOR_MARKER: unique symbol;
+declare function createCaptureInterceptor(config: CaptureHistoryConfig): Interceptor;
+
+/**
+ * Classification result from address checking.
+ */
+type AddressCheckResult = 'direct' | 'indirect' | 'passive' | 'ignore' | 'ambiguous';
+/**
+ * Configuration for the address-check rules interceptor.
+ */
+interface AddressCheckConfig {
+    /** The agent's display name (e.g., "Assistant") */
+    agentName: string;
+    /** The agent's ID/slack ID (e.g., "U123456") */
+    agentId?: string;
+    /** Function to extract message text from input */
+    getMessageText: (input: AgentInput) => string | undefined;
+    /** Optional: Check if input is a direct message (DM) */
+    isDirectMessage?: (input: AgentInput) => boolean;
+    /** Optional: Extract mentioned user IDs from message */
+    getMentions?: (input: AgentInput) => string[];
+    /** Optional callback when classification is made */
+    onClassified?: (result: AddressCheckResult, input: AgentInput) => void;
+}
+/**
+ * Creates an address-check rules interceptor.
+ *
+ * Stage-3 rule-based classifier:
+ * - Vocative detection ("Hey Assistant...")
+ * - Possessive patterns ("my Assistant...")
+ * - Code/URL detection (likely not addressing)
+ * - Co-mention detection
+ *
+ * Returns 'ambiguous' for cases that need LLM classification by intent-classifier.
+ *
+ * @example
+ * ```ts
+ * const registry = new AgentRegistry([
+ *   {
+ *     agent: MyAgent,
+ *     channels: [slackChannel],
+ *     interceptors: [
+ *       createAddressCheckInterceptor({
+ *         agentName: 'Assistant',
+ *         agentId: 'U123456',
+ *         getMessageText: (input) => input.message || ''
+ *       })
+ *     ]
+ *   }
+ * ]);
+ * ```
+ */
+declare function createAddressCheckInterceptor(config: AddressCheckConfig): Interceptor;
+
+/**
+ * Configuration for the intent classifier interceptor.
+ */
+interface IntentClassifierInterceptorConfig {
+    /** Name of the IntentClassifierAgent in the registry */
+    classifierAgentName?: string;
+    /** Function to extract message text from input */
+    getMessageText: (input: AgentInput) => string | undefined;
+    /** Agent's display name for classification context */
+    agentName: string;
+    /** Agent's unique ID */
+    agentId: string;
+    /** Sender name for classification context */
+    getSenderName: (input: AgentInput) => string;
+    /** Channel name for classification context */
+    getChannelName: (input: AgentInput) => string;
+    /** Check if this is a direct message */
+    isDirectMessage?: (input: AgentInput) => boolean;
+    /** Optional: Get recent context messages */
+    getRecentContext?: (input: AgentInput) => Array<{
+        sender: string;
+        content: string;
+    }>;
+    /** Optional callback when classification is made */
+    onClassified?: (classification: IntentClassification, input: AgentInput) => void;
+}
+/**
+ * Creates an intent classifier interceptor.
+ *
+ * Delegates to the IntentClassifierAgent for ambiguous address-check cases.
+ * Should be placed AFTER the address-check interceptor.
+ *
+ * Only runs when address-check result is 'ambiguous' or 'indirect'.
+ * Skips response for 'passive' and 'ignore' classifications.
+ *
+ * @example
+ * ```ts
+ * const registry = new AgentRegistry([
+ *   {
+ *     agent: MyAgent,
+ *     channels: [slackChannel],
+ *     interceptors: [
+ *       createAddressCheckInterceptor({ agentName: 'Assistant', ... }),
+ *       createIntentClassifierInterceptor({
+ *         agentName: 'Assistant',
+ *         agentId: 'U123456',
+ *         getMessageText: (input) => input.message || '',
+ *         getSenderName: (input) => input.context?.userName as string || 'Unknown',
+ *         getChannelName: (input) => input.context?.channelName as string || 'general',
+ *         classifierAgentName: 'intent-classifier' // capability agent name
+ *       })
+ *     ]
+ *   }
+ * ]);
+ * ```
+ */
+declare function createIntentClassifierInterceptor(config: IntentClassifierInterceptorConfig): Interceptor;
+
+/**
+ * Configuration for the depth guard interceptor.
+ */
+interface DepthGuardConfig {
+    /** Maximum allowed invocation depth (default: 5) */
+    maxDepth?: number;
+    /** Optional callback when depth limit is exceeded */
+    onDepthExceeded?: (currentDepth: number, maxDepth: number, input: AgentInput) => void;
+}
+/**
+ * Error thrown when invocation depth exceeds the configured maximum.
+ */
+declare class DepthExceededError extends Error {
+    readonly currentDepth: number;
+    readonly maxDepth: number;
+    constructor(currentDepth: number, maxDepth: number);
+}
+/**
+ * Creates a depth guard interceptor.
+ *
+ * Enforces maximum invocation depth on delegate chains.
+ * This provides an early check before the actual delegation happens,
+ * complementing the depth tracking in the chain composer.
+ *
+ * **Limitation:** This interceptor checks `ctx.invocationDepth`, which is always 0
+ * for top-level chain invocations. It only fires when a delegated agent (called via
+ * `ctx.delegateAndWait`) also has this interceptor and enters via the registry's
+ * interceptor chain. Since `ctx.delegateAndWait` calls `targetAgent.invokeAgent`
+ * directly (bypassing the chain), this interceptor is primarily belt-and-suspenders
+ * for future scenarios where delegated calls may route through the registry.
+ *
+ * The actual depth protection lives in `ctx.delegateAndWait`'s internal
+ * `nextDepth > maxDepth` check in the chain composer.
+ *
+ * @example
+ * ```ts
+ * const registry = new AgentRegistry([
+ *   {
+ *     agent: MyAgent,
+ *     channels: [slackChannel],
+ *     interceptors: [
+ *       createDepthGuardInterceptor({ maxDepth: 5 })
+ *     ]
+ *   }
+ * ]);
+ * ```
+ */
+declare function createDepthGuardInterceptor(config?: DepthGuardConfig): Interceptor;
+
+/**
+ * Configuration for the tracer interceptor.
+ */
+interface TracerConfig {
+    /**
+     * Log level for tracing (default: 'debug')
+     */
+    level?: 'debug' | 'info';
+    /**
+     * Whether to include full input data in logs (default: false)
+     */
+    includeInputData?: boolean;
+    /**
+     * Whether to include full result output in logs (default: false)
+     */
+    includeResultOutput?: boolean;
+    /**
+     * Optional: Filter which inputs to trace
+     */
+    shouldTrace?: (input: AgentInput) => boolean;
+}
+/**
+ * Creates a tracer interceptor.
+ *
+ * Structured logging of each hop for debugging.
+ * Logs entry (before calling next) and exit (after receiving result).
+ *
+ * @example
+ * ```ts
+ * const registry = new AgentRegistry([
+ *   {
+ *     agent: MyAgent,
+ *     channels: [slackChannel],
+ *     interceptors: [
+ *       createTracerInterceptor({ level: 'debug', includeInputData: true })
+ *     ]
+ *   }
+ * ]);
+ * ```
+ */
+declare function createTracerInterceptor(config?: TracerConfig): Interceptor;
+
+export { type AddressCheckConfig, type AddressCheckResult, CAPTURE_INTERCEPTOR_MARKER, type CaptureHistoryConfig, type ComposedChain, DepthExceededError, type DepthGuardConfig, type EventDedupConfig, type IntentClassifierInterceptorConfig, Interceptor, InterceptorChainConfig, InterceptorResult, InvocationDepthExceededError, type NoiseFilterConfig, type ParticipantResolverConfig, type RateLimitConfig, type SelfFilterConfig, type TracerConfig, composeChain, createAddressCheckInterceptor, createCaptureInterceptor, createDepthGuardInterceptor, createEventDedupInterceptor, createIntentClassifierInterceptor, createNoiseFilterInterceptor, createParticipantResolverInterceptor, createRateLimitInterceptor, createSelfFilterInterceptor, createTracerInterceptor, executeChain };

package/dist/interceptors/index.js

@@ -0,0 +1 @@
+var y=Symbol("interceptor-skip-sentinel");function C(e){return e===y}function A(){return y}var v=class extends Error{constructor(t,n){super(`Invocation depth ${t} exceeds maximum ${n}`),this.name="InvocationDepthExceededError"}};function K(e,t,n,s,i={}){let o=i.maxInvocationDepth??5;return{async execute(r){let g=(u=>({agent:t,channel:n,registry:s,invocationDepth:u,delegateAndWait:async(l,d)=>{let p=u+1;if(p>o)throw new v(p,o);if(!s)throw new Error(`Cannot delegate to "${l}": agent is running in standalone mode without a registry`);let f=s.getAgent(l);if(!f)throw new Error(`Agent "${l}" not found for delegation`);let h={message:d.message??"",intent:d.intent,data:d.data,context:d.context,conversationId:d.conversationId??r.conversationId??`delegation-${Date.now()}`};return await f.invokeAgent(h)},skip:A}))(0),a=async u=>{let l=u??r;return await t.invokeAgent(l)};for(let u=e.length-1;u>=0;u--){let l=e[u],d=a;a=async p=>await l(p??r,g,d)}return await a()}}}async function z(e,t){let n=await e.execute(t);return n===y?null:n}var R=class{constructor(t){this.maxSize=t}maxSize;cache=new Map;has(t){return this.cache.has(t)}set(t,n){if(this.cache.has(t)&&this.cache.delete(t),this.cache.size>=this.maxSize){let s=this.cache.keys().next().value;s!==void 0&&this.cache.delete(s)}this.cache.set(t,n)}clear(){this.cache.clear()}size(){return this.cache.size}};function k(e={}){let t=e.maxCacheSize??1e3,n=e.getEventId??(i=>i.context?.eventId),s=new R(t);return async(i,o,r)=>{let c=n(i);if(c){if(s.has(c))return e.onDuplicate?.(c,i),o.logger?.debug(`Event dedup: dropping duplicate event ${c}`,{eventId:c}),o.skip();s.set(c,!0)}return await r()}}function S(e){let t=e.getSubtype??(s=>s.context?.subtype),n=new Set(e.denySubtypes);return async(s,i,o)=>{let r=t(s);return r&&n.has(r)?(e.onFiltered?.(r,s),i.logger?.debug(`Noise filter: dropping message with subtype "${r}"`,{subtype:r}),i.skip()):await o()}}function E(e){return async(t,n,s)=>{let i=e.getSenderId(t),o=e.agentId??n.agent.name;return i&&i===o?(e.onSelfMessage?.(i,t),n.logger?.debug(`Self filter: dropping self-message from ${i}`,{senderId:i,agentId:o}),n.skip()):await s()}}var w=class{constructor(t){this.maxSize=t}maxSize;cache=new Map;get(t){let n=this.cache.get(t);return n!==void 0&&(this.cache.delete(t),this.cache.set(t,n)),n}set(t,n){if(this.cache.has(t))this.cache.delete(t);else if(this.cache.size>=this.maxSize){let s=this.cache.keys().next().value;s!==void 0&&this.cache.delete(s)}this.cache.set(t,n)}clear(){this.cache.clear()}size(){return this.cache.size}},b=class{constructor(t,n,s){this.capacity=t;this.refillRate=n;this.refillInterval=s;this.tokens=t,this.lastRefill=Date.now()}capacity;refillRate;refillInterval;tokens;lastRefill;consume(t=1){return this.refill(),this.tokens>=t?(this.tokens-=t,!0):!1}refill(){let t=Date.now(),n=t-this.lastRefill,s=Math.floor(n/this.refillInterval*this.refillRate);s>0&&(this.tokens=Math.min(this.capacity,this.tokens+s),this.lastRefill=t)}getTokens(){return this.refill(),this.tokens}};function D(e){let t=e.tokensPerInterval??10,n=e.interval??6e4,s=e.maxBuckets??1e3,i=e.onExceeded??"skip",o=new w(s);return async(r,c,g)=>{let a=e.getKey(r),u=o.get(a);if(u||(u=new b(t,t,n),o.set(a,u)),!u.consume()){if(e.onRateLimited?.(a,r),c.logger?.warn(`Rate limit exceeded for key: ${a}`,{key:a}),i==="reject")throw new Error("Rate limit exceeded. Please try again later.");return c.skip()}return await g()}}function P(e={}){return async(t,n,s)=>{let i;if(e.resolveParticipant)i=await e.resolveParticipant(t);else if(typeof n.channel.resolveParticipant=="function")try{i=await n.channel.resolveParticipant(t)}catch(r){n.logger?.warn("Channel resolveParticipant threw; falling back",{error:r instanceof Error?r.message:"Unknown error"})}let o=i??t.participant;if(o){let r={...t,participant:o,context:{...t.context,_participant:o}};return e.onResolved?.(r,o),n.logger?.debug("Resolved participant",{participantId:o.id,participantKind:o.kind}),await s(r)}return await s()}}import{randomUUID as T}from"crypto";function B(e){let t=e.context??{},n=t.channelType;return n==="im"||n==="private"||n==="dm"?"dm":t.threadId!==void 0?"thread":"channel"}var N=Symbol.for("toolpack:capture-history");function F(e){let t=e.captureAgentReplies??!0,n=e.getScope??B,s=e.getMessageId??(r=>r.context?.messageId??r.context?.eventId??T()),i=e.getMentions??(r=>r.context?.mentions??[]),o=async(r,c,g)=>{let a=r.conversationId;if(!a)return c.logger?.warn("[capture-history] Message has no conversationId \u2014 skipping capture"),await g();let u=r.participant;if(u){let d={id:s(r),conversationId:a,participant:u,content:r.message??"",timestamp:new Date().toISOString(),scope:n(r),metadata:{channelType:r.context?.channelType,threadId:r.context?.threadId,messageId:r.context?.messageId,mentions:i(r),channelName:r.context?.channelName,channelId:r.context?.channelId}};try{await e.store.append(d),e.onCaptured?.(d),c.logger?.debug("[capture-history] Captured inbound message",{messageId:d.id,participantId:u.id,conversationId:a})}catch(p){c.logger?.warn("[capture-history] Failed to store inbound message",{error:p instanceof Error?p.message:String(p)})}}let l=await g();if(t&&!C(l)&&l.output!=null){let d={kind:"agent",id:c.agent.name,displayName:c.agent.name},p={id:T(),conversationId:a,participant:d,content:l.output,timestamp:new Date().toISOString(),scope:n(r),metadata:{channelType:r.context?.channelType,threadId:r.context?.threadId,channelName:r.context?.channelName,channelId:r.context?.channelId}};try{await e.store.append(p),e.onCaptured?.(p),c.logger?.debug("[capture-history] Captured agent reply",{messageId:p.id,agentId:c.agent.name,conversationId:a})}catch(f){c.logger?.warn("[capture-history] Failed to store agent reply",{error:f instanceof Error?f.message:String(f)})}}return l};return o[N]=!0,o}function O(e,t){let n=t.toLowerCase();if(!e.toLowerCase().includes(n))return!1;let i=[],o=/```[\s\S]*?```/g,r;for(;(r=o.exec(e))!==null;)i.push([r.index,r.index+r[0].length]);let c=/`[^`\n]*`/g;for(;(r=c.exec(e))!==null;){let d=r.index,p=d+r[0].length;i.some(([h,_])=>d>=h&&p<=_)||i.push([d,p])}if(i.length===0)return!1;i.sort((d,p)=>d[0]-p[0]);let g="",a=0;for(let[d,p]of i)d>a&&(g+=e.slice(a,d)),a=Math.max(a,p);return a<e.length&&(g+=e.slice(a)),g.toLowerCase().includes(n)?!1:i.some(([d,p])=>e.slice(d,p).toLowerCase().includes(n))}function M(e){return async(t,n,s)=>{let i=e.getMessageText(t)??"";if(e.isDirectMessage?.(t)){let p={...t,context:{...t.context,_addressCheck:"direct",_isDM:!0}};return e.onClassified?.("direct",t),await s(p)}let o="ambiguous",r=i.toLowerCase(),c=e.agentName.toLowerCase(),g=p=>p.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),a=g(c),u=e.agentId?`|^@${g(e.agentId)}\\b`:"";if(new RegExp(`^(hey\\s+)?@?${a}\\b${u}`,"i").test(r))o="direct";else if(new RegExp(`\\b(my|our|the)\\s+${a}\\b`,"i").test(r))o="ambiguous";else if(O(i,e.agentName))o="ignore";else if(/^https?:\/\//.test(i))o="ignore";else if(e.getMentions){let p=e.getMentions(t),f=p.some(h=>h.toLowerCase()===c||h===e.agentId);f&&p.length>1?o="indirect":f&&(o="ambiguous")}else r.includes(c)?o="ambiguous":o="passive";let d={...t,context:{...t.context,_addressCheck:o}};return e.onClassified?.(o,t),n.logger?.debug(`Address check classified as: ${o}`,{result:o}),await s(d)}}function j(e){let t=e.classifierAgentName??"intent-classifier";return async(n,s,i)=>{let o=n.context?._addressCheck;if(o==="direct")return await i();if(o==="ignore"||o==="passive")return e.onClassified?.(o,n),s.skip();let r=e.getMessageText(n)??"";if(!r.trim())return await i();let c={message:r,agentName:e.agentName,agentId:e.agentId,senderName:e.getSenderName(n),channelName:e.getChannelName(n),isDirectMessage:e.isDirectMessage?.(n)??!1,recentContext:e.getRecentContext?.(n)};try{let a=(await s.delegateAndWait(t,{message:"classify",data:c,conversationId:n.conversationId})).output.trim();e.onClassified?.(a,n),s.logger?.debug(`Intent classified as: ${a}`,{classification:a});let u={...n,context:{...n.context,_intentClassification:a}};return a==="direct"?await i(u):s.skip()}catch(g){return s.logger?.error("Intent classification failed, allowing message",{error:g instanceof Error?g.message:"Unknown error"}),await i()}}}var x=class extends Error{constructor(n,s){super(`Maximum invocation depth exceeded: ${n} > ${s}`);this.currentDepth=n;this.maxDepth=s;this.name="DepthExceededError"}currentDepth;maxDepth};function L(e={}){let t=e.maxDepth??5;return async(n,s,i)=>{if(s.invocationDepth>t)throw e.onDepthExceeded?.(s.invocationDepth,t,n),s.logger?.error(`Depth guard: invocation depth ${s.invocationDepth} exceeds maximum ${t}`,{currentDepth:s.invocationDepth,maxDepth:t}),new x(s.invocationDepth,t);return await i()}}function $(e={}){let t=e.level??"debug",n=e.includeInputData??!1,s=e.includeResultOutput??!1;return async(i,o,r)=>{if(e.shouldTrace&&!e.shouldTrace(i))return await r();let c=t==="info"?o.logger?.info:o.logger?.debug;c?.("Interceptor entry",{agent:o.agent.name,channel:o.channel.name,depth:o.invocationDepth,conversationId:i.conversationId,intent:i.intent,input:n?i:void 0});let g=performance.now();try{let a=await r(),u=performance.now()-g;return C(a)?c?.("Interceptor exit: skipped",{agent:o.agent.name,channel:o.channel.name,depth:o.invocationDepth,conversationId:i.conversationId,durationMs:u.toFixed(2)}):c?.("Interceptor exit: success",{agent:o.agent.name,channel:o.channel.name,depth:o.invocationDepth,conversationId:i.conversationId,durationMs:u.toFixed(2),outputLength:a.output.length,result:s?a:void 0}),a}catch(a){let u=performance.now()-g;throw o.logger?.error("Interceptor exit: error",{agent:o.agent.name,channel:o.channel.name,depth:o.invocationDepth,conversationId:i.conversationId,durationMs:u.toFixed(2),error:a instanceof Error?a.message:"Unknown error",errorType:a?.constructor?.name}),a}}}export{N as CAPTURE_INTERCEPTOR_MARKER,x as DepthExceededError,v as InvocationDepthExceededError,y as SKIP_SENTINEL,K as composeChain,M as createAddressCheckInterceptor,F as createCaptureInterceptor,L as createDepthGuardInterceptor,k as createEventDedupInterceptor,j as createIntentClassifierInterceptor,S as createNoiseFilterInterceptor,P as createParticipantResolverInterceptor,D as createRateLimitInterceptor,E as createSelfFilterInterceptor,$ as createTracerInterceptor,z as executeChain,C as isSkipSentinel,A as skip};

package/dist/registry/index.cjs

@@ -0,0 +1 @@
+"use strict";var h=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var R=Object.getOwnPropertyNames;var S=Object.prototype.hasOwnProperty;var b=(r,e)=>{for(var o in e)h(r,o,{get:e[o],enumerable:!0})},A=(r,e,o,g)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of R(e))!S.call(r,s)&&s!==o&&h(r,s,{get:()=>e[s],enumerable:!(g=w(e,s))||g.enumerable});return r};var j=r=>A(h({},"__esModule",{value:!0}),r);var M={};b(M,{RegistryError:()=>c,searchRegistry:()=>l});module.exports=j(M);async function l(r={}){let{keyword:e,category:o,tag:g,limit:s=20,offset:p=0,registryUrl:f="https://registry.npmjs.org"}=r,d=["toolpack-agent"];e&&d.push(e),g&&d.push(g);let k=d.join(" "),y=new URL("/-/v1/search",f);y.searchParams.set("text",k),y.searchParams.set("size",String(Math.min(s+p,250))),y.searchParams.set("from",String(0));try{let n=await fetch(y.toString(),{headers:{Accept:"application/json"}});if(!n.ok)throw new c(`NPM registry search failed: ${n.status} ${n.statusText}`);let a=(await n.json()).objects.map(i=>{let t=i.package,u=L(t);return{name:t.name,version:t.version,description:t.description,toolpack:u,keywords:t.keywords,author:t.author,date:t.date,links:t.links,publisher:t.publisher,maintainers:t.maintainers}});if(o&&(a=a.filter(i=>i.toolpack?.category?.toLowerCase()===o.toLowerCase())),g){let i=g.toLowerCase();a=a.filter(t=>t.toolpack?.tags?.some(u=>u.toLowerCase()===i)||t.keywords?.some(u=>u.toLowerCase()===i))}a=a.filter(i=>i.toolpack?.agent===!0);let m=a.length;return a=a.slice(p,p+s),{agents:a,total:m,offset:p,limit:s,hasMore:m>p+s}}catch(n){throw n instanceof c?n:new c(`Failed to search registry: ${n instanceof Error?n.message:String(n)}`)}}function L(r){let e=r.toolpack;if(!(!e||e.agent!==!0))return{agent:!0,category:typeof e.category=="string"?e.category:void 0,description:typeof e.description=="string"?e.description:void 0,tags:Array.isArray(e.tags)?e.tags.filter(o=>typeof o=="string"):void 0,author:typeof e.author=="string"?e.author:void 0,repository:typeof e.repository=="string"?e.repository:void 0,homepage:typeof e.homepage=="string"?e.homepage:void 0}}var c=class extends Error{constructor(e){super(e),this.name="RegistryError"}};0&&(module.exports={RegistryError,searchRegistry});