@push.rocks/smartagent 1.5.0 → 1.5.2

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartagent',
-    version: '1.5.0',
+    version: '1.5.2',
     description: 'an agentic framework built on top of @push.rocks/smartai'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDBEQUEwRDtDQUN4RSxDQUFBIn0=

package/dist_ts/smartagent.classes.driveragent.d.ts

@@ -92,4 +92,41 @@ export declare class DriverAgent {
      * Reset the conversation state
      */
     reset(): void;
+    /**
+     * Start a task with native tool calling support
+     * Uses Ollama's native tool calling API instead of XML parsing
+     * @param task The task description
+     * @param images Optional base64-encoded images for vision tasks
+     * @returns Response with content, reasoning, and any tool calls
+     */
+    startTaskWithNativeTools(task: string, images?: string[]): Promise<{
+        message: interfaces.IAgentMessage;
+        toolCalls?: interfaces.INativeToolCall[];
+    }>;
+    /**
+     * Continue conversation with native tool calling support
+     * @param message The message to continue with (e.g., tool result)
+     * @returns Response with content, reasoning, and any tool calls
+     */
+    continueWithNativeTools(message: string): Promise<{
+        message: interfaces.IAgentMessage;
+        toolCalls?: interfaces.INativeToolCall[];
+    }>;
+    /**
+     * Get system message for native tool calling mode
+     * Simplified prompt that lets the model use tools naturally
+     */
+    private getNativeToolsSystemMessage;
+    /**
+     * Convert registered tools to Ollama JSON Schema format for native tool calling
+     * Each tool action becomes a separate function with name format: "toolName_actionName"
+     * @returns Array of IOllamaTool compatible tool definitions
+     */
+    getToolsAsJsonSchema(): plugins.smartai.IOllamaTool[];
+    /**
+     * Parse native tool calls from provider response into IToolCallProposal format
+     * @param toolCalls Array of native tool calls from the provider
+     * @returns Array of IToolCallProposal ready for execution
+     */
+    parseNativeToolCalls(toolCalls: interfaces.INativeToolCall[]): interfaces.IToolCallProposal[];
 }

package/dist_ts/smartagent.classes.driveragent.js

@@ -382,5 +382,219 @@ Your complete output here
     reset() {
         this.messageHistory = [];
     }
+    // ================================
+    // Native Tool Calling Support
+    // ================================
+    /**
+     * Start a task with native tool calling support
+     * Uses Ollama's native tool calling API instead of XML parsing
+     * @param task The task description
+     * @param images Optional base64-encoded images for vision tasks
+     * @returns Response with content, reasoning, and any tool calls
+     */
+    async startTaskWithNativeTools(task, images) {
+        // Reset message history
+        this.messageHistory = [];
+        // Build simple user message (no XML instructions needed for native tool calling)
+        const userMessage = `TASK: ${task}\n\nComplete this task using the available tools. When done, provide your final output.`;
+        // Add to history
+        this.messageHistory.push({
+            role: 'user',
+            content: userMessage,
+        });
+        // Build system message for native tool calling
+        const fullSystemMessage = this.getNativeToolsSystemMessage();
+        // Get tools in JSON schema format
+        const tools = this.getToolsAsJsonSchema();
+        // Check if provider supports native tool calling (Ollama)
+        const provider = this.provider;
+        if (typeof provider.collectStreamResponse !== 'function') {
+            throw new Error('Provider does not support native tool calling. Use startTask() instead.');
+        }
+        // Use collectStreamResponse for streaming support with tools
+        const response = await provider.collectStreamResponse({
+            systemMessage: fullSystemMessage,
+            userMessage: userMessage,
+            messageHistory: [],
+            images: images,
+            tools: tools.length > 0 ? tools : undefined,
+        }, 
+        // Pass onToken callback through onChunk for streaming
+        this.onToken ? (chunk) => {
+            if (chunk.thinking && this.onToken)
+                this.onToken(chunk.thinking);
+            if (chunk.content && this.onToken)
+                this.onToken(chunk.content);
+        } : undefined);
+        // Add assistant response to history
+        const historyMessage = {
+            role: 'assistant',
+            content: response.message || '',
+            reasoning: response.thinking || response.reasoning,
+        };
+        this.messageHistory.push(historyMessage);
+        // Convert Ollama tool calls to our format
+        let toolCalls;
+        if (response.toolCalls && response.toolCalls.length > 0) {
+            toolCalls = response.toolCalls.map((tc) => ({
+                function: {
+                    name: tc.function.name,
+                    arguments: tc.function.arguments,
+                    index: tc.function.index,
+                },
+            }));
+        }
+        return {
+            message: {
+                role: 'assistant',
+                content: response.message || '',
+            },
+            toolCalls,
+        };
+    }
+    /**
+     * Continue conversation with native tool calling support
+     * @param message The message to continue with (e.g., tool result)
+     * @returns Response with content, reasoning, and any tool calls
+     */
+    async continueWithNativeTools(message) {
+        // Add the new message to history
+        this.messageHistory.push({
+            role: 'user',
+            content: message,
+        });
+        // Build system message
+        const fullSystemMessage = this.getNativeToolsSystemMessage();
+        // Get tools in JSON schema format
+        const tools = this.getToolsAsJsonSchema();
+        // Get response from provider with history windowing
+        let historyForChat;
+        const fullHistory = this.messageHistory.slice(0, -1);
+        if (this.maxHistoryMessages > 0 && fullHistory.length > this.maxHistoryMessages) {
+            historyForChat = [
+                fullHistory[0],
+                ...fullHistory.slice(-(this.maxHistoryMessages - 1)),
+            ];
+        }
+        else {
+            historyForChat = fullHistory;
+        }
+        // Check if provider supports native tool calling
+        const provider = this.provider;
+        if (typeof provider.collectStreamResponse !== 'function') {
+            throw new Error('Provider does not support native tool calling. Use continueWithMessage() instead.');
+        }
+        // Use collectStreamResponse for streaming support with tools
+        const response = await provider.collectStreamResponse({
+            systemMessage: fullSystemMessage,
+            userMessage: message,
+            messageHistory: historyForChat,
+            tools: tools.length > 0 ? tools : undefined,
+        }, 
+        // Pass onToken callback through onChunk for streaming
+        this.onToken ? (chunk) => {
+            if (chunk.thinking && this.onToken)
+                this.onToken(chunk.thinking);
+            if (chunk.content && this.onToken)
+                this.onToken(chunk.content);
+        } : undefined);
+        // Add assistant response to history
+        this.messageHistory.push({
+            role: 'assistant',
+            content: response.message || '',
+            reasoning: response.thinking || response.reasoning,
+        });
+        // Convert Ollama tool calls to our format
+        let toolCalls;
+        if (response.toolCalls && response.toolCalls.length > 0) {
+            toolCalls = response.toolCalls.map((tc) => ({
+                function: {
+                    name: tc.function.name,
+                    arguments: tc.function.arguments,
+                    index: tc.function.index,
+                },
+            }));
+        }
+        return {
+            message: {
+                role: 'assistant',
+                content: response.message || '',
+            },
+            toolCalls,
+        };
+    }
+    /**
+     * Get system message for native tool calling mode
+     * Simplified prompt that lets the model use tools naturally
+     */
+    getNativeToolsSystemMessage() {
+        return `You are an AI assistant that executes tasks by using available tools.
+
+## Your Role
+You analyze tasks, break them down into steps, and use tools to accomplish goals.
+
+## Guidelines
+1. Think step by step about what needs to be done
+2. Use the available tools to complete the task
+3. Process tool results and continue until the task is complete
+4. When the task is complete, provide a final summary
+
+## Important
+- Use tools when needed to gather information or perform actions
+- If you need clarification, ask the user
+- Always verify your work before marking the task complete`;
+    }
+    /**
+     * Convert registered tools to Ollama JSON Schema format for native tool calling
+     * Each tool action becomes a separate function with name format: "toolName_actionName"
+     * @returns Array of IOllamaTool compatible tool definitions
+     */
+    getToolsAsJsonSchema() {
+        const tools = [];
+        for (const tool of this.tools.values()) {
+            for (const action of tool.actions) {
+                // Build the tool definition in Ollama format
+                const toolDef = {
+                    type: 'function',
+                    function: {
+                        name: `${tool.name}_${action.name}`, // e.g., "json_validate"
+                        description: `[${tool.name}] ${action.description}`,
+                        parameters: action.parameters,
+                    },
+                };
+                tools.push(toolDef);
+            }
+        }
+        return tools;
+    }
+    /**
+     * Parse native tool calls from provider response into IToolCallProposal format
+     * @param toolCalls Array of native tool calls from the provider
+     * @returns Array of IToolCallProposal ready for execution
+     */
+    parseNativeToolCalls(toolCalls) {
+        return toolCalls.map(tc => {
+            // Split "json_validate" -> toolName="json", action="validate"
+            const fullName = tc.function.name;
+            const underscoreIndex = fullName.indexOf('_');
+            let toolName;
+            let action;
+            if (underscoreIndex > 0) {
+                toolName = fullName.substring(0, underscoreIndex);
+                action = fullName.substring(underscoreIndex + 1);
+            }
+            else {
+                // Fallback: treat entire name as tool name with empty action
+                toolName = fullName;
+                action = '';
+            }
+            return {
+                proposalId: this.generateProposalId(),
+                toolName,
+                action,
+                params: tc.function.arguments,
+            };
+        });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartagent.classes.driveragent.js","sourceRoot":"","sources":["../ts/smartagent.classes.driveragent.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartagent.classes.driveragent.js","sourceRoot":"","sources":["../ts/smartagent.classes.driveragent.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartagent.classes.dualagent.js

@@ -215,11 +215,15 @@ export class DualAgentOrchestrator {
         if (!this.isRunning) {
             throw new Error('Orchestrator not started. Call start() first.');
         }
+        // Use native tool calling if enabled
+        const useNativeTools = this.options.useNativeToolCalling === true;
         this.conversationHistory = [];
         let iterations = 0;
         let consecutiveRejections = 0;
         let completed = false;
         let finalResult = null;
+        // Track pending native tool calls
+        let pendingNativeToolCalls;
         // Extract images from options
         const images = options?.images;
         // Add initial task to history
@@ -228,7 +232,17 @@ export class DualAgentOrchestrator {
             content: task,
         });
         // Start the driver with the task and optional images
-        let driverResponse = await this.driver.startTask(task, images);
+        let driverResponse;
+        if (useNativeTools) {
+            // Native tool calling mode
+            const result = await this.driver.startTaskWithNativeTools(task, images);
+            driverResponse = result.message;
+            pendingNativeToolCalls = result.toolCalls;
+        }
+        else {
+            // XML parsing mode
+            driverResponse = await this.driver.startTask(task, images);
+        }
         this.conversationHistory.push(driverResponse);
         // Emit task started event
         this.emitProgress({
@@ -245,10 +259,15 @@ export class DualAgentOrchestrator {
                 iteration: iterations,
                 maxIterations: this.options.maxIterations,
             });
-            // Check if task is complete
-            if (this.driver.isTaskComplete(driverResponse.content)) {
+            // Check if task is complete (for native mode, no pending tool calls and has content)
+            const isComplete = useNativeTools
+                ? (!pendingNativeToolCalls || pendingNativeToolCalls.length === 0) && driverResponse.content.length > 0
+                : this.driver.isTaskComplete(driverResponse.content);
+            if (isComplete) {
                 completed = true;
-                finalResult = this.driver.extractTaskResult(driverResponse.content) || driverResponse.content;
+                finalResult = useNativeTools
+                    ? driverResponse.content
+                    : (this.driver.extractTaskResult(driverResponse.content) || driverResponse.content);
                 // Emit task completed event
                 this.emitProgress({
                     type: 'task_completed',
@@ -275,11 +294,32 @@ export class DualAgentOrchestrator {
                     status: 'clarification_needed',
                 };
             }
-            // Parse tool call proposals
-            const proposals = this.driver.parseToolCallProposals(driverResponse.content);
+            // Parse tool call proposals - native mode uses pendingNativeToolCalls, XML mode parses content
+            let proposals;
+            if (useNativeTools && pendingNativeToolCalls && pendingNativeToolCalls.length > 0) {
+                // Native tool calling mode - convert native tool calls to proposals
+                proposals = this.driver.parseNativeToolCalls(pendingNativeToolCalls);
+                pendingNativeToolCalls = undefined; // Clear after processing
+            }
+            else if (!useNativeTools) {
+                // XML parsing mode
+                proposals = this.driver.parseToolCallProposals(driverResponse.content);
+            }
+            else {
+                proposals = [];
+            }
             if (proposals.length === 0) {
-                // No tool calls found - remind the model of the exact XML format
-                driverResponse = await this.driver.continueWithMessage(`No valid tool call was found in your response. To use a tool, you MUST output the exact XML format:
+                if (useNativeTools) {
+                    // Native mode: no tool calls and no content means we should continue
+                    const result = await this.driver.continueWithNativeTools('Please continue with the task. Use the available tools or provide your final output.');
+                    driverResponse = result.message;
+                    pendingNativeToolCalls = result.toolCalls;
+                    this.conversationHistory.push(driverResponse);
+                    continue;
+                }
+                else {
+                    // XML mode: remind the model of the exact XML format
+                    driverResponse = await this.driver.continueWithMessage(`No valid tool call was found in your response. To use a tool, you MUST output the exact XML format:
 
 <tool_call>
   <tool>tool_name</tool>
@@ -298,8 +338,9 @@ Or to complete the task:
 <task_complete>your final JSON output here</task_complete>
 
 Please output the exact XML format above.`);
-                this.conversationHistory.push(driverResponse);
-                continue;
+                    this.conversationHistory.push(driverResponse);
+                    continue;
+                }
             }
             // Process the first proposal (one at a time)
             const proposal = proposals[0];
@@ -393,12 +434,27 @@ Please output the exact XML format above.`);
                         toolCall: proposal,
                         toolResult: result,
                     });
-                    driverResponse = await this.driver.continueWithMessage(resultMessage);
+                    // Continue with appropriate method based on mode
+                    if (useNativeTools) {
+                        const continueResult = await this.driver.continueWithNativeTools(resultMessage);
+                        driverResponse = continueResult.message;
+                        pendingNativeToolCalls = continueResult.toolCalls;
+                    }
+                    else {
+                        driverResponse = await this.driver.continueWithMessage(resultMessage);
+                    }
                     this.conversationHistory.push(driverResponse);
                 }
                 catch (error) {
                     const errorMessage = `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`;
-                    driverResponse = await this.driver.continueWithMessage(`TOOL ERROR: ${errorMessage}\n\nPlease try a different approach.`);
+                    if (useNativeTools) {
+                        const continueResult = await this.driver.continueWithNativeTools(`TOOL ERROR: ${errorMessage}\n\nPlease try a different approach.`);
+                        driverResponse = continueResult.message;
+                        pendingNativeToolCalls = continueResult.toolCalls;
+                    }
+                    else {
+                        driverResponse = await this.driver.continueWithMessage(`TOOL ERROR: ${errorMessage}\n\nPlease try a different approach.`);
+                    }
                     this.conversationHistory.push(driverResponse);
                 }
             }
@@ -429,7 +485,15 @@ Please output the exact XML format above.`);
                     toolCall: proposal,
                     guardianDecision: decision,
                 });
-                driverResponse = await this.driver.continueWithMessage(feedback);
+                // Continue with appropriate method based on mode
+                if (useNativeTools) {
+                    const continueResult = await this.driver.continueWithNativeTools(feedback);
+                    driverResponse = continueResult.message;
+                    pendingNativeToolCalls = continueResult.toolCalls;
+                }
+                else {
+                    driverResponse = await this.driver.continueWithMessage(feedback);
+                }
                 this.conversationHistory.push(driverResponse);
             }
         }
@@ -514,4 +578,4 @@ Please output the exact XML format above.`);
         return Array.from(this.tools.keys());
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartagent.classes.dualagent.js","sourceRoot":"","sources":["../ts/smartagent.classes.dualagent.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartagent.classes.dualagent.js","sourceRoot":"","sources":["../ts/smartagent.classes.dualagent.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartagent.interfaces.d.ts

@@ -38,6 +38,12 @@ export interface IDualAgentOptions extends plugins.smartai.ISmartAiOptions {
     logPrefix?: string;
     /** Callback fired for each token during LLM generation (streaming mode) */
     onToken?: (token: string, source: 'driver' | 'guardian') => void;
+    /**
+     * Enable native tool calling mode (default: false)
+     * When enabled, uses Ollama's native tool calling API instead of XML parsing
+     * This is more efficient for models that support it (e.g., GPT-OSS with Harmony format)
+     */
+    useNativeToolCalling?: boolean;
 }
 /**
  * Represents a message in the agent's conversation history
@@ -62,6 +68,17 @@ export interface IToolAction {
     /** JSON schema for action parameters */
     parameters: Record<string, unknown>;
 }
+/**
+ * Native tool call from provider (matches Ollama's tool calling format)
+ * Format: function name is "toolName_actionName" (e.g., "json_validate")
+ */
+export interface INativeToolCall {
+    function: {
+        name: string;
+        arguments: Record<string, unknown>;
+        index?: number;
+    };
+}
 /**
  * Proposed tool call from the Driver
  */

package/dist_ts/smartagent.interfaces.js

@@ -5,4 +5,4 @@ import * as plugins from './plugins.js';
 export function generateProposalId() {
     return `proposal_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhZ2VudC5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRhZ2VudC5pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBMFJ4Qzs7R0FFRztBQUNILE1BQU0sVUFBVSxrQkFBa0I7SUFDaEMsT0FBTyxZQUFZLElBQUksQ0FBQyxHQUFHLEVBQUUsSUFBSSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQztBQUNoRixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhZ2VudC5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRhZ2VudC5pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBNFN4Qzs7R0FFRztBQUNILE1BQU0sVUFBVSxrQkFBa0I7SUFDaEMsT0FBTyxZQUFZLElBQUksQ0FBQyxHQUFHLEVBQUUsSUFBSSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQztBQUNoRixDQUFDIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartagent",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "private": false,
   "description": "an agentic framework built on top of @push.rocks/smartai",
   "main": "dist_ts/index.js",
@@ -21,7 +21,7 @@
     "@types/node": "^25.0.2"
   },
   "dependencies": {
-    "@push.rocks/smartai": "^0.13.0",
+    "@push.rocks/smartai": "^0.13.1",
     "@push.rocks/smartbrowser": "^2.0.8",
     "@push.rocks/smartdeno": "^1.2.0",
     "@push.rocks/smartfs": "^1.2.0",

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartagent',
-  version: '1.5.0',
+  version: '1.5.2',
   description: 'an agentic framework built on top of @push.rocks/smartai'
 }

package/ts/smartagent.classes.driveragent.ts

@@ -442,4 +442,252 @@ Your complete output here
   public reset(): void {
     this.messageHistory = [];
   }
+
+  // ================================
+  // Native Tool Calling Support
+  // ================================
+
+  /**
+   * Start a task with native tool calling support
+   * Uses Ollama's native tool calling API instead of XML parsing
+   * @param task The task description
+   * @param images Optional base64-encoded images for vision tasks
+   * @returns Response with content, reasoning, and any tool calls
+   */
+  public async startTaskWithNativeTools(
+    task: string,
+    images?: string[]
+  ): Promise<{ message: interfaces.IAgentMessage; toolCalls?: interfaces.INativeToolCall[] }> {
+    // Reset message history
+    this.messageHistory = [];
+
+    // Build simple user message (no XML instructions needed for native tool calling)
+    const userMessage = `TASK: ${task}\n\nComplete this task using the available tools. When done, provide your final output.`;
+
+    // Add to history
+    this.messageHistory.push({
+      role: 'user',
+      content: userMessage,
+    });
+
+    // Build system message for native tool calling
+    const fullSystemMessage = this.getNativeToolsSystemMessage();
+
+    // Get tools in JSON schema format
+    const tools = this.getToolsAsJsonSchema();
+
+    // Check if provider supports native tool calling (Ollama)
+    const provider = this.provider as any;
+    if (typeof provider.collectStreamResponse !== 'function') {
+      throw new Error('Provider does not support native tool calling. Use startTask() instead.');
+    }
+
+    // Use collectStreamResponse for streaming support with tools
+    const response = await provider.collectStreamResponse(
+      {
+        systemMessage: fullSystemMessage,
+        userMessage: userMessage,
+        messageHistory: [],
+        images: images,
+        tools: tools.length > 0 ? tools : undefined,
+      },
+      // Pass onToken callback through onChunk for streaming
+      this.onToken ? (chunk: any) => {
+        if (chunk.thinking && this.onToken) this.onToken(chunk.thinking);
+        if (chunk.content && this.onToken) this.onToken(chunk.content);
+      } : undefined
+    );
+
+    // Add assistant response to history
+    const historyMessage: plugins.smartai.ChatMessage = {
+      role: 'assistant',
+      content: response.message || '',
+      reasoning: response.thinking || response.reasoning,
+    };
+    this.messageHistory.push(historyMessage);
+
+    // Convert Ollama tool calls to our format
+    let toolCalls: interfaces.INativeToolCall[] | undefined;
+    if (response.toolCalls && response.toolCalls.length > 0) {
+      toolCalls = response.toolCalls.map((tc: any) => ({
+        function: {
+          name: tc.function.name,
+          arguments: tc.function.arguments,
+          index: tc.function.index,
+        },
+      }));
+    }
+
+    return {
+      message: {
+        role: 'assistant',
+        content: response.message || '',
+      },
+      toolCalls,
+    };
+  }
+
+  /**
+   * Continue conversation with native tool calling support
+   * @param message The message to continue with (e.g., tool result)
+   * @returns Response with content, reasoning, and any tool calls
+   */
+  public async continueWithNativeTools(
+    message: string
+  ): Promise<{ message: interfaces.IAgentMessage; toolCalls?: interfaces.INativeToolCall[] }> {
+    // Add the new message to history
+    this.messageHistory.push({
+      role: 'user',
+      content: message,
+    });
+
+    // Build system message
+    const fullSystemMessage = this.getNativeToolsSystemMessage();
+
+    // Get tools in JSON schema format
+    const tools = this.getToolsAsJsonSchema();
+
+    // Get response from provider with history windowing
+    let historyForChat: plugins.smartai.ChatMessage[];
+    const fullHistory = this.messageHistory.slice(0, -1);
+
+    if (this.maxHistoryMessages > 0 && fullHistory.length > this.maxHistoryMessages) {
+      historyForChat = [
+        fullHistory[0],
+        ...fullHistory.slice(-(this.maxHistoryMessages - 1)),
+      ];
+    } else {
+      historyForChat = fullHistory;
+    }
+
+    // Check if provider supports native tool calling
+    const provider = this.provider as any;
+    if (typeof provider.collectStreamResponse !== 'function') {
+      throw new Error('Provider does not support native tool calling. Use continueWithMessage() instead.');
+    }
+
+    // Use collectStreamResponse for streaming support with tools
+    const response = await provider.collectStreamResponse(
+      {
+        systemMessage: fullSystemMessage,
+        userMessage: message,
+        messageHistory: historyForChat,
+        tools: tools.length > 0 ? tools : undefined,
+      },
+      // Pass onToken callback through onChunk for streaming
+      this.onToken ? (chunk: any) => {
+        if (chunk.thinking && this.onToken) this.onToken(chunk.thinking);
+        if (chunk.content && this.onToken) this.onToken(chunk.content);
+      } : undefined
+    );
+
+    // Add assistant response to history
+    this.messageHistory.push({
+      role: 'assistant',
+      content: response.message || '',
+      reasoning: response.thinking || response.reasoning,
+    });
+
+    // Convert Ollama tool calls to our format
+    let toolCalls: interfaces.INativeToolCall[] | undefined;
+    if (response.toolCalls && response.toolCalls.length > 0) {
+      toolCalls = response.toolCalls.map((tc: any) => ({
+        function: {
+          name: tc.function.name,
+          arguments: tc.function.arguments,
+          index: tc.function.index,
+        },
+      }));
+    }
+
+    return {
+      message: {
+        role: 'assistant',
+        content: response.message || '',
+      },
+      toolCalls,
+    };
+  }
+
+  /**
+   * Get system message for native tool calling mode
+   * Simplified prompt that lets the model use tools naturally
+   */
+  private getNativeToolsSystemMessage(): string {
+    return `You are an AI assistant that executes tasks by using available tools.
+
+## Your Role
+You analyze tasks, break them down into steps, and use tools to accomplish goals.
+
+## Guidelines
+1. Think step by step about what needs to be done
+2. Use the available tools to complete the task
+3. Process tool results and continue until the task is complete
+4. When the task is complete, provide a final summary
+
+## Important
+- Use tools when needed to gather information or perform actions
+- If you need clarification, ask the user
+- Always verify your work before marking the task complete`;
+  }
+
+  /**
+   * Convert registered tools to Ollama JSON Schema format for native tool calling
+   * Each tool action becomes a separate function with name format: "toolName_actionName"
+   * @returns Array of IOllamaTool compatible tool definitions
+   */
+  public getToolsAsJsonSchema(): plugins.smartai.IOllamaTool[] {
+    const tools: plugins.smartai.IOllamaTool[] = [];
+
+    for (const tool of this.tools.values()) {
+      for (const action of tool.actions) {
+        // Build the tool definition in Ollama format
+        const toolDef: plugins.smartai.IOllamaTool = {
+          type: 'function',
+          function: {
+            name: `${tool.name}_${action.name}`,  // e.g., "json_validate"
+            description: `[${tool.name}] ${action.description}`,
+            parameters: action.parameters as plugins.smartai.IOllamaTool['function']['parameters'],
+          },
+        };
+        tools.push(toolDef);
+      }
+    }
+
+    return tools;
+  }
+
+  /**
+   * Parse native tool calls from provider response into IToolCallProposal format
+   * @param toolCalls Array of native tool calls from the provider
+   * @returns Array of IToolCallProposal ready for execution
+   */
+  public parseNativeToolCalls(
+    toolCalls: interfaces.INativeToolCall[]
+  ): interfaces.IToolCallProposal[] {
+    return toolCalls.map(tc => {
+      // Split "json_validate" -> toolName="json", action="validate"
+      const fullName = tc.function.name;
+      const underscoreIndex = fullName.indexOf('_');
+
+      let toolName: string;
+      let action: string;
+
+      if (underscoreIndex > 0) {
+        toolName = fullName.substring(0, underscoreIndex);
+        action = fullName.substring(underscoreIndex + 1);
+      } else {
+        // Fallback: treat entire name as tool name with empty action
+        toolName = fullName;
+        action = '';
+      }
+
+      return {
+        proposalId: this.generateProposalId(),
+        toolName,
+        action,
+        params: tc.function.arguments,
+      };
+    });
+  }
 }

package/ts/smartagent.classes.dualagent.ts

@@ -242,12 +242,18 @@ export class DualAgentOrchestrator {
       throw new Error('Orchestrator not started. Call start() first.');
     }
 
+    // Use native tool calling if enabled
+    const useNativeTools = this.options.useNativeToolCalling === true;
+
     this.conversationHistory = [];
     let iterations = 0;
     let consecutiveRejections = 0;
     let completed = false;
     let finalResult: string | null = null;
 
+    // Track pending native tool calls
+    let pendingNativeToolCalls: interfaces.INativeToolCall[] | undefined;
+
     // Extract images from options
     const images = options?.images;
 
@@ -258,7 +264,17 @@ export class DualAgentOrchestrator {
     });
 
     // Start the driver with the task and optional images
-    let driverResponse = await this.driver.startTask(task, images);
+    let driverResponse: interfaces.IAgentMessage;
+
+    if (useNativeTools) {
+      // Native tool calling mode
+      const result = await this.driver.startTaskWithNativeTools(task, images);
+      driverResponse = result.message;
+      pendingNativeToolCalls = result.toolCalls;
+    } else {
+      // XML parsing mode
+      driverResponse = await this.driver.startTask(task, images);
+    }
     this.conversationHistory.push(driverResponse);
 
     // Emit task started event
@@ -281,10 +297,16 @@ export class DualAgentOrchestrator {
         maxIterations: this.options.maxIterations,
       });
 
-      // Check if task is complete
-      if (this.driver.isTaskComplete(driverResponse.content)) {
+      // Check if task is complete (for native mode, no pending tool calls and has content)
+      const isComplete = useNativeTools
+        ? (!pendingNativeToolCalls || pendingNativeToolCalls.length === 0) && driverResponse.content.length > 0
+        : this.driver.isTaskComplete(driverResponse.content);
+
+      if (isComplete) {
         completed = true;
-        finalResult = this.driver.extractTaskResult(driverResponse.content) || driverResponse.content;
+        finalResult = useNativeTools
+          ? driverResponse.content
+          : (this.driver.extractTaskResult(driverResponse.content) || driverResponse.content);
 
         // Emit task completed event
         this.emitProgress({
@@ -315,13 +337,34 @@ export class DualAgentOrchestrator {
         };
       }
 
-      // Parse tool call proposals
-      const proposals = this.driver.parseToolCallProposals(driverResponse.content);
+      // Parse tool call proposals - native mode uses pendingNativeToolCalls, XML mode parses content
+      let proposals: interfaces.IToolCallProposal[];
+
+      if (useNativeTools && pendingNativeToolCalls && pendingNativeToolCalls.length > 0) {
+        // Native tool calling mode - convert native tool calls to proposals
+        proposals = this.driver.parseNativeToolCalls(pendingNativeToolCalls);
+        pendingNativeToolCalls = undefined; // Clear after processing
+      } else if (!useNativeTools) {
+        // XML parsing mode
+        proposals = this.driver.parseToolCallProposals(driverResponse.content);
+      } else {
+        proposals = [];
+      }
 
       if (proposals.length === 0) {
-        // No tool calls found - remind the model of the exact XML format
-        driverResponse = await this.driver.continueWithMessage(
-          `No valid tool call was found in your response. To use a tool, you MUST output the exact XML format:
+        if (useNativeTools) {
+          // Native mode: no tool calls and no content means we should continue
+          const result = await this.driver.continueWithNativeTools(
+            'Please continue with the task. Use the available tools or provide your final output.'
+          );
+          driverResponse = result.message;
+          pendingNativeToolCalls = result.toolCalls;
+          this.conversationHistory.push(driverResponse);
+          continue;
+        } else {
+          // XML mode: remind the model of the exact XML format
+          driverResponse = await this.driver.continueWithMessage(
+            `No valid tool call was found in your response. To use a tool, you MUST output the exact XML format:
 
 <tool_call>
   <tool>tool_name</tool>
@@ -340,9 +383,10 @@ Or to complete the task:
 <task_complete>your final JSON output here</task_complete>
 
 Please output the exact XML format above.`
-        );
-        this.conversationHistory.push(driverResponse);
-        continue;
+          );
+          this.conversationHistory.push(driverResponse);
+          continue;
+        }
       }
 
       // Process the first proposal (one at a time)
@@ -449,13 +493,28 @@ Please output the exact XML format above.`
             toolResult: result,
           });
 
-          driverResponse = await this.driver.continueWithMessage(resultMessage);
+          // Continue with appropriate method based on mode
+          if (useNativeTools) {
+            const continueResult = await this.driver.continueWithNativeTools(resultMessage);
+            driverResponse = continueResult.message;
+            pendingNativeToolCalls = continueResult.toolCalls;
+          } else {
+            driverResponse = await this.driver.continueWithMessage(resultMessage);
+          }
           this.conversationHistory.push(driverResponse);
         } catch (error) {
           const errorMessage = `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`;
-          driverResponse = await this.driver.continueWithMessage(
-            `TOOL ERROR: ${errorMessage}\n\nPlease try a different approach.`
-          );
+          if (useNativeTools) {
+            const continueResult = await this.driver.continueWithNativeTools(
+              `TOOL ERROR: ${errorMessage}\n\nPlease try a different approach.`
+            );
+            driverResponse = continueResult.message;
+            pendingNativeToolCalls = continueResult.toolCalls;
+          } else {
+            driverResponse = await this.driver.continueWithMessage(
+              `TOOL ERROR: ${errorMessage}\n\nPlease try a different approach.`
+            );
+          }
           this.conversationHistory.push(driverResponse);
         }
       } else {
@@ -492,7 +551,14 @@ Please output the exact XML format above.`
           guardianDecision: decision,
         });
 
-        driverResponse = await this.driver.continueWithMessage(feedback);
+        // Continue with appropriate method based on mode
+        if (useNativeTools) {
+          const continueResult = await this.driver.continueWithNativeTools(feedback);
+          driverResponse = continueResult.message;
+          pendingNativeToolCalls = continueResult.toolCalls;
+        } else {
+          driverResponse = await this.driver.continueWithMessage(feedback);
+        }
         this.conversationHistory.push(driverResponse);
       }
     }

package/ts/smartagent.interfaces.ts

@@ -48,6 +48,12 @@ export interface IDualAgentOptions extends plugins.smartai.ISmartAiOptions {
   logPrefix?: string;
   /** Callback fired for each token during LLM generation (streaming mode) */
   onToken?: (token: string, source: 'driver' | 'guardian') => void;
+  /**
+   * Enable native tool calling mode (default: false)
+   * When enabled, uses Ollama's native tool calling API instead of XML parsing
+   * This is more efficient for models that support it (e.g., GPT-OSS with Harmony format)
+   */
+  useNativeToolCalling?: boolean;
 }
 
 // ================================
@@ -83,6 +89,18 @@ export interface IToolAction {
   parameters: Record<string, unknown>;
 }
 
+/**
+ * Native tool call from provider (matches Ollama's tool calling format)
+ * Format: function name is "toolName_actionName" (e.g., "json_validate")
+ */
+export interface INativeToolCall {
+  function: {
+    name: string;  // Format: "toolName_actionName"
+    arguments: Record<string, unknown>;
+    index?: number;
+  };
+}
+
 /**
  * Proposed tool call from the Driver
  */