@falai/agent 0.8.1 → 0.9.0-alpha-1

package/src/core/Tool.ts

@@ -1,112 +0,0 @@
-/**
- * Tool definition and creation utilities
- */
-
-import type {
-  ToolContext,
-  ToolHandler,
-  ToolRef,
-  ToolResult,
-} from "../types/tool";
-import { generateToolId } from "../utils/id";
-
-/**
- * Define a new tool with type-safe context and arguments
- *
- * @param name - Name of the tool
- * @param handler - Handler function that executes the tool
- * @param options - Optional configuration
- * @returns A reference to the defined tool
- *
- * @example
- * ```ts
- * const getTool = defineTool<MyContext, [string, number], string>(
- *   'get_data',
- *   async ({ context }, id, count) => {
- *     return { data: `Retrieved ${count} items for ${id}` };
- *   }
- * );
- * ```
- */
-export function defineTool<
-  TContext = unknown,
-  TArgs extends unknown[] = unknown[],
-  TResult = unknown
->(
-  name: string,
-  handler: ToolHandler<TContext, TArgs, TResult>,
-  options?: {
-    id?: string;
-    description?: string;
-    parameters?: unknown;
-  }
-): ToolRef<TContext, TArgs, TResult>;
-export function defineTool<
-  TContext = unknown,
-  TArgs extends unknown[] = unknown[],
-  TResult = unknown
->(options: {
-  name: string;
-  handler: ToolHandler<TContext, TArgs, TResult>;
-  id?: string;
-  description?: string;
-  parameters?: unknown;
-}): ToolRef<TContext, TArgs, TResult>;
-export function defineTool<
-  TContext = unknown,
-  TArgs extends unknown[] = unknown[],
-  TResult = unknown
->(
-  nameOrOptions:
-    | string
-    | {
-        name: string;
-        handler: ToolHandler<TContext, TArgs, TResult>;
-        id?: string;
-        description?: string;
-        parameters?: unknown;
-      },
-  handler?: ToolHandler<TContext, TArgs, TResult>,
-  options?: {
-    id?: string;
-    description?: string;
-    parameters?: unknown;
-  }
-): ToolRef<TContext, TArgs, TResult> {
-  if (typeof nameOrOptions === "string") {
-    // Original signature: defineTool(name, handler, options)
-    const name = nameOrOptions;
-    const id = options?.id || generateToolId(name);
-
-    return {
-      id,
-      name,
-      handler: handler!,
-      description: options?.description,
-      parameters: options?.parameters,
-    };
-  } else {
-    // New signature: defineTool(options)
-    const {
-      name,
-      handler: newHandler,
-      id,
-      description,
-      parameters,
-    } = nameOrOptions;
-    const toolId = id || generateToolId(name);
-
-    return {
-      id: toolId,
-      name,
-      handler: newHandler,
-      description,
-      parameters,
-    };
-  }
-}
-
-/**
- * Re-export types for convenience
- */
-export type { ToolContext, ToolHandler, ToolRef, ToolResult };

package/src/core/Transition.ts

@@ -1,115 +0,0 @@
-/**
- * Transition between steps in the route DSL
- */
-
-import type {
-  StepRef,
-  TransitionSpec,
-  InlineToolHandler,
-} from "../types/route";
-import type { Step } from "./Step";
-import type { ToolRef, ToolResult, ToolContext } from "../types/tool";
-import { generateInlineToolId } from "../utils/id";
-
-/**
- * Represents a transition from one step to another
- */
-export class Transition<TContext = unknown, TData = unknown> {
-  private target?: Step<TContext, TData>;
-  public readonly condition?: string;
-
-  constructor(
-    public readonly source: StepRef,
-    public readonly spec: TransitionSpec<TContext, TData>
-  ) {
-    // Extract condition from spec for convenience
-    this.condition = spec.condition;
-
-    // Normalize tool if present
-    if (spec.tool) {
-      this.spec = {
-        ...spec,
-        tool: this.normalizeTool(spec.tool, source.id),
-      };
-    }
-  }
-  /**
-   * Normalize tool - convert inline handler to ToolRef if needed
-   */
-  private normalizeTool<TContext, TData>(
-    tool: // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ToolRef<TContext, any[], any, TData> | InlineToolHandler<TContext, TData>,
-    stepId: string
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ): ToolRef<TContext, any[], any, TData> {
-    // If it's already a ToolRef (has id and name properties), return as-is
-    if (typeof tool === "object" && "id" in tool && "name" in tool) {
-      return tool;
-    }
-
-    // Otherwise, it's an inline handler function - wrap it in a ToolRef
-    const inlineHandler = tool;
-    const toolId = generateInlineToolId(stepId);
-
-    return {
-      id: toolId,
-      name: toolId,
-
-      handler: async (
-        context: ToolContext<TContext, TData>
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ): Promise<ToolResult<any, TContext, TData>> => {
-        const result = (await inlineHandler(context)) as ToolResult<
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          any,
-          TContext,
-          TData
-        >;
-        return {
-          data: result,
-        };
-      },
-      description: `Inline tool for step ${stepId}`,
-    };
-  }
-
-  /**
-   * Set the target step for this transition
-   */
-  setTarget(step: Step<TContext, TData>): void {
-    this.target = step;
-  }
-
-  /**
-   * Get the target step
-   */
-  getTarget(): Step<TContext, TData> | undefined {
-    return this.target;
-  }
-
-  /**
-   * Get transition description for logging/debugging
-   */
-  describe(): string {
-    const parts: string[] = [];
-
-    if (this.spec.instructions) {
-      parts.push(`chat: "${this.spec.instructions}"`);
-    }
-    if (this.spec.tool) {
-      parts.push(`tool: ${this.spec.tool.name}`);
-    }
-    if (this.spec.step) {
-      if (typeof this.spec.step === "symbol") {
-        parts.push("step: END_ROUTE");
-      } else {
-        parts.push(`step: ${this.spec.step.id}`);
-      }
-    }
-
-    const transition = parts.join(", ");
-    const conditionPart = this.condition ? ` (when: ${this.condition})` : "";
-
-    return `${this.source.id} -> [${transition}]${conditionPart}`;
-  }
-}