@looopy-ai/core 1.2.0 → 2.0.0

package/dist/core/agent.d.ts

@@ -3,7 +3,7 @@ import type { SkillRegistry } from '../skills';
 import type { MessageStore } from '../stores/messages/interfaces';
 import type { AgentState, AgentStore } from '../types/agent';
 import type { AuthContext } from '../types/context';
-import type { AnyEvent } from '../types/event';
+import type { ContextAnyEvent } from '../types/event';
 import type { LLMProvider } from '../types/llm';
 import type { Message } from '../types/message';
 import type { ToolProvider } from '../types/tools';
@@ -39,7 +39,7 @@ export declare class Agent {
     startTurn(userMessage: string | null, options?: {
         authContext?: AuthContext;
         taskId?: string;
-    }): Promise<Observable<AnyEvent>>;
+    }): Promise<Observable<ContextAnyEvent>>;
     private executeInternal;
     shutdown(): Promise<void>;
     getMessages(options?: GetMessagesOptions): Promise<Message[]>;

package/dist/core/iteration.d.ts

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

package/dist/core/iteration.js

@@ -10,11 +10,15 @@ export const runIteration = (context, config, history) => {
     const { traceContext: iterationContext, tapFinish: finishIterationSpan } = startLoopIterationSpan({ ...context, logger }, config.iterationNumber);
     const llmEvents$ = defer(async () => {
         const systemPrompt = await getSystemPrompt(context.systemPrompt);
-        const messages = await prepareMessages(systemPrompt, context.skillPrompts, history);
+        const messages = await prepareMessages(systemPrompt, context.skillRegistry, history);
         const tools = await prepareTools(context.toolProviders);
+        logger.debug({
+            messages: messages.length,
+            tools: tools.map((t) => t.name).join(', '),
+        }, 'Prepared messages and tools for LLM call');
         return { messages, tools, systemPrompt };
     }).pipe(mergeMap(({ messages, tools, systemPrompt }) => {
-        const { tapFinish: finishLLMCallSpan } = startLLMCallSpan({ ...context, parentContext: iterationContext }, systemPrompt, messages);
+        const { tapFinish: finishLLMCallSpan } = startLLMCallSpan({ ...context, parentContext: iterationContext }, systemPrompt, messages, tools);
         return config.llmProvider
             .call({
             messages,
@@ -22,11 +26,11 @@ export const runIteration = (context, config, history) => {
             stream: true,
             sessionId: context.taskId,
         })
-            .pipe(map((event) => ({
+            .pipe(finishLLMCallSpan, map((event) => ({
             contextId: context.contextId,
             taskId: context.taskId,
             ...event,
-        })), finishLLMCallSpan);
+        })));
     }), shareReplay({ refCount: true }));
     const toolEvents$ = llmEvents$.pipe(filter((event) => event.kind === 'tool-call'), mergeMap((event) => runToolCall({
         ...context,
@@ -35,22 +39,23 @@ export const runIteration = (context, config, history) => {
     }, event)));
     return concat(llmEvents$.pipe(filter((event) => event.kind !== 'tool-call')), toolEvents$).pipe(finishIterationSpan);
 };
-const prepareMessages = async (systemPrompt, skillPrompts, history) => {
+const prepareMessages = async (systemPrompt, skillRegistry, history) => {
     const messages = [];
     if (systemPrompt) {
         messages.push({
             role: 'system',
             content: systemPrompt.prompt,
-            name: systemPrompt.name || 'system-prompt',
         });
     }
-    if (skillPrompts) {
-        for (const [name, content] of Object.entries(skillPrompts)) {
-            messages.push({
+    if (skillRegistry) {
+        const skills = skillRegistry.list();
+        if (skills.length > 0) {
+            const skillList = skills.map((s) => `- **${s.name}**: ${s.description}`).join('\n');
+            const skillMessage = {
                 role: 'system',
-                content,
-                name,
-            });
+                content: `You can learn new skills by using the 'learn_skill' tool. Available skills:\n\n${skillList}`,
+            };
+            messages.push(skillMessage);
         }
     }
     return messages.concat(history);

package/dist/core/loop.d.ts

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

package/dist/core/loop.js

@@ -27,20 +27,8 @@ export const runLoop = (context, config, history) => {
         status: 'working',
         metadata: {},
     });
-    const initialMessages = [...history];
-    if (context.skillRegistry) {
-        const skills = context.skillRegistry.list();
-        if (skills.length > 0) {
-            const skillList = skills.map((s) => `- **${s.name}**: ${s.description}`).join('\n');
-            const skillMessage = {
-                role: 'system',
-                content: `You can learn new skills by using the 'learn_skill' tool. Available skills:\n\n${skillList}`,
-            };
-            initialMessages.unshift(skillMessage);
-        }
-    }
     const merged$ = recursiveMerge({
-        messages: initialMessages,
+        messages: history,
         completed: false,
         iteration: 0,
     }, (state) => runIteration({ ...context, parentContext: loopContext }, {

package/dist/core/tools.d.ts

@@ -1,4 +1,4 @@
 import { type Observable } from 'rxjs';
-import type { InternalToolMessageEvent, ToolCallEvent, ToolExecutionEvent } from '../types/event';
+import type { ContextAnyEvent, ContextEvent, ToolCallEvent } from '../types/event';
 import type { IterationContext } from './types';
-export declare const runToolCall: (context: IterationContext, toolCall: ToolCallEvent) => Observable<ToolExecutionEvent | InternalToolMessageEvent>;
+export declare const runToolCall: (context: IterationContext, toolCall: ContextEvent<ToolCallEvent>) => Observable<ContextAnyEvent>;

package/dist/core/tools.js

@@ -1,5 +1,6 @@
-import { catchError, concat, defer, EMPTY, from, mergeMap, of, shareReplay, } from 'rxjs';
+import { catchError, concat, defer, mergeMap, of, tap } from 'rxjs';
 import { startToolExecuteSpan } from '../observability/spans';
+import { toolErrorEvent } from '../tools/tool-result-events';
 export const runToolCall = (context, toolCall) => {
     const logger = context.logger.child({
         component: 'tool-call',
@@ -28,66 +29,43 @@ export const runToolCall = (context, toolCall) => {
             arguments: toolCall.arguments,
             timestamp: new Date().toISOString(),
         };
+        const toolCallInput = {
+            id: toolCall.toolCallId,
+            type: 'function',
+            function: {
+                name: toolCall.toolName,
+                arguments: toolCall.arguments,
+            },
+        };
         const { tapFinish } = startToolExecuteSpan(context, toolCall);
-        const toolResults$ = defer(async () => {
-            logger.trace({ providerName: provider.name }, 'Executing tool');
-            return await provider.execute({
-                id: toolCall.toolCallId,
-                type: 'function',
-                function: {
-                    name: toolCall.toolName,
-                    arguments: toolCall.arguments,
-                },
-            }, context);
-        }).pipe(tapFinish, shareReplay({ refCount: true }));
-        const toolCompleteEvents$ = toolResults$.pipe(mergeMap((result) => {
-            if (result.success) {
-                logger.trace({ providerName: provider.name, success: true }, 'Tool execution complete');
-                return of(createToolCompleteEvent(context, toolCall, result.result));
+        const execution$ = defer(() => {
+            try {
+                logger.trace({ providerName: provider.name }, 'Executing tool');
+                return provider.execute(toolCallInput, context).pipe(tap((event) => {
+                    if (event.kind !== 'tool-complete') {
+                        return;
+                    }
+                    logger.trace({ providerName: provider.name, success: event.success }, 'Tool execution complete');
+                }), tapFinish, catchError((error) => {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    logger.error({
+                        providerName: provider.name,
+                        error: err.message,
+                        stack: err.stack,
+                    }, 'Tool execution error');
+                    return of(toolErrorEvent(context, toolCallInput, err.message));
+                }));
             }
-            else {
-                logger.trace({ providerName: provider.name, success: false }, 'Tool execution failed');
-                return of(createToolErrorEvent(context, toolCall, result.error || 'Unknown error'));
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                logger.error({
+                    providerName: provider.name,
+                    error: err.message,
+                    stack: err.stack,
+                }, 'Tool execution error');
+                return of(toolErrorEvent(context, toolCallInput, err.message));
             }
-        }), catchError((error) => {
-            const err = error instanceof Error ? error : new Error(String(error));
-            logger.error({
-                providerName: provider.name,
-                error: err.message,
-                stack: err.stack,
-            }, 'Tool execution error');
-            return of(createToolErrorEvent(context, toolCall, err.message));
-        }));
-        const toolMessageEvents$ = toolResults$.pipe(mergeMap((result) => result.success && result.messages
-            ? from(result.messages?.map((message) => ({
-                kind: 'internal:tool-message',
-                message,
-                timestamp: new Date().toISOString(),
-            })))
-            : EMPTY), catchError(() => {
-            return EMPTY;
-        }));
-        return concat(of(toolStartEvent), toolCompleteEvents$, toolMessageEvents$);
+        });
+        return concat(of(toolStartEvent), execution$);
     }).pipe(mergeMap((obs) => obs));
 };
-const createToolCompleteEvent = (context, toolCall, result) => ({
-    kind: 'tool-complete',
-    contextId: context.contextId,
-    taskId: context.taskId,
-    toolCallId: toolCall.toolCallId,
-    toolName: toolCall.toolName,
-    success: true,
-    result: result,
-    timestamp: new Date().toISOString(),
-});
-const createToolErrorEvent = (context, toolCall, errorMessage) => ({
-    kind: 'tool-complete',
-    contextId: context.contextId,
-    taskId: context.taskId,
-    toolCallId: toolCall.toolCallId,
-    toolName: toolCall.toolName,
-    success: false,
-    result: null,
-    error: errorMessage,
-    timestamp: new Date().toISOString(),
-});

package/dist/core/types.d.ts

@@ -13,7 +13,6 @@ export type AgentContext = {
     logger: pino.Logger;
     systemPrompt?: SystemPromptProp;
     skillRegistry?: SkillRegistry;
-    skillPrompts?: Record<string, string>;
     metadata?: Record<string, unknown>;
 };
 export type TurnContext = AgentContext & {

package/dist/events/utils.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEvent, AuthCompletedEvent, AuthRequiredEvent, AuthType, ContentCompleteEvent, ContentDeltaEvent, DatasetWriteEvent, DataWriteEvent, FileWriteEvent, FinishReason, InputProvider, InputReceivedEvent, InputRequiredEvent, InputType, InternalCheckpointEvent, InternalLLMCallEvent, InternalThoughtProcessEvent, JSONSchema, SubtaskCreatedEvent, TaskCompleteEvent, TaskCreatedEvent, TaskInitiator, TaskStatus, TaskStatusEvent, ThoughtStreamEvent, ThoughtType, ThoughtVerbosity, ToolCompleteEvent, ToolProgressEvent, ToolStartEvent } from '../types/event';
+import type { AuthCompletedEvent, AuthRequiredEvent, AuthType, ContentCompleteEvent, ContentDeltaEvent, ContextAnyEvent, ContextEvent, DatasetWriteEvent, DataWriteEvent, FileWriteEvent, FinishReason, InputProvider, InputReceivedEvent, InputRequiredEvent, InputType, InternalCheckpointEvent, InternalLLMCallEvent, InternalThoughtProcessEvent, JSONSchema, SubtaskCreatedEvent, TaskCompleteEvent, TaskCreatedEvent, TaskInitiator, TaskStatus, TaskStatusEvent, ThoughtStreamEvent, ThoughtType, ThoughtVerbosity, ToolCompleteEvent, ToolProgressEvent, ToolStartEvent } from '../types/event';
 export declare function generateEventId(): string;
 export interface CreateTaskCreatedEventOptions {
     contextId: string;
@@ -11,7 +11,7 @@ export interface CreateTaskCreatedEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createTaskCreatedEvent(options: CreateTaskCreatedEventOptions): TaskCreatedEvent;
+export declare function createTaskCreatedEvent(options: CreateTaskCreatedEventOptions): ContextEvent<TaskCreatedEvent>;
 export interface CreateTaskStatusEventOptions {
     contextId: string;
     taskId: string;
@@ -23,7 +23,7 @@ export interface CreateTaskStatusEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createTaskStatusEvent(options: CreateTaskStatusEventOptions): TaskStatusEvent;
+export declare function createTaskStatusEvent(options: CreateTaskStatusEventOptions): ContextEvent<TaskStatusEvent>;
 export interface CreateTaskCompleteEventOptions {
     contextId: string;
     taskId: string;
@@ -36,21 +36,21 @@ export interface CreateTaskCompleteEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createTaskCompleteEvent(options: CreateTaskCompleteEventOptions): TaskCompleteEvent;
+export declare function createTaskCompleteEvent(options: CreateTaskCompleteEventOptions): ContextEvent<TaskCompleteEvent>;
 export interface CreateContentDeltaEventOptions {
     contextId: string;
     taskId: string;
     delta: string;
     index: number;
 }
-export declare function createContentDeltaEvent(options: CreateContentDeltaEventOptions): ContentDeltaEvent;
+export declare function createContentDeltaEvent(options: CreateContentDeltaEventOptions): ContextEvent<ContentDeltaEvent>;
 export interface CreateContentCompleteEventOptions {
     contextId: string;
     taskId: string;
     content: string;
     finishReason?: FinishReason;
 }
-export declare function createContentCompleteEvent(options: CreateContentCompleteEventOptions): ContentCompleteEvent;
+export declare function createContentCompleteEvent(options: CreateContentCompleteEventOptions): ContextEvent<ContentCompleteEvent>;
 export interface CreateToolStartEventOptions {
     contextId: string;
     taskId: string;
@@ -63,7 +63,7 @@ export interface CreateToolStartEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createToolStartEvent(options: CreateToolStartEventOptions): ToolStartEvent;
+export declare function createToolStartEvent(options: CreateToolStartEventOptions): ContextEvent<ToolStartEvent>;
 export interface CreateToolProgressEventOptions {
     contextId: string;
     taskId: string;
@@ -77,7 +77,7 @@ export interface CreateToolProgressEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createToolProgressEvent(options: CreateToolProgressEventOptions): ToolProgressEvent;
+export declare function createToolProgressEvent(options: CreateToolProgressEventOptions): ContextEvent<ToolProgressEvent>;
 export interface CreateToolCompleteEventOptions {
     contextId: string;
     taskId: string;
@@ -93,7 +93,7 @@ export interface CreateToolCompleteEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createToolCompleteEvent(options: CreateToolCompleteEventOptions): ToolCompleteEvent;
+export declare function createToolCompleteEvent(options: CreateToolCompleteEventOptions): ContextEvent<ToolCompleteEvent>;
 export interface CreateInputRequiredEventOptions {
     contextId: string;
     taskId: string;
@@ -105,7 +105,7 @@ export interface CreateInputRequiredEventOptions {
     options?: unknown[];
     metadata?: Record<string, unknown>;
 }
-export declare function createInputRequiredEvent(options: CreateInputRequiredEventOptions): InputRequiredEvent;
+export declare function createInputRequiredEvent(options: CreateInputRequiredEventOptions): ContextEvent<InputRequiredEvent>;
 export interface CreateInputReceivedEventOptions {
     contextId: string;
     taskId: string;
@@ -118,7 +118,7 @@ export interface CreateInputReceivedEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createInputReceivedEvent(options: CreateInputReceivedEventOptions): InputReceivedEvent;
+export declare function createInputReceivedEvent(options: CreateInputReceivedEventOptions): ContextEvent<InputReceivedEvent>;
 export interface CreateAuthRequiredEventOptions {
     contextId: string;
     taskId: string;
@@ -133,7 +133,7 @@ export interface CreateAuthRequiredEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createAuthRequiredEvent(options: CreateAuthRequiredEventOptions): AuthRequiredEvent;
+export declare function createAuthRequiredEvent(options: CreateAuthRequiredEventOptions): ContextEvent<AuthRequiredEvent>;
 export interface CreateAuthCompletedEventOptions {
     contextId: string;
     taskId: string;
@@ -144,7 +144,7 @@ export interface CreateAuthCompletedEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createAuthCompletedEvent(options: CreateAuthCompletedEventOptions): AuthCompletedEvent;
+export declare function createAuthCompletedEvent(options: CreateAuthCompletedEventOptions): ContextEvent<AuthCompletedEvent>;
 export interface CreateFileWriteEventOptions {
     contextId: string;
     taskId: string;
@@ -162,7 +162,7 @@ export interface CreateFileWriteEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createFileWriteEvent(options: CreateFileWriteEventOptions): FileWriteEvent;
+export declare function createFileWriteEvent(options: CreateFileWriteEventOptions): ContextEvent<FileWriteEvent>;
 export interface CreateDataWriteEventOptions {
     contextId: string;
     taskId: string;
@@ -176,7 +176,7 @@ export interface CreateDataWriteEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createDataWriteEvent(options: CreateDataWriteEventOptions): DataWriteEvent;
+export declare function createDataWriteEvent(options: CreateDataWriteEventOptions): ContextEvent<DataWriteEvent>;
 export interface CreateDatasetWriteEventOptions {
     contextId: string;
     taskId: string;
@@ -194,7 +194,7 @@ export interface CreateDatasetWriteEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createDatasetWriteEvent(options: CreateDatasetWriteEventOptions): DatasetWriteEvent;
+export declare function createDatasetWriteEvent(options: CreateDatasetWriteEventOptions): ContextEvent<DatasetWriteEvent>;
 export interface CreateSubtaskCreatedEventOptions {
     contextId: string;
     taskId: string;
@@ -202,7 +202,7 @@ export interface CreateSubtaskCreatedEventOptions {
     agentId?: string;
     prompt: string;
 }
-export declare function createSubtaskCreatedEvent(options: CreateSubtaskCreatedEventOptions): SubtaskCreatedEvent;
+export declare function createSubtaskCreatedEvent(options: CreateSubtaskCreatedEventOptions): ContextEvent<SubtaskCreatedEvent>;
 export interface CreateThoughtStreamEventOptions {
     contextId: string;
     taskId: string;
@@ -218,7 +218,7 @@ export interface CreateThoughtStreamEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createThoughtStreamEvent(options: CreateThoughtStreamEventOptions): ThoughtStreamEvent;
+export declare function createThoughtStreamEvent(options: CreateThoughtStreamEventOptions): ContextEvent<ThoughtStreamEvent>;
 export interface CreateInternalThoughtProcessEventOptions {
     contextId: string;
     taskId: string;
@@ -227,7 +227,7 @@ export interface CreateInternalThoughtProcessEventOptions {
     reasoning: string;
     state: Record<string, unknown>;
 }
-export declare function createInternalThoughtProcessEvent(options: CreateInternalThoughtProcessEventOptions): InternalThoughtProcessEvent;
+export declare function createInternalThoughtProcessEvent(options: CreateInternalThoughtProcessEventOptions): ContextEvent<InternalThoughtProcessEvent>;
 export interface CreateInternalLLMCallEventOptions {
     contextId: string;
     taskId: string;
@@ -235,16 +235,16 @@ export interface CreateInternalLLMCallEventOptions {
     messageCount: number;
     toolCount: number;
 }
-export declare function createInternalLLMCallEvent(options: CreateInternalLLMCallEventOptions): InternalLLMCallEvent;
+export declare function createInternalLLMCallEvent(options: CreateInternalLLMCallEventOptions): ContextEvent<InternalLLMCallEvent>;
 export interface CreateInternalCheckpointEventOptions {
     contextId: string;
     taskId: string;
     iteration: number;
 }
-export declare function createInternalCheckpointEvent(options: CreateInternalCheckpointEventOptions): InternalCheckpointEvent;
-export declare function filterExternalEvents(events: AnyEvent[]): AnyEvent[];
-export declare function filterByTaskId(events: AnyEvent[], taskId: string): AnyEvent[];
-export declare function filterByContextId(events: AnyEvent[], contextId: string): AnyEvent[];
-export declare function filterByKind<K extends AnyEvent['kind']>(events: AnyEvent[], kind: K): Extract<AnyEvent, {
+export declare function createInternalCheckpointEvent(options: CreateInternalCheckpointEventOptions): ContextEvent<InternalCheckpointEvent>;
+export declare function filterExternalEvents(events: ContextAnyEvent[]): ContextAnyEvent[];
+export declare function filterByTaskId(events: ContextAnyEvent[], taskId: string): ContextAnyEvent[];
+export declare function filterByContextId(events: ContextAnyEvent[], contextId: string): ContextAnyEvent[];
+export declare function filterByKind<K extends ContextAnyEvent['kind']>(events: ContextAnyEvent[], kind: K): Extract<ContextAnyEvent, {
     kind: K;
 }>[];

package/dist/observability/spans/agent-turn.d.ts

@@ -1,5 +1,5 @@
 import { type Context, type Span } from '@opentelemetry/api';
-import type { AnyEvent } from '../../types/event';
+import type { ContextAnyEvent } from '../../types/event';
 export interface AgentTurnSpanParams {
     agentId: string;
     taskId: string;
@@ -10,7 +10,7 @@ export interface AgentTurnSpanParams {
 export declare const startAgentTurnSpan: (params: AgentTurnSpanParams) => {
     span: Span;
     traceContext: Context;
-    tapFinish: import("rxjs").MonoTypeOperatorFunction<AnyEvent>;
+    tapFinish: import("rxjs").MonoTypeOperatorFunction<ContextAnyEvent>;
 };
 export declare function addMessagesLoadedEvent(span: Span, count: number): void;
 export declare function addMessagesCompactedEvent(span: Span): void;

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

@@ -1,5 +1,5 @@
 import type { LoopContext } from '../../core/types';
-import type { AnyEvent } from '../../types/event';
+import type { ContextAnyEvent } from '../../types/event';
 export interface LoopIterationSpanParams {
     agentId: string;
     contextId: string;
@@ -10,5 +10,5 @@ export interface LoopIterationSpanParams {
 export declare const startLoopIterationSpan: (context: LoopContext, iteration: number) => {
     span: import("@opentelemetry/api").Span;
     traceContext: import("@opentelemetry/api").Context;
-    tapFinish: import("rxjs").MonoTypeOperatorFunction<AnyEvent>;
+    tapFinish: import("rxjs").MonoTypeOperatorFunction<ContextAnyEvent>;
 };

package/dist/observability/spans/llm-call.d.ts

@@ -1,3 +1,4 @@
+import type { ToolDefinition } from '../..';
 import type { LoopContext } from '../../core/types';
 import type { AnyEvent } from '../../types/event';
 import type { Message } from '../../types/message';
@@ -8,7 +9,7 @@ export interface LLMCallSpanParams {
     messages: Message[];
     parentContext: import('@opentelemetry/api').Context;
 }
-export declare const startLLMCallSpan: (context: LoopContext, systemPrompt: SystemPrompt | undefined, messages: Message[]) => {
+export declare const startLLMCallSpan: (context: LoopContext, systemPrompt: SystemPrompt | undefined, messages: Message[], tools: ToolDefinition[]) => {
     span: import("@opentelemetry/api").Span;
     traceContext: import("@opentelemetry/api").Context;
     tapFinish: import("rxjs").MonoTypeOperatorFunction<AnyEvent>;

package/dist/observability/spans/llm-call.js

@@ -1,7 +1,7 @@
 import { SpanStatusCode, trace } from '@opentelemetry/api';
 import { tap } from 'rxjs/internal/operators/tap';
 import { SpanAttributes, SpanNames } from '../tracing';
-export const startLLMCallSpan = (context, systemPrompt, messages) => {
+export const startLLMCallSpan = (context, systemPrompt, messages, tools) => {
     const tracer = trace.getTracer('looopy');
     const span = tracer.startSpan(SpanNames.LLM_CALL, {
         attributes: {
@@ -11,6 +11,7 @@ export const startLLMCallSpan = (context, systemPrompt, messages) => {
             [SpanAttributes.LANGFUSE_OBSERVATION_TYPE]: 'generation',
             [SpanAttributes.LANGFUSE_PROMPT_NAME]: systemPrompt?.name,
             [SpanAttributes.LANGFUSE_PROMPT_VERSION]: systemPrompt?.version,
+            'tools.available': tools.map((t) => t.name),
         },
     }, context.parentContext);
     const traceContext = trace.setSpan(context.parentContext, span);

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

@@ -1,5 +1,5 @@
 import { type Context } from '@opentelemetry/api';
-import type { AnyEvent } from '../../types/event';
+import type { ContextAnyEvent } from '../../types/event';
 export interface AgentLoopSpanParams {
     agentId: string;
     taskId: string;
@@ -10,5 +10,5 @@ export interface AgentLoopSpanParams {
 export declare const startAgentLoopSpan: (params: AgentLoopSpanParams) => {
     span: import("@opentelemetry/api").Span;
     traceContext: Context;
-    tapFinish: import("rxjs").MonoTypeOperatorFunction<AnyEvent>;
+    tapFinish: import("rxjs").MonoTypeOperatorFunction<ContextAnyEvent>;
 };

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

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

package/dist/observability/spans/tool.js

@@ -1,5 +1,5 @@
 import { context as otelContext, SpanStatusCode, trace } from '@opentelemetry/api';
-import { tap } from 'rxjs/internal/operators/tap';
+import { tap } from 'rxjs';
 import { SpanAttributes, SpanNames } from '../tracing';
 export const startToolExecuteSpan = (context, toolStart) => {
     const tracer = trace.getTracer('looopy');
@@ -19,8 +19,22 @@ export const startToolExecuteSpan = (context, toolStart) => {
         traceContext,
         tapFinish: tap({
             next: (event) => {
-                span.setAttribute('output', JSON.stringify(event.result));
-                span.setStatus({ code: SpanStatusCode.OK });
+                if (!isToolCompleteEvent(event)) {
+                    return;
+                }
+                try {
+                    span.setAttribute('output', JSON.stringify(event.result));
+                }
+                catch {
+                }
+                if (event.success) {
+                    span.setStatus({ code: SpanStatusCode.OK });
+                    return;
+                }
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: event.error ?? 'Tool execution failed',
+                });
             },
             complete: () => span.end(),
             error: (err) => {
@@ -31,3 +45,6 @@ export const startToolExecuteSpan = (context, toolStart) => {
         }),
     };
 };
+const isToolCompleteEvent = (event) => {
+    return event.kind === 'tool-complete';
+};

package/dist/providers/litellm-provider.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import type { AnyEvent, LLMEvent } from '../types/event';
+import type { AnyEvent } from '../types/event';
 import type { LLMProvider } from '../types/llm';
 import type { Message } from '../types/message';
 import type { ToolDefinition } from '../types/tools';
@@ -23,7 +23,7 @@ export declare class LiteLLMProvider implements LLMProvider {
         messages: Message[];
         tools?: ToolDefinition[];
         sessionId?: string;
-    }): Observable<LLMEvent<AnyEvent>>;
+    }): Observable<AnyEvent>;
     private debugLogRawChunk;
     private debugLog;
     private createSSEStream;

package/dist/server/event-buffer.d.ts

@@ -1,7 +1,7 @@
-import type { AnyEvent } from '../types/event';
+import type { ContextAnyEvent } from '../types/event';
 export interface BufferedEvent {
     id: string;
-    event: AnyEvent;
+    event: ContextAnyEvent;
     timestamp: number;
 }
 export interface EventBufferConfig {
@@ -19,7 +19,7 @@ export declare class EventBuffer {
     private readonly autoCleanup;
     private readonly cleanupInterval;
     constructor(config?: EventBufferConfig);
-    add(contextId: string, event: AnyEvent): string;
+    add(contextId: string, event: ContextAnyEvent): string;
     getEventsSince(contextId: string, lastEventId: string): BufferedEvent[];
     getAll(contextId: string): BufferedEvent[];
     clear(contextId: string): void;

package/dist/server/event-router.d.ts

@@ -1,5 +1,5 @@
-import type { AnyEvent } from '../types/event';
-export type EventFilter = (event: AnyEvent) => boolean;
+import type { ContextAnyEvent } from '../types/event';
+export type EventFilter = (event: ContextAnyEvent) => boolean;
 export interface SubscriptionConfig {
     contextId: string;
     taskId?: string;
@@ -11,14 +11,14 @@ export interface SubscriptionConfig {
 export interface Subscriber {
     id: string;
     config: SubscriptionConfig;
-    send(event: AnyEvent, eventId: string): void;
+    send(event: ContextAnyEvent, eventId: string): void;
     close(): void;
 }
 export declare class EventRouter {
     private subscribers;
     subscribe(subscriber: Subscriber): void;
     unsubscribe(subscriberId: string, contextId: string): void;
-    route(contextId: string, event: AnyEvent, eventId: string): number;
+    route(contextId: string, event: ContextAnyEvent, eventId: string): number;
     private shouldSendToSubscriber;
     getSubscriberCount(contextId: string): number;
     getActiveContexts(): string[];