@looopy-ai/core 1.0.3 → 1.1.0

package/dist/core/iteration.js

@@ -31,7 +31,7 @@ export const runIteration = (context, config, history) => {
         logger: context.logger.child({ iteration: config.iterationNumber }),
         parentContext: iterationContext,
     }, event)));
-    return concat(llmEvents$, toolEvents$).pipe(finishIterationSpan);
+    return concat(llmEvents$.pipe(filter((event) => event.kind !== 'tool-call')), toolEvents$).pipe(finishIterationSpan);
 };
 const prepareMessages = (context, history) => {
     const messages = [];

package/dist/core/tools.js

@@ -1,4 +1,4 @@
-import { concat, defer, of } from 'rxjs';
+import { concat, defer, mergeMap, of } from 'rxjs';
 import { startToolExecuteSpan } from '../observability/spans';
 export const runToolCall = (context, toolCall) => {
     const logger = context.logger.child({
@@ -6,54 +6,56 @@ export const runToolCall = (context, toolCall) => {
         toolCallId: toolCall.toolCallId,
         toolName: toolCall.toolName,
     });
-    const toolStartEvent = {
-        kind: 'tool-start',
-        contextId: context.contextId,
-        taskId: context.taskId,
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        arguments: toolCall.arguments,
-        timestamp: new Date().toISOString(),
-    };
-    const { tapFinish } = startToolExecuteSpan(context, toolStartEvent);
-    const toolResultEvents$ = defer(async () => {
-        logger.trace('Executing tool');
-        const provider = context.toolProviders.find((p) => p.canHandle(toolCall.toolName));
-        if (!provider) {
-            logger.warn('No provider found for tool');
-            const errorMessage = `No provider found for tool: ${toolCall.toolName}`;
-            return createToolErrorEvent(context, toolCall, errorMessage);
-        }
-        try {
-            const result = await provider.execute({
-                id: toolCall.toolCallId,
-                type: 'function',
-                function: {
-                    name: toolCall.toolName,
-                    arguments: toolCall.arguments,
-                },
-            }, {
-                contextId: context.contextId,
-                taskId: context.taskId,
-                agentId: context.agentId,
-                parentContext: context.parentContext,
-                authContext: context.authContext,
-            });
-            logger.trace({
-                success: result.success,
-            }, 'Tool execution complete');
-            return createToolCompleteEvent(context, toolCall, result.result);
+    return defer(async () => {
+        const matchingProviders = await Promise.all(context.toolProviders.map(async (p) => ({
+            provider: p,
+            tool: await p.getTool(toolCall.toolName),
+        })));
+        const matchingProvider = matchingProviders.find((p) => p.tool !== undefined);
+        if (!matchingProvider) {
+            logger.warn('No tool provider found for tool');
+            return of(toolCall);
         }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            logger.error({
-                error: err.message,
-                stack: err.stack,
-            }, 'Tool execution failed');
-            return createToolErrorEvent(context, toolCall, err.message);
-        }
-    });
-    return concat(of(toolStartEvent), toolResultEvents$).pipe(tapFinish);
+        const { provider, tool } = matchingProvider;
+        logger.trace({ providerName: provider.name }, 'Found tool provider for tool');
+        const toolStartEvent = {
+            kind: 'tool-start',
+            contextId: context.contextId,
+            taskId: context.taskId,
+            toolCallId: toolCall.toolCallId,
+            icon: tool.icon,
+            toolName: toolCall.toolName,
+            arguments: toolCall.arguments,
+            timestamp: new Date().toISOString(),
+        };
+        const { tapFinish } = startToolExecuteSpan(context, toolCall);
+        const toolResultEvents$ = defer(async () => {
+            logger.trace({ providerName: provider.name }, 'Executing tool');
+            try {
+                const result = await provider.execute({
+                    id: toolCall.toolCallId,
+                    type: 'function',
+                    function: {
+                        name: toolCall.toolName,
+                        arguments: toolCall.arguments,
+                    },
+                }, context);
+                logger.trace({
+                    success: result.success,
+                }, 'Tool execution complete');
+                return createToolCompleteEvent(context, toolCall, result.result);
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                logger.error({
+                    error: err.message,
+                    stack: err.stack,
+                }, 'Tool execution failed');
+                return createToolErrorEvent(context, toolCall, err.message);
+            }
+        });
+        return concat(of(toolStartEvent), toolResultEvents$).pipe(tapFinish);
+    }).pipe(mergeMap((obs) => obs));
 };
 const createToolCompleteEvent = (context, toolCall, result) => ({
     kind: 'tool-complete',

package/dist/observability/spans/tool.d.ts

@@ -1,5 +1,5 @@
 import type { IterationContext } from '../../core/types';
-import type { ToolExecutionEvent, ToolStartEvent } from '../../types/event';
+import type { ToolCallEvent, ToolExecutionEvent } from '../../types/event';
 import type { ToolCall } from '../../types/tools';
 export interface ToolExecutionSpanParams {
     agentId: string;
@@ -7,7 +7,7 @@ export interface ToolExecutionSpanParams {
     toolCall: ToolCall;
     parentContext?: import('@opentelemetry/api').Context;
 }
-export declare const startToolExecuteSpan: (context: IterationContext, toolStart: ToolStartEvent) => {
+export declare const startToolExecuteSpan: (context: IterationContext, toolStart: ToolCallEvent) => {
     span: import("@opentelemetry/api").Span;
     traceContext: import("@opentelemetry/api").Context;
     tapFinish: import("rxjs").MonoTypeOperatorFunction<ToolExecutionEvent>;

package/dist/tools/client-tool-provider.d.ts

@@ -5,18 +5,18 @@ export interface ClientToolConfig {
     onInputRequired: (toolCall: ToolCall, context: ExecutionContext) => Promise<ToolResult>;
 }
 export declare class ClientToolProvider implements ToolProvider {
+    name: string;
     private readonly tools;
     private readonly toolNames;
     private readonly onInputRequired;
     constructor(config: ClientToolConfig);
     getTools(): Promise<ToolDefinition[]>;
-    canHandle(toolName: string): boolean;
     execute(toolCall: ToolCall, context: ExecutionContext): Promise<ToolResult>;
-    getTool(name: string): ToolDefinition | undefined;
-    validateToolArguments(toolCall: ToolCall): {
+    getTool(name: string): Promise<ToolDefinition | undefined>;
+    validateToolArguments(toolCall: ToolCall): Promise<{
         valid: boolean;
         errors?: string[];
-    };
+    }>;
     private validateRequiredParams;
     private validateUnknownParams;
     private validateParamTypes;

package/dist/tools/client-tool-provider.js

@@ -1,5 +1,6 @@
 import { validateToolDefinitions, } from '../types/tools';
 export class ClientToolProvider {
+    name = 'client-tool-provider';
     tools;
     toolNames;
     onInputRequired;
@@ -24,11 +25,9 @@ export class ClientToolProvider {
     async getTools() {
         return [...this.tools];
     }
-    canHandle(toolName) {
-        return this.toolNames.has(toolName);
-    }
     async execute(toolCall, context) {
-        if (!this.canHandle(toolCall.function.name)) {
+        const tool = await this.getTool(toolCall.function.name);
+        if (!tool) {
             return {
                 toolCallId: toolCall.id,
                 toolName: toolCall.function.name,
@@ -60,11 +59,11 @@ export class ClientToolProvider {
             };
         }
     }
-    getTool(name) {
+    async getTool(name) {
         return this.tools.find((t) => t.name === name);
     }
-    validateToolArguments(toolCall) {
-        const tool = this.getTool(toolCall.function.name);
+    async validateToolArguments(toolCall) {
+        const tool = await this.getTool(toolCall.function.name);
         if (!tool) {
             return { valid: false, errors: [`Tool ${toolCall.function.name} not found`] };
         }

package/dist/tools/local-tools.d.ts

@@ -1,13 +1,13 @@
 import { z } from 'zod';
 import type { ExecutionContext } from '../types/context';
 import type { ToolProvider } from '../types/tools';
-type ToolHandler<TParams> = (params: TParams, context: ExecutionContext) => Promise<unknown> | unknown;
-interface LocalToolDefinition<TSchema extends z.ZodObject> {
+export type ToolHandler<TParams> = (params: TParams, context: ExecutionContext) => Promise<unknown> | unknown;
+export interface LocalToolDefinition<TSchema extends z.ZodObject> {
     name: string;
     description: string;
+    icon?: string;
     schema: TSchema;
     handler: ToolHandler<z.infer<TSchema>>;
 }
 export declare function tool<TSchema extends z.ZodObject>(name: string, description: string, schema: TSchema, handler: ToolHandler<z.infer<TSchema>>): LocalToolDefinition<TSchema>;
 export declare function localTools(tools: LocalToolDefinition<z.ZodObject>[]): ToolProvider;
-export {};

package/dist/tools/local-tools.js

@@ -19,12 +19,25 @@ export function localTools(tools) {
         toolMap.set(tool.name, tool);
     }
     return {
+        name: 'local-tool-provider',
         getTools: async () => tools.map((t) => ({
             name: t.name,
             description: t.description,
+            icon: t.icon,
             parameters: zodToJsonSchema(t.schema),
         })),
-        canHandle: (toolName) => toolMap.has(toolName),
+        getTool: async (toolName) => {
+            const toolDef = toolMap.get(toolName);
+            if (!toolDef) {
+                return undefined;
+            }
+            return {
+                name: toolDef.name,
+                description: toolDef.description,
+                icon: toolDef.icon,
+                parameters: zodToJsonSchema(toolDef.schema),
+            };
+        },
         execute: async (toolCall, context) => {
             const toolDef = toolMap.get(toolCall.function.name);
             if (!toolDef) {

package/dist/tools/mcp-tool-provider.d.ts

@@ -8,6 +8,7 @@ export interface MCPProviderConfig {
 }
 export declare const mcp: (config: MCPProviderConfig) => McpToolProvider;
 export declare class McpToolProvider implements ToolProvider {
+    name: string;
     readonly id: string;
     private readonly client;
     private toolCache;
@@ -15,8 +16,9 @@ export declare class McpToolProvider implements ToolProvider {
     private readonly cacheTTL;
     private ongoingRequest;
     constructor(config: MCPProviderConfig);
+    getTool(toolName: string): Promise<ToolDefinition | undefined>;
+    executeBatch(toolCalls: ToolCall[], context: ExecutionContext): Promise<ToolResult[]>;
     getTools(): Promise<ToolDefinition[]>;
-    canHandle(toolName: string): boolean;
     execute(toolCall: ToolCall, context: ExecutionContext): Promise<ToolResult>;
     private convertMCPTool;
 }

package/dist/tools/mcp-tool-provider.js

@@ -3,6 +3,7 @@ export const mcp = (config) => {
     return new McpToolProvider(config);
 };
 export class McpToolProvider {
+    name = 'mcp-tool-provider';
     id;
     client;
     toolCache = new Map();
@@ -17,6 +18,13 @@ export class McpToolProvider {
             getHeaders: config.getHeaders,
         });
     }
+    async getTool(toolName) {
+        const tools = await this.getTools();
+        return tools.find((tool) => tool.name === toolName);
+    }
+    async executeBatch(toolCalls, context) {
+        return Promise.all(toolCalls.map((call) => this.execute(call, context)));
+    }
     async getTools() {
         if (this.toolCache.size > 0 && this.cacheExpiry && Date.now() < this.cacheExpiry) {
             return Array.from(this.toolCache.values());
@@ -40,9 +48,6 @@ export class McpToolProvider {
         });
         return this.ongoingRequest;
     }
-    canHandle(toolName) {
-        return this.toolCache.has(toolName);
-    }
     async execute(toolCall, context) {
         const { name, arguments: args } = toolCall.function;
         if (typeof args !== 'object' || args === null) {

package/dist/types/event.d.ts

@@ -98,6 +98,7 @@ export interface ToolStartEvent {
     contextId: string;
     taskId: string;
     toolCallId: string;
+    icon?: string;
     toolName: string;
     arguments: Record<string, unknown>;
     timestamp: string;
@@ -112,6 +113,7 @@ export interface ToolProgressEvent {
     contextId: string;
     taskId: string;
     toolCallId: string;
+    icon?: string;
     progress: number;
     message?: string;
     timestamp: string;
@@ -127,6 +129,7 @@ export interface ToolCompleteEvent {
     contextId: string;
     taskId: string;
     toolCallId: string;
+    icon?: string;
     toolName: string;
     success: boolean;
     result?: unknown;

package/dist/types/tools.d.ts

@@ -27,6 +27,7 @@ export type FunctionParameters = z.infer<typeof FunctionParametersSchema>;
 export declare const ToolDefinitionSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
     parameters: z.ZodObject<{
         type: z.ZodLiteral<"object">;
         properties: z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
@@ -50,8 +51,9 @@ export declare const ToolCallSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type ToolProvider = {
+    get name(): string;
+    getTool(toolName: string): Promise<ToolDefinition | undefined>;
     getTools(): Promise<ToolDefinition[]>;
     execute(toolCall: ToolCall, context: ExecutionContext): Promise<ToolResult>;
-    canHandle(toolName: string): boolean;
     executeBatch?(toolCalls: ToolCall[], context: ExecutionContext): Promise<ToolResult[]>;
 };

package/dist/types/tools.js

@@ -31,6 +31,7 @@ export const ToolDefinitionSchema = z.object({
         .max(64)
         .regex(/^[a-zA-Z0-9_-]+$/, 'Tool name must contain only alphanumeric characters, underscores, and hyphens'),
     description: z.string().min(1).max(1024),
+    icon: z.string().optional(),
     parameters: FunctionParametersSchema,
 });
 export function validateToolDefinitions(tools) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looopy-ai/core",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "RxJS-based AI agent framework",
   "keywords": [
     "agent",