@agentforge/testing 0.16.30 → 0.16.32

package/dist/index.d.cts

@@ -2,9 +2,8 @@ import { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import { BaseMessage } from '@langchain/core/messages';
 import { ChatResult } from '@langchain/core/outputs';
 import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import * as _agentforge_core from '@agentforge/core';
-import { ToolCategory, Tool, Logger } from '@agentforge/core';
 import { z } from 'zod';
+import { Tool, ToolCategory, Logger } from '@agentforge/core';
 
 /**
  * Configuration for MockLLM
@@ -80,10 +79,27 @@ declare function createEchoLLM(): MockLLM;
  */
 declare function createErrorLLM(errorMessage?: string): MockLLM;
 
+declare const defaultMockToolSchema: z.ZodObject<{
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+}, {
+    input: string;
+}>;
+type DefaultMockToolSchema = typeof defaultMockToolSchema;
+type MockToolSchema = z.ZodTypeAny;
+type MockToolInput<TSchema extends MockToolSchema> = z.infer<TSchema>;
+type MockToolInstance<TSchema extends MockToolSchema> = Tool<MockToolInput<TSchema>, string>;
+type MockToolConfigWithoutSchema = Omit<MockToolConfig<DefaultMockToolSchema>, 'schema'> & {
+    schema?: undefined;
+};
+type SchemaBackedMockToolConfig<TSchema extends MockToolSchema> = MockToolConfig<TSchema> & {
+    schema: TSchema;
+};
 /**
  * Configuration for mock tool
  */
-interface MockToolConfig<T extends z.ZodType = z.ZodType> {
+interface MockToolConfig<TSchema extends MockToolSchema = DefaultMockToolSchema> {
     /**
      * Tool name
      */
@@ -99,11 +115,11 @@ interface MockToolConfig<T extends z.ZodType = z.ZodType> {
     /**
      * Input schema
      */
-    schema?: T;
+    schema?: TSchema;
     /**
      * Implementation function
      */
-    implementation?: (input: z.infer<T>) => Promise<string> | string;
+    implementation?: (input: MockToolInput<TSchema>) => Promise<string> | string;
     /**
      * Whether to throw an error
      */
@@ -117,38 +133,55 @@ interface MockToolConfig<T extends z.ZodType = z.ZodType> {
      */
     delay?: number;
 }
-/**
- * Create a mock tool for testing
- *
- * @example
- * ```typescript
- * const tool = createMockTool({
- *   name: 'test_tool',
- *   schema: z.object({ input: z.string().describe('Input') }),
- *   implementation: async ({ input }) => `Processed: ${input}`
- * });
- *
- * const result = await tool.execute({ input: 'test' });
- * console.log(result); // 'Processed: test'
- * ```
- */
-declare function createMockTool<T extends z.ZodType = any>(config?: MockToolConfig<T>): _agentforge_core.Tool<any, string>;
+declare function createMockTool(): MockToolInstance<DefaultMockToolSchema>;
+declare function createMockTool(config: MockToolConfigWithoutSchema): MockToolInstance<DefaultMockToolSchema>;
+declare function createMockTool<TSchema extends MockToolSchema>(config: SchemaBackedMockToolConfig<TSchema>): MockToolInstance<TSchema>;
 /**
  * Create a mock tool that echoes its input
  */
-declare function createEchoTool(name?: string): _agentforge_core.Tool<any, string>;
+declare function createEchoTool(name?: string): MockToolInstance<z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>>;
 /**
  * Create a mock tool that always errors
  */
-declare function createErrorTool(name?: string, errorMessage?: string): _agentforge_core.Tool<any, string>;
+declare function createErrorTool(name?: string, errorMessage?: string): MockToolInstance<z.ZodObject<{
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+}, {
+    input: string;
+}>>;
 /**
  * Create a mock tool with delay
  */
-declare function createDelayedTool(name?: string, delay?: number): _agentforge_core.Tool<any, string>;
+declare function createDelayedTool(name?: string, delay?: number): MockToolInstance<z.ZodObject<{
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+}, {
+    input: string;
+}>>;
 /**
  * Create a calculator mock tool
  */
-declare function createCalculatorTool(): _agentforge_core.Tool<any, string>;
+declare function createCalculatorTool(): MockToolInstance<z.ZodObject<{
+    operation: z.ZodEnum<["add", "subtract", "multiply", "divide"]>;
+    a: z.ZodNumber;
+    b: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    operation: "add" | "subtract" | "multiply" | "divide";
+    a: number;
+    b: number;
+}, {
+    operation: "add" | "subtract" | "multiply" | "divide";
+    a: number;
+    b: number;
+}>>;
 
 type StateBuilderFields = Record<string, unknown> & {
     messages?: BaseMessage[];

package/dist/index.d.ts

@@ -2,9 +2,8 @@ import { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import { BaseMessage } from '@langchain/core/messages';
 import { ChatResult } from '@langchain/core/outputs';
 import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import * as _agentforge_core from '@agentforge/core';
-import { ToolCategory, Tool, Logger } from '@agentforge/core';
 import { z } from 'zod';
+import { Tool, ToolCategory, Logger } from '@agentforge/core';
 
 /**
  * Configuration for MockLLM
@@ -80,10 +79,27 @@ declare function createEchoLLM(): MockLLM;
  */
 declare function createErrorLLM(errorMessage?: string): MockLLM;
 
+declare const defaultMockToolSchema: z.ZodObject<{
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+}, {
+    input: string;
+}>;
+type DefaultMockToolSchema = typeof defaultMockToolSchema;
+type MockToolSchema = z.ZodTypeAny;
+type MockToolInput<TSchema extends MockToolSchema> = z.infer<TSchema>;
+type MockToolInstance<TSchema extends MockToolSchema> = Tool<MockToolInput<TSchema>, string>;
+type MockToolConfigWithoutSchema = Omit<MockToolConfig<DefaultMockToolSchema>, 'schema'> & {
+    schema?: undefined;
+};
+type SchemaBackedMockToolConfig<TSchema extends MockToolSchema> = MockToolConfig<TSchema> & {
+    schema: TSchema;
+};
 /**
  * Configuration for mock tool
  */
-interface MockToolConfig<T extends z.ZodType = z.ZodType> {
+interface MockToolConfig<TSchema extends MockToolSchema = DefaultMockToolSchema> {
     /**
      * Tool name
      */
@@ -99,11 +115,11 @@ interface MockToolConfig<T extends z.ZodType = z.ZodType> {
     /**
      * Input schema
      */
-    schema?: T;
+    schema?: TSchema;
     /**
      * Implementation function
      */
-    implementation?: (input: z.infer<T>) => Promise<string> | string;
+    implementation?: (input: MockToolInput<TSchema>) => Promise<string> | string;
     /**
      * Whether to throw an error
      */
@@ -117,38 +133,55 @@ interface MockToolConfig<T extends z.ZodType = z.ZodType> {
      */
     delay?: number;
 }
-/**
- * Create a mock tool for testing
- *
- * @example
- * ```typescript
- * const tool = createMockTool({
- *   name: 'test_tool',
- *   schema: z.object({ input: z.string().describe('Input') }),
- *   implementation: async ({ input }) => `Processed: ${input}`
- * });
- *
- * const result = await tool.execute({ input: 'test' });
- * console.log(result); // 'Processed: test'
- * ```
- */
-declare function createMockTool<T extends z.ZodType = any>(config?: MockToolConfig<T>): _agentforge_core.Tool<any, string>;
+declare function createMockTool(): MockToolInstance<DefaultMockToolSchema>;
+declare function createMockTool(config: MockToolConfigWithoutSchema): MockToolInstance<DefaultMockToolSchema>;
+declare function createMockTool<TSchema extends MockToolSchema>(config: SchemaBackedMockToolConfig<TSchema>): MockToolInstance<TSchema>;
 /**
  * Create a mock tool that echoes its input
  */
-declare function createEchoTool(name?: string): _agentforge_core.Tool<any, string>;
+declare function createEchoTool(name?: string): MockToolInstance<z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>>;
 /**
  * Create a mock tool that always errors
  */
-declare function createErrorTool(name?: string, errorMessage?: string): _agentforge_core.Tool<any, string>;
+declare function createErrorTool(name?: string, errorMessage?: string): MockToolInstance<z.ZodObject<{
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+}, {
+    input: string;
+}>>;
 /**
  * Create a mock tool with delay
  */
-declare function createDelayedTool(name?: string, delay?: number): _agentforge_core.Tool<any, string>;
+declare function createDelayedTool(name?: string, delay?: number): MockToolInstance<z.ZodObject<{
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+}, {
+    input: string;
+}>>;
 /**
  * Create a calculator mock tool
  */
-declare function createCalculatorTool(): _agentforge_core.Tool<any, string>;
+declare function createCalculatorTool(): MockToolInstance<z.ZodObject<{
+    operation: z.ZodEnum<["add", "subtract", "multiply", "divide"]>;
+    a: z.ZodNumber;
+    b: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    operation: "add" | "subtract" | "multiply" | "divide";
+    a: number;
+    b: number;
+}, {
+    operation: "add" | "subtract" | "multiply" | "divide";
+    a: number;
+    b: number;
+}>>;
 
 type StateBuilderFields = Record<string, unknown> & {
     messages?: BaseMessage[];

package/dist/index.js

@@ -1538,58 +1538,81 @@ function createErrorLLM(errorMessage = "Mock error") {
     errorMessage
   });
 }
-function createMockTool(config2 = {}) {
-  const {
-    name = "mock_tool",
-    description = "A mock tool for testing",
-    category = ToolCategory.UTILITY,
-    schema,
-    implementation,
-    shouldError = false,
-    errorMessage = "Mock tool error",
-    delay = 0
-  } = config2;
-  const actualSchema = schema || z.object({ input: z.string().describe("Input parameter") });
+var defaultMockToolSchema = z.object({
+  input: z.string().describe("Input parameter")
+});
+function buildMockTool(config2) {
+  const { name, description, category, schema, implementation, shouldError, errorMessage, delay } = config2;
   const defaultImplementation = async (input) => {
+    return `Mock result: ${JSON.stringify(input)}`;
+  };
+  const actualImplementation = async (input) => {
     if (delay > 0) {
       await new Promise((resolve4) => setTimeout(resolve4, delay));
     }
     if (shouldError) {
       throw new Error(errorMessage);
     }
-    return `Mock result: ${JSON.stringify(input)}`;
-  };
-  const actualImplementation = async (input) => {
     if (implementation) {
       const result = await Promise.resolve(implementation(input));
       return result;
     }
     return defaultImplementation(input);
   };
-  return toolBuilder().name(name).description(description).category(category).schema(actualSchema).implement(actualImplementation).build();
+  return toolBuilder().name(name).description(description).category(category).schema(schema).implement(actualImplementation).build();
 }
-function createEchoTool(name = "echo_tool") {
-  return createMockTool({
+function createMockTool(config2 = {}) {
+  const name = config2.name ?? "mock-tool";
+  const description = config2.description ?? "A mock tool for testing";
+  const category = config2.category ?? ToolCategory.UTILITY;
+  const shouldError = config2.shouldError ?? false;
+  const errorMessage = config2.errorMessage ?? "Mock tool error";
+  const delay = config2.delay ?? 0;
+  if ("schema" in config2 && config2.schema) {
+    return buildMockTool({
+      name,
+      description,
+      category,
+      schema: config2.schema,
+      implementation: config2.implementation,
+      shouldError,
+      errorMessage,
+      delay
+    });
+  }
+  return buildMockTool({
     name,
+    description,
+    category,
+    schema: defaultMockToolSchema,
+    implementation: config2.implementation,
+    shouldError,
+    errorMessage,
+    delay
+  });
+}
+function createEchoTool(name = "echo-tool") {
+  return createMockTool({
+    name: name.replace(/_/g, "-"),
     description: "Echoes the input",
     schema: z.object({ message: z.string().describe("Message to echo") }),
     implementation: async ({ message }) => `Echo: ${message}`
   });
 }
-function createErrorTool(name = "error_tool", errorMessage = "Tool error") {
+function createErrorTool(name = "error-tool", errorMessage = "Tool error") {
   return createMockTool({
-    name,
+    name: name.replace(/_/g, "-"),
     description: "A tool that always errors",
     shouldError: true,
     errorMessage
   });
 }
-function createDelayedTool(name = "delayed_tool", delay = 100) {
+function createDelayedTool(name = "delayed-tool", delay = 100) {
   return createMockTool({
-    name,
+    name: name.replace(/_/g, "-"),
     description: "A tool with artificial delay",
     delay,
-    schema: z.object({ input: z.string().describe("Input parameter") }),
+    schema: defaultMockToolSchema,
     implementation: async ({ input }) => `Delayed result: ${input}`
   });
 }