@falai/agent 1.2.8 → 2.0.1

package/src/types/persistence.ts

@@ -19,7 +19,7 @@ export interface SessionData<TData = Record<string, unknown>> {
   userId?: string;
   agentName?: string;
   status: SessionStatus;
-  currentRoute?: string;
+  currentFlow?: string;
   currentStep?: string;
   collectedData?: CollectedStateData<TData>;
   messageCount?: number;
@@ -45,11 +45,15 @@ export type CreateSessionData<TData = Record<string, unknown>> = Omit<
  */
 export interface CollectedStateData<TData = Record<string, unknown>> {
   data: Partial<TData>;
-  routeHistory: SessionState<TData>["routeHistory"];
+  flowHistory: SessionState<TData>["flowHistory"];
   history?: SessionState<TData>["history"];
-  currentRouteTitle?: string;
+  currentFlowTitle?: string;
   currentStepDescription?: string;
   metadata: SessionState<TData>["metadata"];
+  /** Pending directive — included only when a directive is actually present. */
+  pendingDirective?: SessionState<TData>["pendingDirective"];
+  /** Reserved for v2.x Signals. Passed through bit-identical. */
+  signals?: SessionState<TData>["signals"];
 }
 
 /**
@@ -61,7 +65,7 @@ export interface MessageData {
   userId?: string;
   role: MessageRole;
   content: string;
-  route?: string;
+  flow?: string;
   step?: string;
   toolCalls?: Array<{ toolName: string; arguments: Record<string, unknown> }>;
   event?: Event; // Optional: store full event data
@@ -119,11 +123,11 @@ export interface SessionRepository<TData = Record<string, unknown>> {
   ): Promise<SessionData<TData> | null>;
 
   /**
-   * Update current route and step
+   * Update current flow and step
    */
-  updateRouteStep(
+  updateFlowStep(
     id: string,
-    route?: string,
+    flow?: string,
     step?: string
   ): Promise<SessionData<TData> | null>;
 
@@ -244,7 +248,7 @@ export interface SaveMessageOptions {
   userId?: string;
   role: MessageRole;
   content: string;
-  route?: string;
+  flow?: string;
   step?: string;
   toolCalls?: Array<{ toolName: string; arguments: Record<string, unknown> }>;
   event?: Event;

package/src/types/routing.ts

@@ -2,7 +2,7 @@ import type { StructuredSchema } from "./schema";
 
 export interface RoutingDecision {
   context: string;
-  routes: Record<string, number>;
+  flows: Record<string, number>;
   responseDirectives?: string[];
   extractions?: unknown;
   contextUpdate?: Record<string, unknown>;

package/src/types/session.ts

@@ -3,35 +3,28 @@
  */
 
 import type { History } from "./history";
+import type { Directive } from "./flow";
+import type { SignalsState } from "./signals";
 
-/**
- * Pending route transition information
- */
-export interface PendingTransition {
-  /** Target route ID to transition to */
-  targetRouteId: string;
-  /** Optional AI-evaluated condition for the transition */
-  condition?: string;
-  /** Reason for the transition */
-  reason: "route_complete" | "manual";
-}
+// Re-export for backward compatibility — canonical declarations live in ./signals.ts
+export type { SignalsState, SignalTriggerState } from "./signals";
 
 /**
  * Session state tracks the current position in the conversation flow
- * and data collected at the agent level across all routes
+ * and data collected at the agent level across all flows
  */
 export interface SessionState<TData = unknown> {
   /** Unique session identifier (useful for persistence) */
   id: string;
 
-  /** Current route the conversation is in */
-  currentRoute?: {
+  /** Current flow the conversation is in */
+  currentFlow?: {
     id: string;
     title: string;
     enteredAt?: Date;
   };
 
-  /** Current step within the route */
+  /** Current step within the flow */
   currentStep?: {
     id: string;
     description?: string;
@@ -39,25 +32,35 @@ export interface SessionState<TData = unknown> {
   };
 
   /**
-   * Agent-level data collected across all routes
+   * Agent-level data collected across all flows
    * This is the single source of truth for all collected data
-   * Routes can access and contribute to this shared data structure
+   * Flows can access and contribute to this shared data structure
    */
   data: Partial<TData>;
 
-  /** History of routes visited in this session */
-  routeHistory?: Array<{
-    routeId: string;
+  /** History of flows visited in this session */
+  flowHistory?: Array<{
+    flowId: string;
     enteredAt?: Date;
     exitedAt?: Date;
     completed: boolean;
   }>;
 
   /**
-   * Pending route transition after completion
-   * Set when a route completes with onComplete handler
+   * Pending directive to apply at the start of the next turn.
+   * Replaces the v1 `pendingTransition` field. When set, the turn pipeline
+   * applies this directive and skips `FlowRouter.decideFlowAndStep`.
+   *
+   * Cleared after application unless `complete.next` chains another directive.
+   */
+  pendingDirective?: Directive<unknown, TData>;
+
+  /**
+   * Reserved for v2.x Signals feature. v2.0 does not read or mutate this
+   * field at runtime — persistence adapters preserve it bit-identical through
+   * save → load roundtrips. See Decision D-Q6 in design.md.
    */
-  pendingTransition?: PendingTransition;
+  signals?: SignalsState;
 
   /**
    * Conversation history managed by the session

package/src/types/signals.ts

@@ -0,0 +1,321 @@
+/**
+ * Signals types for v2.x.
+ *
+ * This is the canonical location for all signals-related types.
+ * `SignalsState` and `SignalTriggerState` originated in `session.ts` as v2.0
+ * forward-compat reservations and are re-exported from there for backward
+ * compatibility within the same major.
+ */
+
+import type { SessionState } from "./session";
+import type { PreDirective } from "./flow";
+import type { Event } from "./history";
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Persistence types (shape locked in v2.0 — DO NOT modify)
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Per-signal trigger tracking state.
+ * Shape is locked to enable forward-compatible persistence in v2.0.
+ */
+export interface SignalTriggerState {
+    /** When this signal first fired. */
+    firstTriggeredAt: Date;
+    /** When this signal last fired. */
+    lastTriggeredAt: Date;
+    /** Total number of times this signal has fired. */
+    count: number;
+    /** Free-text reason from the last trigger (if the signal supplied one). */
+    lastReason?: string;
+    /** Which phase the signal last fired in. */
+    lastPhase?: 'pre' | 'post';
+}
+
+/**
+ * Aggregated signals state stored on the session.
+ * Shape is locked to enable forward-compatible persistence in v2.0.
+ */
+export interface SignalsState {
+    /** Per-signal trigger tracking; keyed by signal id. */
+    triggers: Record<string, SignalTriggerState>;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Schema types
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Schema for extraction signals. JSON Schema subset or Zod-compatible shape.
+ * The framework uses this to build the per-signal `extracted` field in the
+ * classifier response schema.
+ *
+ * When set on a signal, the signal operates in extraction mode: the classifier
+ * call includes this schema in the response format, and the handler receives
+ * `extracted: TExtract` when the signal matches.
+ *
+ * The type parameter `_T` is a phantom type that carries the extraction shape
+ * for downstream inference — the runtime value is always a JSON Schema object.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type SignalSchema<_T = unknown> = Record<string, unknown>;
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Predicate types
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Context passed to signal `if` predicates.
+ * Symmetric with `BranchPredicateContext` used by branches.
+ */
+export interface SignalPredicateContext<TContext = unknown, TData = unknown> {
+    /** Collected data (partial — null-check fields not guaranteed). */
+    data: Partial<TData>;
+    /** Agent-level context. */
+    context: TContext;
+    /** Full session state. */
+    session: SessionState<TData>;
+    /** Conversation history as events. */
+    history: Event[];
+}
+
+/**
+ * Code-evaluated predicate for signal `if` conditions.
+ * Returns `true` to pass (signal proceeds to `when` evaluation or fires),
+ * `false` to skip (signal is not evaluated this turn).
+ *
+ * Predicates evaluate BEFORE `when` conditions — code-first short-circuit.
+ * If `if` returns false, `when` is NOT evaluated (token-saving).
+ *
+ * If a predicate throws, the signal is treated as non-match and other
+ * signals continue evaluation.
+ */
+export type SignalPredicate<TContext = unknown, TData = unknown> = (
+    ctx: SignalPredicateContext<TContext, TData>,
+) => boolean | Promise<boolean>;
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Signal directive
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * SignalDirective — what signal handlers return.
+ * Extends `PreDirective` (which extends `Directive`). Adds signal-specific
+ * fields: `stopOtherSignals` and `replyWith`.
+ *
+ * All position-control (`goTo`, `goToStep`, `complete`, `abort`, `reset`),
+ * state writes (`dataUpdate`, `contextUpdate`), prompt augmentation
+ * (`appendPrompt`, `injectTools`), `reply`, and `halt` are inherited unchanged.
+ *
+ * Post-phase drop rules: when returned in the post-phase, `appendPrompt`,
+ * `injectTools`, and `halt` are dropped with a debug warning — they have
+ * no meaning after the LLM call has already completed.
+ */
+export interface SignalDirective<TContext = unknown, TData = unknown>
+    extends PreDirective<TContext, TData> {
+    /**
+     * Stop processing remaining signals for this phase after this handler.
+     * Does not affect the other phase.
+     */
+    stopOtherSignals?: boolean;
+
+    /**
+     * Verbatim reply with optional late-binding (function form).
+     * - String: same as `Directive.reply`.
+     * - Function: evaluated at emit time; result projects onto `Directive.reply`.
+     *
+     * The field is resolved and stripped before reaching the directive merge bus.
+     */
+    replyWith?: string | ((ctx: SignalContext<TContext, TData>) => string);
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Signal context (handler argument)
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Context passed to signal handlers when a signal fires.
+ * Symmetric with `ToolContext` — provides session state and writer methods.
+ *
+ * The `updateContext` and `updateData` writers follow the same D-Q12 contract
+ * as `ToolContext` writers.
+ */
+export interface SignalContext<
+    TContext = unknown,
+    TData = unknown,
+    TExtract = void,
+> {
+    /** The signal definition that fired. */
+    signal: Signal<TContext, TData, TExtract>;
+
+    /** Phase in which this signal fired. */
+    phase: 'pre' | 'post';
+
+    /** Whether the signal matched (always `true` when handler runs). */
+    matched: true;
+
+    /** AI rationale when `when` matched, or `'code-only'` / `'unconditional'`. */
+    reason: string;
+
+    /**
+     * Extracted data when the signal has `extract` set. Typed via the
+     * TExtract generic. Undefined for detection-only signals.
+     */
+    extracted: TExtract extends void ? undefined : TExtract;
+
+    /** Session state. Use writers below for mutations. */
+    session: SessionState<TData>;
+    /** Agent-level context. */
+    context: TContext;
+    /** Collected data (partial). */
+    data: Partial<TData>;
+    /** Conversation history as events. */
+    history: Event[];
+
+    /** Last user message (convenience). */
+    lastUserMessage?: string;
+
+    /** Timestamp when the signal fired. */
+    triggeredAt: Date;
+
+    /** Update agent context (same signature as ToolContext.updateContext). */
+    updateContext: (updates: Partial<TContext>) => Promise<void>;
+    /** Update collected data (same signature as ToolContext.updateData). */
+    updateData: (updates: Partial<TData>) => Promise<void>;
+
+    /** Imperative directive emission onto the per-turn bus. */
+    dispatch(directive: SignalDirective<TContext, TData>): void;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Signal definition
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * A signal: a typed event detector (and optional data extractor) that runs
+ * around an LLM turn.
+ *
+ * Conditions use the v2 `when` / `if` split:
+ * - `when`: AI-evaluated string(s). Entries prefixed with `!` are exclusion
+ *   conditions rendered under "DO NOT TRIGGER WHEN" in the classifier prompt.
+ *   Non-prefixed entries render under "TRIGGER WHEN". Positive entries use AND
+ *   semantics (all must match). Negative entries use OR semantics (any match
+ *   inhibits firing).
+ * - `if`: Code-evaluated function(s). Free. AND semantics.
+ *
+ * When both `if` and `when` are set, `if` evaluates first. If `if` returns
+ * false, `when` is not evaluated (token-saving).
+ *
+ * Signals with neither `when` nor `if` are unconditional — they always fire
+ * (subject to behavior gating). If `extract` is set on an unconditional signal,
+ * the extraction runs every turn.
+ */
+export interface Signal<
+    TContext = unknown,
+    TData = unknown,
+    TExtract = void,
+> {
+    /** Unique identifier. Auto-generated if omitted (stable within session). */
+    id?: string;
+
+    /** Display title (shown in logs and traces). */
+    title?: string;
+
+    /** Free-text description of what this signal detects. */
+    description?: string;
+
+    /**
+     * AI-evaluated trigger condition(s). String or array of strings.
+     * - Non-prefixed entries: AND semantics. All must match to trigger.
+     * - `!`-prefixed entries: OR exclusion. Any match inhibits firing.
+     *
+     * At prompt-render time, the framework splits entries by prefix:
+     * - Non-`!` → rendered under "TRIGGER WHEN"
+     * - `!` → stripped of prefix, rendered under "DO NOT TRIGGER WHEN"
+     */
+    when?: string | string[];
+
+    /**
+     * Code predicate(s). Function or array of functions (AND).
+     * Free to evaluate; runs before `when`. If `if` returns false, the
+     * signal is skipped — `when` is not evaluated.
+     */
+    if?: SignalPredicate<TContext, TData> | SignalPredicate<TContext, TData>[];
+
+    /**
+     * Optional structured extraction schema. When set, the signal operates
+     * in extraction mode: the classifier call includes this schema in the
+     * response format, and the handler receives `extracted: TExtract` when
+     * the signal matches.
+     *
+     * Extraction signals participate in the same batched classifier call as
+     * detection signals. The merged response schema includes each signal's
+     * extraction fields alongside the standard `matched` / `reason`.
+     *
+     * When absent, the signal operates in detection mode (boolean match).
+     */
+    extract?: SignalSchema<TExtract>;
+
+    /**
+     * When this signal evaluates relative to the LLM call.
+     * - `'pre'`: before the LLM call (parallel with routing).
+     * - `'post'`: after the LLM call (sequential, after finalize).
+     * - `'both'`: evaluated in both phases.
+     */
+    phase: 'pre' | 'post' | 'both';
+
+    /**
+     * Handler invoked when the signal fires. Receives match info and
+     * extracted data (if applicable). Returns void or a SignalDirective.
+     */
+    handler: (ctx: SignalContext<TContext, TData, TExtract>)
+        => void
+        | SignalDirective<TContext, TData>
+        | Promise<void | SignalDirective<TContext, TData>>;
+
+    /**
+     * Rate-limit / dedup behavior:
+     * - `'once'`: fire once per session.
+     * - `'always'`: fire every match (default).
+     * - `'cooldown'`: fire, then suppress for `cooldownMs`.
+     */
+    behavior?: 'once' | 'always' | 'cooldown';
+
+    /** Cooldown duration in ms. Required when `behavior === 'cooldown'`. */
+    cooldownMs?: number;
+
+    /** Whether this signal is currently enabled. @default true */
+    enabled?: boolean;
+
+    /**
+     * Higher priority signals fire first within a phase. Default 0.
+     * Tie: declaration order in `agent.signals`.
+     */
+    priority?: number;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Observability types
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Observability record for a signal that fired during a turn.
+ * Populated in fire order across both pre- and post-phases.
+ * Mirrors the observability framing of `executedSteps` and `appliedGuidelines`.
+ */
+export interface SignalFiring<TContext = unknown, TData = unknown> {
+    /** The signal's unique identifier. */
+    id: string;
+    /** Which phase the signal fired in. */
+    phase: 'pre' | 'post';
+    /** AI rationale when `when` matched, or 'code-only' / 'unconditional'. */
+    reason?: string;
+    /** Extracted data when the signal operates in extraction mode. */
+    extracted?: unknown;
+    /** The directive returned by the signal handler (if any). */
+    directive?: SignalDirective<TContext, TData>;
+    /** Error message if the handler threw. */
+    handlerError?: string;
+    /** Wall-clock duration of the handler invocation in milliseconds. */
+    durationMs?: number;
+}

package/src/types/template.ts

@@ -21,7 +21,7 @@ export interface TemplateContext<TContext = unknown, TData = unknown> {
   history?: Event[];
 
   /**
-   * The data collected in the current route.
+   * The data collected in the current flow.
    * A convenience alias for `session.data`.
    */
   data: Partial<TData>;
@@ -29,7 +29,7 @@ export interface TemplateContext<TContext = unknown, TData = unknown> {
   /**
    * Helper methods for working with history and context.
    */
-  helpers: {
+  helpers?: {
     /**
      * Get the last message from history, optionally filtered by role.
      * @param role - Optional role to filter by (user, assistant, etc.)
@@ -74,15 +74,7 @@ export type Template<TContext = unknown, TData = unknown> =
   | string
   | ((params: TemplateContext<TContext, TData>) => string | Promise<string>);
 
-/**
- * Represents a condition that can be used for routing decisions.
- * Supports strings (AI context only), boolean functions (programmatic evaluation),
- * and arrays of either for complex condition logic.
- */
-export type ConditionTemplate<TContext = unknown, TData = unknown> =
-  | string  // AI context only - not evaluated programmatically
-  | ((params: TemplateContext<TContext, TData>) => boolean | Promise<boolean>) // Programmatic evaluation
-  | ConditionTemplate<TContext, TData>[]; // Array of either
+
 
 /**
  * Result of condition evaluation containing both programmatic results

package/src/types/tool.ts

@@ -4,6 +4,7 @@
  */
 
 import type { Event, StepRef, ValidationResult } from "./index";
+import type { Directive } from "./flow";
 
 /**
  * Context provided to tool handlers
@@ -15,7 +16,7 @@ export interface ToolContext<TContext = any, TData = any> {
   data: Partial<TData>;
   /** Interaction history */
   history: Event[];
-  /** Current step reference (if in a route) */
+  /** Current step reference (if in a flow) */
   step?: StepRef;
   /** Additional metadata */
   metadata?: Record<string, unknown>;
@@ -30,6 +31,16 @@ export interface ToolContext<TContext = any, TData = any> {
   setField<K extends keyof TData>(key: K, value: TData[K]): Promise<void>;
   /** Check if a field exists in collected data */
   hasField<K extends keyof TData>(key: K): boolean;
+
+  /**
+   * Emit a directive into the per-turn bus. Identical effect to returning
+   * `{ directive }` from the tool handler, but usable mid-handler (e.g.,
+   * after an early-exit branch decides the rest of the turn is moot).
+   *
+   * Multiple `dispatch()` calls in one handler are allowed; they are merged
+   * by Algorithm 4 along with directives from other tools/hooks this turn.
+   */
+  dispatch(directive: Directive<TContext, TData>): void;
 }
 
 /**
@@ -52,6 +63,8 @@ export interface ToolResult<
   error?: string;
   /** Optional metadata about the execution */
   meta?: Record<string, unknown>;
+  /** Emit a directive declaratively (alternative to ctx.dispatch). */
+  directive?: Directive<TContext, TData>;
 }
 
 /**
@@ -70,7 +83,11 @@ export type ToolHandler<
     | ToolResult<TResult, TContext, TData>;
 
 /**
- * Tool definition - plain object interface
+ * Tool definition - single unified type (v2).
+ *
+ * In v1 there were two tool types: `Tool` (basic) and `EnhancedTool`
+ * (with metadata). v2 merges these into a single `Tool` type with all
+ * metadata fields optional. `EnhancedTool` is removed from the public surface.
  */
 export interface Tool<
   TContext = any,
@@ -79,14 +96,38 @@ export interface Tool<
 > {
   /** Tool identifier */
   id: string;
-  /** Tool display name (shown to AI models) */
-  name?: string;
   /** Tool handler function */
   handler: ToolHandler<TContext, TData, TResult>;
   /** Description of what the tool does (for AI discovery) */
   description?: string;
   /** Parameter schema or description */
   parameters?: unknown;
+
+  // ── Optional metadata (merged from EnhancedTool in v2) ──
+
+  /** Whether this tool is safe to run concurrently with other concurrent-safe tools */
+  isConcurrencySafe?(input?: Record<string, unknown>): boolean;
+  /** Whether this tool only reads data without side effects */
+  isReadOnly?(input?: Record<string, unknown>): boolean;
+  /** Whether this tool performs destructive/irreversible operations */
+  isDestructive?(input?: Record<string, unknown>): boolean;
+
+  /** How the tool responds to abort signals: 'cancel' = immediate abort, 'block' = allow completion */
+  interruptBehavior?(): 'cancel' | 'block';
+  /** Maximum characters for the tool result before truncation */
+  maxResultSizeChars?: number;
+
+  /** Validate input before execution */
+  validateInput?(
+    input: Record<string, unknown>,
+    context: ToolContext<TContext, TData>
+  ): Promise<ToolValidationResult> | ToolValidationResult;
+
+  /** Check permissions before execution — when denied, handler is NOT invoked */
+  checkPermissions?(
+    input: Record<string, unknown>,
+    context: ToolContext<TContext, TData>
+  ): Promise<ToolPermissionResult> | ToolPermissionResult;
 }
 
 
@@ -101,6 +142,8 @@ export interface ToolExecutionResult {
   contextUpdate?: Record<string, unknown>;
   dataUpdate?: Record<string, unknown>;
   metadata?: Record<string, unknown>;
+  /** Directives collected during tool execution (from ctx.dispatch and/or result.directive). */
+  directives?: Directive[];
 }
 
 /**
@@ -108,7 +151,7 @@ export interface ToolExecutionResult {
  */
 export enum ToolScope {
   AGENT = 'agent',
-  ROUTE = 'route',
+  FLOW = 'flow',
   STEP = 'step',
   REGISTERED = 'registered',
   ALL = 'all'
@@ -116,7 +159,7 @@ export enum ToolScope {
 
 
 
-// --- EnhancedTool and supporting types ---
+// --- EnhancedTool (deprecated internal alias — use Tool directly) ---
 
 /**
  * Result of input validation on a tool call
@@ -177,7 +220,7 @@ export type ToolStatus = 'queued' | 'executing' | 'completed' | 'yielded';
 export interface TrackedTool<TContext = unknown, TData = unknown> {
   id: string;
   toolCall: ToolCallRequest;
-  tool: EnhancedTool<TContext, TData>;
+  tool: Tool<TContext, TData>;
   status: ToolStatus;
   isConcurrencySafe: boolean;
   promise?: Promise<void>;
@@ -185,42 +228,7 @@ export interface TrackedTool<TContext = unknown, TData = unknown> {
   pendingProgress: string[];
 }
 
-/**
- * Extended tool interface with rich metadata for concurrency control,
- * permission gating, input validation, and result size management.
- *
- * All additional methods/properties are optional — plain `Tool` objects
- * remain fully compatible.
- */
-export interface EnhancedTool<
-  TContext = any,
-  TData = any,
-  TResult = any
-> extends Tool<TContext, TData, TResult> {
-  /** Whether this tool is safe to run concurrently with other concurrent-safe tools */
-  isConcurrencySafe?(input?: Record<string, unknown>): boolean;
-  /** Whether this tool only reads data without side effects */
-  isReadOnly?(input?: Record<string, unknown>): boolean;
-  /** Whether this tool performs destructive/irreversible operations */
-  isDestructive?(input?: Record<string, unknown>): boolean;
 
-  /** How the tool responds to abort signals: 'cancel' = immediate abort, 'block' = allow completion */
-  interruptBehavior?(): 'cancel' | 'block';
-  /** Maximum characters for the tool result before truncation */
-  maxResultSizeChars?: number;
-
-  /** Validate input before execution */
-  validateInput?(
-    input: Record<string, unknown>,
-    context: ToolContext<TContext, TData>
-  ): Promise<ToolValidationResult> | ToolValidationResult;
-
-  /** Check permissions before execution */
-  checkPermissions?(
-    input: Record<string, unknown>,
-    context: ToolContext<TContext, TData>
-  ): Promise<ToolPermissionResult> | ToolPermissionResult;
-}
 
 // --- Existing tool configuration types ---