@looopy-ai/core 1.1.0 → 1.1.2

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

@@ -1,5 +1,4 @@
-import { type Observable } from 'rxjs';
 import type { AnyEvent } from '../types/event';
 import type { Message } from '../types/message';
 import type { LoopConfig, TurnContext } from './types';
-export declare const runLoop: (context: TurnContext, config: LoopConfig, history: Message[]) => Observable<AnyEvent>;
+export declare const runLoop: (context: TurnContext, config: LoopConfig, history: Message[]) => import("rxjs").Observable<AnyEvent>;

package/dist/core/loop.js

@@ -1,6 +1,7 @@
-import { concat, EMPTY, expand, map, mergeMap, of, reduce, share, shareReplay, } from 'rxjs';
+import { concat, EMPTY, mergeMap, of, reduce, shareReplay } from 'rxjs';
 import { createTaskCompleteEvent, createTaskCreatedEvent, createTaskStatusEvent } from '../events';
 import { startAgentLoopSpan } from '../observability/spans';
+import { recursiveMerge } from '../utils/recursive-merge';
 import { runIteration } from './iteration';
 export const runLoop = (context, config, history) => {
     const logger = context.logger.child({ component: 'loop' });
@@ -49,34 +50,6 @@ export const runLoop = (context, config, history) => {
     }));
     return concat(of(taskEvent, workingEvent), merged$, finalSummary$).pipe(tapFinish);
 };
-function recursiveMerge(initial, eventsFor, next, isStop) {
-    const seed = {
-        state: initial,
-        iteration: 0,
-        events$: eventsFor({ ...initial, iteration: 0 }).pipe(shareReplay()),
-    };
-    const iterations$ = of(seed).pipe(expand(({ state, iteration, events$ }) => events$.pipe(reduce((acc, e) => {
-        acc.events.push(e);
-        if (isStop(e))
-            acc.sawStop = true;
-        return acc;
-    }, { events: [], sawStop: false }), mergeMap(({ events, sawStop }) => {
-        if (sawStop)
-            return EMPTY;
-        return of(next(state, { iteration, events })).pipe(map((nextState) => {
-            const nextIter = iteration + 1;
-            return {
-                state: nextState,
-                iteration: nextIter,
-                events$: eventsFor({
-                    ...nextState,
-                    iteration: nextIter,
-                }).pipe(share()),
-            };
-        }));
-    }))));
-    return iterations$.pipe(mergeMap(({ events$ }) => events$));
-}
 const eventsToMessages = (events) => {
     const messages = [];
     for (const event of events) {
@@ -88,22 +61,13 @@ const eventsToMessages = (events) => {
                         content: event.content,
                     });
                 }
-                break;
-            case 'tool-call':
-                messages.push({
-                    role: 'assistant',
-                    content: '',
-                    toolCalls: [
-                        {
-                            id: event.toolCallId,
-                            type: 'function',
-                            function: {
-                                name: event.toolName,
-                                arguments: event.arguments,
-                            },
-                        },
-                    ],
-                });
+                if (event.finishReason === 'tool_calls' && (event.toolCalls?.length ?? 0) > 0) {
+                    messages.push({
+                        role: 'assistant',
+                        content: '',
+                        toolCalls: event.toolCalls,
+                    });
+                }
                 break;
             case 'tool-complete':
                 messages.push({

package/dist/core/tools.js

@@ -43,7 +43,9 @@ export const runToolCall = (context, toolCall) => {
                 logger.trace({
                     success: result.success,
                 }, 'Tool execution complete');
-                return createToolCompleteEvent(context, toolCall, result.result);
+                return result.success
+                    ? createToolCompleteEvent(context, toolCall, result.result)
+                    : createToolErrorEvent(context, toolCall, result.error || 'Unknown error');
             }
             catch (error) {
                 const err = error instanceof Error ? error : new Error(String(error));

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

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

package/dist/utils/index.js

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

package/dist/utils/recursive-merge.d.ts

@@ -0,0 +1,7 @@
+import { type Observable } from 'rxjs';
+export declare function recursiveMerge<S, E>(initial: S, eventsFor: (state: S & {
+    iteration: number;
+}) => Observable<E>, next: (state: S, info: {
+    iteration: number;
+    events: E[];
+}) => S, isStop: (e: E) => boolean): Observable<E>;

package/dist/utils/recursive-merge.js

@@ -0,0 +1,29 @@
+import { EMPTY, expand, map, mergeMap, of, reduce, share, shareReplay, } from 'rxjs';
+export function recursiveMerge(initial, eventsFor, next, isStop) {
+    const seed = {
+        state: initial,
+        iteration: 0,
+        events$: eventsFor({ ...initial, iteration: 0 }).pipe(shareReplay()),
+    };
+    const iterations$ = of(seed).pipe(expand(({ state, iteration, events$ }) => events$.pipe(reduce((acc, e) => {
+        acc.events.push(e);
+        if (isStop(e))
+            acc.sawStop = true;
+        return acc;
+    }, { events: [], sawStop: false }), mergeMap(({ events, sawStop }) => {
+        if (sawStop)
+            return EMPTY;
+        return of(next(state, { iteration, events })).pipe(map((nextState) => {
+            const nextIter = iteration + 1;
+            return {
+                state: nextState,
+                iteration: nextIter,
+                events$: eventsFor({
+                    ...nextState,
+                    iteration: nextIter,
+                }).pipe(share()),
+            };
+        }));
+    }))));
+    return iterations$.pipe(mergeMap(({ events$ }) => events$));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looopy-ai/core",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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);
-}