@looopy-ai/core 1.0.4 → 1.1.1

package/dist/core/agent.d.ts

@@ -26,8 +26,6 @@ export declare class Agent {
     private readonly config;
     private _state;
     private logger;
-    private sigtermHandler?;
-    private sigintHandler?;
     private shuttingDown;
     private shutdownComplete;
     constructor(config: AgentConfig);
@@ -48,6 +46,4 @@ export declare class Agent {
     private loadPersistedState;
     private loadMessages;
     private checkAndCompact;
-    private registerSignalHandlers;
-    private removeSignalHandlers;
 }

package/dist/core/agent.js

@@ -2,15 +2,12 @@ import { catchError, concat, Observable, of, tap } from 'rxjs';
 import { createTaskStatusEvent } from '../events';
 import { addMessagesCompactedEvent, addMessagesLoadedEvent, completeAgentInitializeSpan, completeAgentTurnSpan, failAgentInitializeSpan, failAgentTurnSpan, setResumeAttributes, setTurnCountAttribute, startAgentInitializeSpan, startAgentTurnSpan, } from '../observability/spans';
 import { serializeError } from '../utils/error';
-import { registerSignalListener, unregisterSignalListener } from '../utils/process-signals';
 import { getLogger } from './logger';
 import { runLoop } from './loop';
 export class Agent {
     config;
     _state;
     logger;
-    sigtermHandler;
-    sigintHandler;
     shuttingDown = false;
     shutdownComplete = false;
     constructor(config) {
@@ -31,7 +28,6 @@ export class Agent {
         };
         this.logger.debug('Agent created');
         this.persistStateSafely();
-        this.registerSignalHandlers();
     }
     get state() {
         return { ...this._state };
@@ -286,7 +282,6 @@ export class Agent {
             this._state.status = 'shutdown';
             this._state.lastActivity = new Date();
             await this.persistState();
-            this.removeSignalHandlers();
             this.shutdownComplete = true;
             this.config.logger.info('Agent shutdown complete');
         }
@@ -371,46 +366,4 @@ export class Agent {
             });
         }
     }
-    registerSignalHandlers() {
-        if (typeof process === 'undefined') {
-            return;
-        }
-        if (this.sigtermHandler || typeof process === 'undefined') {
-            return;
-        }
-        if (!this.sigtermHandler) {
-            this.sigtermHandler = async () => {
-                this.logger.info('Received SIGTERM signal. Initiating graceful shutdown.');
-                try {
-                    await this.shutdown();
-                }
-                catch (error) {
-                    this.logger.error({ error }, 'Failed to shutdown agent after SIGTERM signal');
-                }
-            };
-            registerSignalListener('SIGTERM', this.sigtermHandler);
-        }
-        if (!this.sigintHandler) {
-            const sigintHandler = async () => {
-                this.logger.info('Received SIGINT signal. Initiating graceful shutdown.');
-                try {
-                    await this.shutdown();
-                }
-                catch (error) {
-                    this.logger.error({ error }, 'Failed to shutdown agent after SIGINT signal');
-                }
-            };
-            registerSignalListener('SIGINT', sigintHandler);
-        }
-    }
-    removeSignalHandlers() {
-        if (this.sigtermHandler) {
-            unregisterSignalListener('SIGTERM', this.sigtermHandler);
-            this.sigtermHandler = undefined;
-        }
-        if (this.sigintHandler) {
-            unregisterSignalListener('SIGINT', this.sigintHandler);
-            this.sigintHandler = undefined;
-        }
-    }
 }

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/index.d.ts

@@ -6,3 +6,4 @@ export * from './server';
 export * from './stores';
 export * from './tools';
 export * from './types';
+export * from './utils';

package/dist/index.js

@@ -6,3 +6,4 @@ export * from './server';
 export * from './stores';
 export * from './tools';
 export * from './types';
+export * from './utils';

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/server/index.d.ts

@@ -1,3 +1,4 @@
 export { type BufferedEvent, EventBuffer, type EventBufferConfig, } from './event-buffer';
 export { type EventFilter, EventRouter, type Subscriber, type SubscriptionConfig, } from './event-router';
+export * from './shutdown';
 export { SSEConnection, type SSEConnectionConfig, type SSEResponse, SSEServer, type SSEServerConfig, } from './sse';

package/dist/server/index.js

@@ -1,3 +1,4 @@
 export { EventBuffer, } from './event-buffer';
 export { EventRouter, } from './event-router';
+export * from './shutdown';
 export { SSEConnection, SSEServer, } from './sse';

package/dist/server/shutdown.d.ts

@@ -0,0 +1,7 @@
+export declare class ShutdownManager {
+    private watchers;
+    constructor();
+    registerWatcher(handleShutdown: () => Promise<void>, order?: number): void;
+    initiateShutdown(): Promise<void>;
+    private signalHandler;
+}

package/dist/server/shutdown.js

@@ -0,0 +1,21 @@
+import { getLogger } from '../core';
+export class ShutdownManager {
+    watchers = [];
+    constructor() {
+        process.on('SIGINT', this.signalHandler.bind(this));
+        process.on('SIGTERM', this.signalHandler.bind(this));
+    }
+    registerWatcher(handleShutdown, order = 100) {
+        this.watchers.push({ handleShutdown, order });
+        this.watchers.sort((a, b) => a.order - b.order);
+    }
+    async initiateShutdown() {
+        for (const watcher of this.watchers) {
+            await watcher.handleShutdown();
+        }
+    }
+    signalHandler(signal) {
+        getLogger({ component: 'shutdown-manager' }).info({ signal, watchers: this.watchers.length }, 'Received shutdown signal');
+        this.initiateShutdown();
+    }
+}

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

@@ -5,6 +5,7 @@ export type ToolHandler<TParams> = (params: TParams, context: ExecutionContext)
 export interface LocalToolDefinition<TSchema extends z.ZodObject> {
     name: string;
     description: string;
+    icon?: string;
     schema: TSchema;
     handler: ToolHandler<z.infer<TSchema>>;
 }

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/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './error';

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from './error';

package/package.json

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

package/dist/utils/process-signals.d.ts

@@ -1,3 +0,0 @@
-export type SignalListener = () => void | Promise<void>;
-export declare function registerSignalListener(signal: NodeJS.Signals, listener: SignalListener): void;
-export declare function unregisterSignalListener(signal: NodeJS.Signals, listener: SignalListener): void;

package/dist/utils/process-signals.js

@@ -1,67 +0,0 @@
-import { getLogger } from '../core/logger';
-import { serializeError } from './error';
-const listeners = new Map();
-const processHandlers = new Map();
-const signalLogger = getLogger({ component: 'process-signal-coordinator' });
-function isProcessAvailable() {
-    return typeof process !== 'undefined' && typeof process.on === 'function';
-}
-export function registerSignalListener(signal, listener) {
-    if (!isProcessAvailable()) {
-        return;
-    }
-    const signalListeners = listeners.get(signal) ?? new Set();
-    signalListeners.add(listener);
-    listeners.set(signal, signalListeners);
-    ensureProcessHandler(signal);
-}
-export function unregisterSignalListener(signal, listener) {
-    if (!isProcessAvailable()) {
-        return;
-    }
-    const signalListeners = listeners.get(signal);
-    if (!signalListeners) {
-        return;
-    }
-    signalListeners.delete(listener);
-    if (signalListeners.size === 0) {
-        listeners.delete(signal);
-        removeProcessHandler(signal);
-    }
-}
-function ensureProcessHandler(signal) {
-    if (processHandlers.has(signal)) {
-        return;
-    }
-    const handler = () => {
-        const signalListeners = listeners.get(signal);
-        if (!signalListeners || signalListeners.size === 0) {
-            return;
-        }
-        signalLogger.info({ signal, listenerCount: signalListeners.size }, 'Received process signal; notifying registered listeners');
-        const listenersSnapshot = Array.from(signalListeners);
-        void Promise.allSettled(listenersSnapshot.map(async (listener) => {
-            try {
-                await listener();
-            }
-            catch (error) {
-                signalLogger.error({ signal, error: serializeError(error) }, 'Signal listener failed');
-            }
-        }));
-    };
-    process.on(signal, handler);
-    processHandlers.set(signal, handler);
-}
-function removeProcessHandler(signal) {
-    const handler = processHandlers.get(signal);
-    if (!handler) {
-        return;
-    }
-    if (typeof process.off === 'function') {
-        process.off(signal, handler);
-    }
-    else if (typeof process.removeListener === 'function') {
-        process.removeListener(signal, handler);
-    }
-    processHandlers.delete(signal);
-}