@looopy-ai/core 1.1.6 → 1.2.0

package/dist/core/agent.d.ts

@@ -1,4 +1,5 @@
 import { Observable } from 'rxjs';
+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';
@@ -17,6 +18,7 @@ export interface AgentConfig {
     autoCompact?: boolean;
     maxMessages?: number;
     systemPrompt?: SystemPromptProp;
+    skillRegistry?: SkillRegistry;
     logger?: import('pino').Logger;
 }
 export interface GetMessagesOptions {

package/dist/core/agent.js

@@ -1,4 +1,4 @@
-import { catchError, concat, Observable, of, tap } from 'rxjs';
+import { catchError, concat, filter, 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';
@@ -102,7 +102,7 @@ export class Agent {
             }
             if (this._state.status === 'error') {
                 const error = new Error(`Cannot execute turn: Agent is in error state: ${this._state.error?.message}`);
-                logger.error(error.message);
+                logger.error(this._state.error, 'Cannot execute turn due to agent error state');
                 failAgentTurnSpan(rootSpan, error);
                 return of(createTaskStatusEvent({
                     contextId: this.config.contextId,
@@ -170,6 +170,7 @@ export class Agent {
                         parentContext: turnContext,
                         systemPrompt: this.config.systemPrompt,
                         toolProviders: this.config.toolProviders,
+                        skillRegistry: this.config.skillRegistry,
                         logger: this.config.logger.child({ taskId, turnNumber }),
                         turnNumber,
                     }, {
@@ -210,10 +211,14 @@ export class Agent {
                                 await this.config.messageStore.append(this.config.contextId, [message]);
                                 break;
                             }
+                            case 'internal:tool-message':
+                                logger.debug({ message: event.message }, 'Saving internal tool message to message store');
+                                await this.config.messageStore.append(this.config.contextId, [event.message]);
+                                break;
                             default:
                                 break;
                         }
-                    }));
+                    }), filter((event) => event.kind !== 'internal:tool-message'));
                     turnEvents$.subscribe({
                         next: (event) => {
                             observer.next(event);

package/dist/core/iteration.js

@@ -27,7 +27,7 @@ export const runIteration = (context, config, history) => {
             taskId: context.taskId,
             ...event,
         })), finishLLMCallSpan);
-    }), shareReplay());
+    }), shareReplay({ refCount: true }));
     const toolEvents$ = llmEvents$.pipe(filter((event) => event.kind === 'tool-call'), mergeMap((event) => runToolCall({
         ...context,
         logger: context.logger.child({ iteration: config.iterationNumber }),

package/dist/core/loop.js

@@ -27,8 +27,20 @@ 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: history,
+        messages: initialMessages,
         completed: false,
         iteration: 0,
     }, (state) => runIteration({ ...context, parentContext: loopContext }, {
@@ -37,7 +49,7 @@ export const runLoop = (context, config, history) => {
     }, state.messages), (state, { events }) => ({
         ...state,
         messages: [...state.messages, ...eventsToMessages(events)],
-    }), (e) => e.kind === 'content-complete' && e.finishReason !== 'tool_calls').pipe(shareReplay());
+    }), (e) => e.kind === 'content-complete' && e.finishReason !== 'tool_calls').pipe(shareReplay({ refCount: true }));
     const finalSummary$ = merged$.pipe(reduce((last, e) => (e.kind === 'content-complete' ? e : last), null), mergeMap((last) => {
         if (!last)
             return EMPTY;
@@ -81,6 +93,9 @@ const eventsToMessages = (events) => {
                     toolCallId: event.toolCallId,
                 });
                 break;
+            case 'internal:tool-message':
+                messages.push(event.message);
+                break;
             default:
                 break;
         }

package/dist/core/tools.d.ts

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

package/dist/core/tools.js

@@ -1,4 +1,4 @@
-import { concat, defer, mergeMap, of } from 'rxjs';
+import { catchError, concat, defer, EMPTY, from, mergeMap, of, shareReplay, } from 'rxjs';
 import { startToolExecuteSpan } from '../observability/spans';
 export const runToolCall = (context, toolCall) => {
     const logger = context.logger.child({
@@ -29,34 +29,45 @@ export const runToolCall = (context, toolCall) => {
             timestamp: new Date().toISOString(),
         };
         const { tapFinish } = startToolExecuteSpan(context, toolCall);
-        const toolResultEvents$ = defer(async () => {
+        const toolResults$ = 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 result.success
-                    ? createToolCompleteEvent(context, toolCall, result.result)
-                    : createToolErrorEvent(context, toolCall, result.error || 'Unknown error');
+            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));
             }
-            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);
+            else {
+                logger.trace({ providerName: provider.name, success: false }, 'Tool execution failed');
+                return of(createToolErrorEvent(context, toolCall, result.error || 'Unknown error'));
             }
-        });
-        return concat(of(toolStartEvent), toolResultEvents$).pipe(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(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$);
     }).pipe(mergeMap((obs) => obs));
 };
 const createToolCompleteEvent = (context, toolCall, result) => ({

package/dist/core/types.d.ts

@@ -1,4 +1,5 @@
 import type pino from 'pino';
+import type { SkillRegistry } from '../skills';
 import type { AuthContext } from '../types/context';
 import type { LLMProvider } from '../types/llm';
 import type { ToolProvider } from '../types/tools';
@@ -11,6 +12,7 @@ export type AgentContext = {
     toolProviders: ToolProvider[];
     logger: pino.Logger;
     systemPrompt?: SystemPromptProp;
+    skillRegistry?: SkillRegistry;
     skillPrompts?: Record<string, string>;
     metadata?: Record<string, unknown>;
 };

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from './events';
 export * from './observability';
 export * from './providers';
 export * from './server';
+export * from './skills';
 export * from './stores';
 export * from './tools';
 export * from './types';

package/dist/index.js

@@ -3,6 +3,7 @@ export * from './events';
 export * from './observability';
 export * from './providers';
 export * from './server';
+export * from './skills';
 export * from './stores';
 export * from './tools';
 export * from './types';

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

@@ -1,6 +1,6 @@
 import type { IterationContext } from '../../core/types';
-import type { ToolCallEvent, ToolExecutionEvent } from '../../types/event';
-import type { ToolCall } from '../../types/tools';
+import type { ToolCallEvent } from '../../types/event';
+import type { ToolCall, ToolResult } 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<ToolExecutionEvent>;
+    tapFinish: import("rxjs").MonoTypeOperatorFunction<ToolResult>;
 };

package/dist/observability/spans/tool.js

@@ -19,19 +19,8 @@ export const startToolExecuteSpan = (context, toolStart) => {
         traceContext,
         tapFinish: tap({
             next: (event) => {
-                if (event.kind === 'tool-complete') {
-                    if (event.success) {
-                        span.setAttribute('output', JSON.stringify(event.result));
-                        span.setStatus({ code: SpanStatusCode.OK });
-                    }
-                    else {
-                        span.setAttribute('output', event.error || 'Tool execution failed');
-                        span.setStatus({ code: SpanStatusCode.ERROR });
-                        if (event.error) {
-                            span.setAttribute('error.message', event.error);
-                        }
-                    }
-                }
+                span.setAttribute('output', JSON.stringify(event.result));
+                span.setStatus({ code: SpanStatusCode.OK });
             },
             complete: () => span.end(),
             error: (err) => {

package/dist/providers/litellm-provider.js

@@ -40,7 +40,7 @@ export class LiteLLMProvider {
         const rawStream$ = this.createSSEStream(request);
         const stream$ = (this.config.debugLogPath
             ? rawStream$.pipe(tap((chunk) => this.debugLogRawChunk(chunk)))
-            : rawStream$).pipe(shareReplay());
+            : rawStream$).pipe(shareReplay({ refCount: true }));
         const choices$ = stream$.pipe(choices());
         const usage$ = stream$.pipe(usage());
         const { content, tags } = splitInlineXml(choices$.pipe(getContent()));
@@ -181,11 +181,11 @@ export class LiteLLMProvider {
                         role: msg.role,
                         content: msg.content,
                     };
-                    if (msg.name)
+                    if ('name' in msg && msg.name)
                         baseMsg.name = msg.name;
-                    if (msg.toolCallId)
+                    if (msg.role === 'tool' && msg.toolCallId)
                         baseMsg.tool_call_id = msg.toolCallId;
-                    if (msg.toolCalls && msg.toolCalls.length > 0) {
+                    if (msg.role === 'assistant' && msg.toolCalls && msg.toolCalls.length > 0) {
                         baseMsg.tool_calls = msg.toolCalls.map((tc) => ({
                             id: tc.id,
                             type: tc.type,

package/dist/skills/index.d.ts

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

package/dist/skills/index.js

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

package/dist/skills/registry.d.ts

@@ -0,0 +1,14 @@
+import z from 'zod';
+import type { Skill } from '../types';
+export declare const learnSkillToolName = "learn_skill";
+export declare const skill: (definition: Skill) => Skill;
+export declare class SkillRegistry {
+    private skills;
+    constructor(skills?: Skill[]);
+    register(skill: Skill): void;
+    get(name: string): Skill | undefined;
+    list(): Skill[];
+    tool(): import("..").LocalToolDefinition<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>>;
+}

package/dist/skills/registry.js

@@ -0,0 +1,60 @@
+import z from 'zod';
+import { tool } from '../tools/local-tools';
+export const learnSkillToolName = 'learn_skill';
+const getInstruction = async (instruction) => {
+    if (typeof instruction === 'string') {
+        return instruction;
+    }
+    return await instruction();
+};
+export const skill = (definition) => {
+    return { ...definition };
+};
+export class SkillRegistry {
+    skills = {};
+    constructor(skills = []) {
+        skills.forEach((skill) => {
+            this.skills[skill.name] = skill;
+        });
+    }
+    register(skill) {
+        this.skills[skill.name] = skill;
+    }
+    get(name) {
+        return this.skills[name];
+    }
+    list() {
+        return Object.values(this.skills);
+    }
+    tool() {
+        return tool({
+            name: learnSkillToolName,
+            description: 'Learns a new skill from the available skill registry.',
+            schema: z.object({
+                name: z.string().describe('The name of the skill to learn.'),
+            }),
+            handler: async ({ name }) => {
+                const foundSkill = this.get(name);
+                if (!foundSkill) {
+                    const availableSkills = this.list()
+                        .map((s) => `'${s.name}'`)
+                        .join(', ');
+                    return {
+                        success: false,
+                        result: null,
+                        error: `Skill '${name}' not found. Available skills are: ${availableSkills}`,
+                    };
+                }
+                const systemMessage = {
+                    role: 'system',
+                    content: `You have learned the following skill:\n\n**${foundSkill.name}**\n${await getInstruction(foundSkill.instruction)}`,
+                };
+                return {
+                    success: true,
+                    result: `Successfully learned the '${name}' skill.`,
+                    messages: [systemMessage],
+                };
+            },
+        });
+    }
+}

package/dist/stores/messages/interfaces.d.ts

@@ -1,5 +1,5 @@
 import type { Message } from '../../types/message';
-export interface StoredMessage extends Message {
+export type StoredMessage = Message & {
     id: string;
     contextId: string;
     index: number;
@@ -11,7 +11,7 @@ export interface StoredMessage extends Message {
         start: number;
         end: number;
     };
-}
+};
 export interface MessageStore {
     append(contextId: string, messages: Message[]): Promise<void>;
     getRecent(contextId: string, options?: {

package/dist/tools/artifact-tools.js

@@ -51,12 +51,15 @@ export function createArtifactTools(artifactStore, taskStateStore) {
                 });
                 await trackArtifactInState(context.taskId, params.artifactId, taskStateStore);
                 return {
-                    artifactId: params.artifactId,
-                    type: 'file',
-                    status: 'building',
-                    message: params.override
-                        ? 'File artifact reset. Use append_file_chunk to add content.'
-                        : 'File artifact created. Use append_file_chunk to add content.',
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        type: 'file',
+                        status: 'building',
+                        message: params.override
+                            ? 'File artifact reset. Use append_file_chunk to add content.'
+                            : 'File artifact created. Use append_file_chunk to add content.',
+                    },
                 };
             },
         }),
@@ -77,12 +80,15 @@ export function createArtifactTools(artifactStore, taskStateStore) {
                     isLastChunk: params.isLastChunk,
                 });
                 return {
-                    artifactId: params.artifactId,
-                    chunkAdded: true,
-                    complete: params.isLastChunk,
-                    message: params.isLastChunk
-                        ? 'Final chunk appended. Artifact is complete.'
-                        : 'Chunk appended successfully.',
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        chunkAdded: true,
+                        complete: params.isLastChunk,
+                        message: params.isLastChunk
+                            ? 'Final chunk appended. Artifact is complete.'
+                            : 'Chunk appended successfully.',
+                    },
                 };
             },
         }),
@@ -95,8 +101,11 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             handler: async (params, context) => {
                 const content = await scheduledStore.getFileContent(context.contextId, params.artifactId);
                 return {
-                    artifactId: params.artifactId,
-                    content,
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        content,
+                    },
                 };
             },
         }),
@@ -126,12 +135,15 @@ export function createArtifactTools(artifactStore, taskStateStore) {
                 await scheduledStore.writeData(context.contextId, params.artifactId, params.data);
                 await trackArtifactInState(context.taskId, params.artifactId, taskStateStore);
                 return {
-                    artifactId: params.artifactId,
-                    type: 'data',
-                    status: 'complete',
-                    message: params.override
-                        ? 'Data artifact reset successfully.'
-                        : 'Data artifact created successfully.',
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        type: 'data',
+                        status: 'complete',
+                        message: params.override
+                            ? 'Data artifact reset successfully.'
+                            : 'Data artifact created successfully.',
+                    },
                 };
             },
         }),
@@ -145,10 +157,13 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             handler: async (params, context) => {
                 await scheduledStore.writeData(context.contextId, params.artifactId, params.data);
                 return {
-                    artifactId: params.artifactId,
-                    type: 'data',
-                    status: 'complete',
-                    message: 'Data artifact updated successfully.',
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        type: 'data',
+                        status: 'complete',
+                        message: 'Data artifact updated successfully.',
+                    },
                 };
             },
         }),
@@ -161,8 +176,11 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             handler: async (params, context) => {
                 const data = await scheduledStore.getDataContent(context.contextId, params.artifactId);
                 return {
-                    artifactId: params.artifactId,
-                    data,
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        data,
+                    },
                 };
             },
         }),
@@ -175,8 +193,11 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             handler: async (params, context) => {
                 const data = await scheduledStore.getDataContent(context.contextId, params.artifactId);
                 return {
-                    artifactId: params.artifactId,
-                    data,
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        data,
+                    },
                 };
             },
         }),
@@ -212,12 +233,15 @@ export function createArtifactTools(artifactStore, taskStateStore) {
                 });
                 await trackArtifactInState(context.taskId, params.artifactId, taskStateStore);
                 return {
-                    artifactId: params.artifactId,
-                    type: 'dataset',
-                    status: 'building',
-                    message: params.override
-                        ? 'Dataset artifact reset. Use append_dataset_row(s) to add data.'
-                        : 'Dataset artifact created. Use append_dataset_row(s) to add data.',
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        type: 'dataset',
+                        status: 'building',
+                        message: params.override
+                            ? 'Dataset artifact reset. Use append_dataset_row(s) to add data.'
+                            : 'Dataset artifact created. Use append_dataset_row(s) to add data.',
+                    },
                 };
             },
         }),
@@ -231,9 +255,12 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             handler: async (params, context) => {
                 await scheduledStore.appendDatasetBatch(context.contextId, params.artifactId, [params.row]);
                 return {
-                    artifactId: params.artifactId,
-                    rowAdded: true,
-                    message: 'Row appended to dataset.',
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        rowAdded: true,
+                        message: 'Row appended to dataset.',
+                    },
                 };
             },
         }),
@@ -250,9 +277,12 @@ export function createArtifactTools(artifactStore, taskStateStore) {
                     isLastBatch: params.isLastBatch,
                 });
                 return {
-                    artifactId: params.artifactId,
-                    rowsAdded: params.rows.length,
-                    message: `${params.rows.length} rows appended to dataset.`,
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        rowsAdded: params.rows.length,
+                        message: `${params.rows.length} rows appended to dataset.`,
+                    },
                 };
             },
         }),
@@ -265,9 +295,12 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             handler: async (params, context) => {
                 const rows = await scheduledStore.getDatasetRows(context.contextId, params.artifactId);
                 return {
-                    artifactId: params.artifactId,
-                    rows,
-                    totalRows: rows.length,
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        rows,
+                        totalRows: rows.length,
+                    },
                 };
             },
         }),
@@ -282,15 +315,18 @@ export function createArtifactTools(artifactStore, taskStateStore) {
                 const artifacts = await Promise.all(artifactIds.map((id) => scheduledStore.getArtifact(context.contextId, id)));
                 const validArtifacts = artifacts.filter((a) => a !== null);
                 return {
-                    artifacts: validArtifacts.map((a) => ({
-                        artifactId: a.artifactId,
-                        type: a.type,
-                        name: a.name,
-                        taskId: a.taskId,
-                        contextId: a.contextId,
-                        createdAt: a.createdAt,
-                    })),
-                    totalCount: validArtifacts.length,
+                    success: true,
+                    result: {
+                        artifacts: validArtifacts.map((a) => ({
+                            artifactId: a.artifactId,
+                            type: a.type,
+                            name: a.name,
+                            taskId: a.taskId,
+                            contextId: a.contextId,
+                            createdAt: a.createdAt,
+                        })),
+                        totalCount: validArtifacts.length,
+                    },
                 };
             },
         }),
@@ -306,25 +342,28 @@ export function createArtifactTools(artifactStore, taskStateStore) {
                     throw new Error(`Artifact not found: ${params.artifactId}`);
                 }
                 return {
-                    artifactId: artifact.artifactId,
-                    type: artifact.type,
-                    taskId: artifact.taskId,
-                    contextId: artifact.contextId,
-                    name: artifact.name,
-                    description: artifact.description,
-                    status: artifact.status,
-                    createdAt: artifact.createdAt,
-                    updatedAt: artifact.updatedAt,
-                    ...(artifact.type === 'file' && {
-                        mimeType: artifact.mimeType,
-                        encoding: artifact.encoding,
-                        totalChunks: artifact.totalChunks,
-                        totalSize: artifact.totalSize,
-                    }),
-                    ...(artifact.type === 'dataset' && {
-                        totalRows: artifact.totalSize,
-                        schema: artifact.schema,
-                    }),
+                    success: true,
+                    result: {
+                        artifactId: artifact.artifactId,
+                        type: artifact.type,
+                        taskId: artifact.taskId,
+                        contextId: artifact.contextId,
+                        name: artifact.name,
+                        description: artifact.description,
+                        status: artifact.status,
+                        createdAt: artifact.createdAt,
+                        updatedAt: artifact.updatedAt,
+                        ...(artifact.type === 'file' && {
+                            mimeType: artifact.mimeType,
+                            encoding: artifact.encoding,
+                            totalChunks: artifact.totalChunks,
+                            totalSize: artifact.totalSize,
+                        }),
+                        ...(artifact.type === 'dataset' && {
+                            totalRows: artifact.totalSize,
+                            schema: artifact.schema,
+                        }),
+                    },
                 };
             },
         }),
@@ -337,9 +376,12 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             handler: async (params, context) => {
                 await scheduledStore.deleteArtifact(context.contextId, params.artifactId);
                 return {
-                    artifactId: params.artifactId,
-                    deleted: true,
-                    message: 'Artifact deleted successfully.',
+                    success: true,
+                    result: {
+                        artifactId: params.artifactId,
+                        deleted: true,
+                        message: 'Artifact deleted successfully.',
+                    },
                 };
             },
         }),

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

@@ -1,7 +1,8 @@
 import { z } from 'zod';
 import type { ExecutionContext } from '../types/context';
-import type { ToolProvider } from '../types/tools';
-export type ToolHandler<TParams> = (params: TParams, context: ExecutionContext) => Promise<unknown> | unknown;
+import type { ToolProvider, ToolResult } from '../types/tools';
+type InternalToolResult = Omit<ToolResult, 'toolCallId' | 'toolName'>;
+export type ToolHandler<TParams> = (params: TParams, context: ExecutionContext) => Promise<InternalToolResult> | InternalToolResult;
 export interface LocalToolDefinition<TSchema extends z.ZodObject> {
     name: string;
     description: string;
@@ -11,3 +12,4 @@ export interface LocalToolDefinition<TSchema extends z.ZodObject> {
 }
 export declare function tool<TSchema extends z.ZodObject>(definition: LocalToolDefinition<TSchema>): LocalToolDefinition<TSchema>;
 export declare function localTools(tools: LocalToolDefinition<z.ZodObject>[]): ToolProvider;
+export {};

package/dist/tools/local-tools.js

@@ -55,8 +55,10 @@ export function localTools(tools) {
                 return {
                     toolCallId: toolCall.id,
                     toolName: toolCall.function.name,
-                    success: true,
-                    result,
+                    success: result.success,
+                    error: result.error,
+                    result: result.result,
+                    messages: result.messages,
                 };
             }
             catch (error) {

package/dist/types/event.d.ts

@@ -1,3 +1,4 @@
+import type { Message, SystemMessage } from './message';
 import type { ToolCall } from './tools';
 export type TaskStatus = 'working' | 'waiting-input' | 'waiting-auth' | 'waiting-subtask' | 'completed' | 'failed' | 'canceled';
 export type ThoughtVerbosity = 'brief' | 'normal' | 'detailed';
@@ -306,6 +307,13 @@ export interface InternalLLMCallEvent {
     toolCount: number;
     timestamp: string;
 }
+export interface InternalToolMessageEvent {
+    kind: 'internal:tool-message';
+    contextId: string;
+    taskId: string;
+    message: SystemMessage;
+    timestamp: string;
+}
 export interface InternalCheckpointEvent {
     kind: 'internal:checkpoint';
     contextId: string;
@@ -331,7 +339,7 @@ export interface InternalToolCompleteEvent {
     error?: string;
     timestamp: string;
 }
-export type InternalDebugEvent = InternalLLMCallEvent | InternalCheckpointEvent | InternalToolStartEvent | InternalToolCompleteEvent | InternalThoughtProcessEvent;
+export type InternalDebugEvent = InternalLLMCallEvent | InternalToolMessageEvent | InternalCheckpointEvent | InternalToolStartEvent | InternalToolCompleteEvent | InternalThoughtProcessEvent;
 export interface LLMUsageEvent {
     kind: 'llm-usage';
     contextId: string;
@@ -347,7 +355,14 @@ export interface LLMUsageEvent {
     timestamp: string;
 }
 export type UsageEvent = LLMUsageEvent;
-export type AnyEvent = TaskLifecycleEvent | ContentStreamingEvent | ToolExecutionEvent | InputRequestEvent | AuthenticationEvent | ArtifactEvent | SubAgentEvent | ThoughtStreamEvent | InternalDebugEvent | UsageEvent;
+export interface MessageEvent {
+    kind: 'message';
+    contextId: string;
+    taskId: string;
+    message: Message;
+    timestamp: string;
+}
+export type AnyEvent = TaskLifecycleEvent | ContentStreamingEvent | ToolExecutionEvent | InputRequestEvent | AuthenticationEvent | ArtifactEvent | SubAgentEvent | ThoughtStreamEvent | InternalDebugEvent | UsageEvent | MessageEvent;
 export type LLMEvent<T> = Omit<T, 'contextId' | 'taskId'>;
 export type ExternalEvent = Exclude<AnyEvent, InternalDebugEvent>;
 export type DebugEvent = InternalDebugEvent;

package/dist/types/index.d.ts

@@ -5,5 +5,6 @@ export * from './context';
 export * from './event';
 export * from './llm';
 export * from './message';
+export * from './skills';
 export * from './state';
 export * from './tools';

package/dist/types/index.js

@@ -5,5 +5,6 @@ export * from './context';
 export * from './event';
 export * from './llm';
 export * from './message';
+export * from './skills';
 export * from './state';
 export * from './tools';

package/dist/types/message.d.ts

@@ -1,9 +1,24 @@
 import type { ToolCall } from './tools';
-export interface Message {
-    role: 'system' | 'user' | 'assistant' | 'tool';
+export type SystemMessage = {
+    role: 'system';
+    content: string;
+    name?: string;
+};
+export type UserMessage = {
+    role: 'user';
+    content: string;
+    name?: string;
+};
+export type AssistantMessage = {
+    role: 'assistant';
     content: string;
     name?: string;
-    toolCallId?: string;
     toolCalls?: ToolCall[];
-    contentDelta?: string;
-}
+};
+export type ToolMessage = {
+    role: 'tool';
+    content: string;
+    name?: string;
+    toolCallId: string;
+};
+export type Message = SystemMessage | UserMessage | AssistantMessage | ToolMessage;

package/dist/types/skills.d.ts

@@ -0,0 +1,8 @@
+export interface Skill {
+    name: string;
+    description: string;
+    instruction: string | (() => Promise<string>);
+}
+export interface SkillRegistration {
+    [key: string]: Skill;
+}

package/dist/types/skills.js

@@ -0,0 +1 @@
+export {};

package/dist/types/tools.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import type { ExecutionContext } from './context';
+import type { SystemMessage } from './message';
 export interface ToolCall {
     id: string;
     type: 'function';
@@ -14,6 +15,7 @@ export interface ToolResult {
     success: boolean;
     result: unknown;
     error?: string;
+    messages?: SystemMessage[];
 }
 export declare const JsonSchemaPropertySchema: z.ZodType<unknown>;
 export type JsonSchemaProperty = z.infer<typeof JsonSchemaPropertySchema>;

package/dist/utils/recursive-merge.js

@@ -3,7 +3,7 @@ export function recursiveMerge(initial, eventsFor, next, isStop) {
     const seed = {
         state: initial,
         iteration: 0,
-        events$: eventsFor({ ...initial, iteration: 0 }).pipe(shareReplay()),
+        events$: eventsFor({ ...initial, iteration: 0 }).pipe(shareReplay({ refCount: true })),
     };
     const iterations$ = of(seed).pipe(expand(({ state, iteration, events$ }) => events$.pipe(reduce((acc, e) => {
         acc.events.push(e);

package/package.json

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