Feat/mcp build

.cspell/project-words.txt

@@ -45,6 +45,7 @@ Macbook
 MCPHTTP
 minilm
 Mixtral
+modelcontextprotocol
 modelinfo
 multiservice
 nanos

src/ai-sdk-provider/provider.ts

@@ -318,6 +318,16 @@ function convertToAxChatPrompt(
               break
             }
 
+            case 'reasoning': {
+              // Reasoning parts are ignored in the message conversion
+              break
+            }
+
+            case 'redacted-reasoning': {
+              // Redacted reasoning parts are ignored in the message conversion
+              break
+            }
+
             default: {
               const _exhaustiveCheck = part
               throw new Error(`Unsupported part: ${_exhaustiveCheck}`)

src/ax/funcs/code.ts

@@ -80,8 +80,19 @@ export class AxJSInterpreter {
         required: ['code'],
       },
 
-      func: ({ code }: Readonly<{ code: string }>) =>
-        this.codeInterpreterJavascript(code),
+      func: async (args?: unknown, options?) => {
+        // Validate args
+        if (!args || typeof args !== 'object') {
+          throw new Error('Invalid arguments: expected object with code property')
+        }
+
+        const { code } = args as { code: string }
+        if (typeof code !== 'string') {
+          throw new Error('Code must be a string')
+        }
+
+        return this.codeInterpreterJavascript(code)
+      },
     }
   }
 }

src/ax/funcs/docker.ts

@@ -387,8 +387,19 @@ export class AxDockerSession {
         required: ['command'],
       },
 
-      func: async ({ command }: Readonly<{ command: string }>) =>
-        await this.executeCommand(command),
+      func: async (args?: unknown, options?) => {
+        // Validate args
+        if (!args || typeof args !== 'object') {
+          throw new Error('Invalid arguments: expected object with command property')
+        }
+
+        const { command } = args as { command: string }
+        if (typeof command !== 'string') {
+          throw new Error('Command must be a string')
+        }
+
+        return await this.executeCommand(command)
+      },
     }
   }
 }

src/ax/funcs/embed.ts

@@ -68,8 +68,19 @@ export class AxEmbeddingAdapter {
         },
         required: ['text'],
       },
-      func: ({ text }: Readonly<{ text: string }>, options) =>
-        this.embedAdapter(text, options),
+      func: async (args?: unknown, options?) => {
+        // Validate args
+        if (!args || typeof args !== 'object') {
+          throw new Error('Invalid arguments: expected object with text property')
+        }
+
+        const { text } = args as { text: string }
+        if (typeof text !== 'string') {
+          throw new Error('Text must be a string')
+        }
+
+        return this.embedAdapter(text, options)
+      },
     }
   }
 }

src/ax/prompts/agent.ts

@@ -88,7 +88,7 @@ function processChildAgentFunction<IN extends AxGenIn>(
       // add debug logging if enabled
       processedFunction.func = async (childArgs, funcOptions) => {
         const updatedChildArgs = {
-          ...childArgs,
+          ...(childArgs || {}),
           ...pick(parentValues, injectionKeys as (keyof IN)[]),
         }
 
@@ -112,7 +112,11 @@ function processChildAgentFunction<IN extends AxGenIn>(
     options.canConfigureSmartModelRouting
   ) {
     processedFunction.parameters = addModelParameter(
-      processedFunction.parameters,
+      processedFunction.parameters || {
+        type: 'object',
+        properties: {},
+        required: []
+      },
       modelList
     )
   }
@@ -172,7 +176,7 @@ export class AxAgent<IN extends AxGenIn, OUT extends AxGenOut = AxGenOut>
 
     this.ai = ai
     this.agents = agents
-    this.functions = functions
+    this.functions = this.initFunctions(functions)
     this.disableSmartModelRouting = disableSmartModelRouting
     this.excludeFieldsFromPassthrough = excludeFieldsFromPassthrough ?? []
     this.debug = debug
@@ -250,9 +254,15 @@ export class AxAgent<IN extends AxGenIn, OUT extends AxGenOut = AxGenOut>
 
     // Create a wrapper function that excludes the 'ai' parameter
     const wrappedFunc: AxFunctionHandler = async (
-      valuesAndModel: IN & { model: string },
+      args?: unknown,
       options?
     ): Promise<string> => {
+      // Type guard to ensure args is the expected type
+      if (!args || typeof args !== 'object') {
+        throw new Error('Invalid arguments: expected object')
+      }
+
+      const valuesAndModel = args as IN & { model: string }
       const { model, ...values } = valuesAndModel
 
       const ai = this.ai ?? options?.ai
@@ -403,6 +413,32 @@ export class AxAgent<IN extends AxGenIn, OUT extends AxGenOut = AxGenOut>
   ): boolean {
     return options?.debug ?? this.debug ?? ai?.getOptions()?.debug ?? false
   }
+
+  private initFunctions(
+    functions: AxInputFunctionType | undefined
+  ): AxFunction[] | undefined {
+    if (!functions) return undefined
+
+    // Handle the two possible types:
+    // 1. Array of AxFunction objects
+    // 2. Array of objects with toFunction method
+    if (Array.isArray(functions)) {
+      // Check if the first item has a toFunction method
+      if (functions.length > 0 && functions[0] && 'toFunction' in functions[0]) {
+        // This is an array of objects with toFunction method
+        return (functions as { toFunction: () => AxFunction | AxFunction[] }[])
+          .flatMap(fn => {
+            const result = fn.toFunction()
+            return Array.isArray(result) ? result : [result]
+          })
+      } else {
+        // This is already an array of AxFunction objects
+        return functions as AxFunction[]
+      }
+    }
+
+    return []
+  }
 }
 
 function toCamelCase(inputString: string): string {