@looopy-ai/core 2.1.9 → 2.1.12

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

@@ -1,4 +1,4 @@
-import type { LoopContext } from '../../core/types';
+import type { LoopContext } from '../../types/core';
 import type { ContextAnyEvent } from '../../types/event';
 export interface LoopIterationSpanParams {
     agentId: string;

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

@@ -1,15 +1,15 @@
-import type { LoopContext } from '../../core/types';
+import type { LoopContext } from '../../types/core';
 import type { AnyEvent } from '../../types/event';
-import type { Message } from '../../types/message';
+import type { LLMMessage } from '../../types/message';
 import type { ToolDefinition } from '../../types/tools';
-import type { SystemPrompt } from '../../utils/prompt';
+import type { SystemPrompts } from '../../utils/prompt';
 export interface LLMCallSpanParams {
     agentId: string;
     taskId: string;
-    messages: Message[];
+    messages: LLMMessage[];
     parentContext: import('@opentelemetry/api').Context;
 }
-export declare const startLLMCallSpan: <AuthContext>(context: LoopContext<AuthContext>, systemPrompt: SystemPrompt | undefined, messages: Message[], tools: ToolDefinition[]) => {
+export declare const startLLMCallSpan: <AuthContext>(context: LoopContext<AuthContext>, systemPrompts: SystemPrompts, messages: LLMMessage[], tools: ToolDefinition[]) => {
     span: import("@opentelemetry/api").Span;
     traceContext: import("@opentelemetry/api").Context;
     tapFinish: import("rxjs").MonoTypeOperatorFunction<AnyEvent>;

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

@@ -2,17 +2,21 @@ import { SpanStatusCode, trace } from '@opentelemetry/api';
 import { tap } from 'rxjs/internal/operators/tap';
 import { isChildTaskEvent } from '../../events/utils';
 import { SpanAttributes, SpanNames } from '../tracing';
-export const startLLMCallSpan = (context, systemPrompt, messages, tools) => {
+export const startLLMCallSpan = (context, systemPrompts, messages, tools) => {
     const tracer = trace.getTracer('looopy');
+    const source = systemPrompts.before
+        .concat(systemPrompts.after)
+        .filter((sp) => sp.source?.providerName === 'langfuse')
+        .at(0)?.source;
     const span = tracer.startSpan(SpanNames.LLM_CALL, {
         attributes: {
             [SpanAttributes.AGENT_ID]: context.agentId,
             [SpanAttributes.TASK_ID]: context.taskId,
             [SpanAttributes.GEN_AI_PROMPT]: JSON.stringify(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),
+            [SpanAttributes.LANGFUSE_PROMPT_NAME]: source?.promptName,
+            [SpanAttributes.LANGFUSE_PROMPT_VERSION]: source?.promptVersion,
+            'tools.available': tools.map((t) => t.id),
         },
     }, context.parentContext);
     const traceContext = trace.setSpan(context.parentContext, span);

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

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

package/dist/plugins/agent-academy.d.ts

@@ -0,0 +1,9 @@
+import type { Skill } from '../types';
+import type { IterationContext, Plugin, SystemPrompt } from '../types/core';
+export declare const learnSkillToolName = "learn_skill";
+export declare const getInstruction: (instruction: string | (() => Promise<string>)) => Promise<string>;
+export declare const skill: (definition: Skill) => Skill;
+export type AgentAcademyOptions<AuthContext> = {
+    learnSkillPrompt?: (skills: Skill[], context: IterationContext<AuthContext>) => Promise<string | SystemPrompt>;
+};
+export declare function agentAcademy<AuthContext>(skills: Skill[], options?: AgentAcademyOptions<AuthContext>): Plugin<AuthContext>;

package/dist/plugins/agent-academy.js

@@ -0,0 +1,137 @@
+import { catchError, defer, mergeMap, of } from 'rxjs';
+import z from 'zod';
+import { toolErrorEvent, toolResultToEvents } from '../tools/tool-result-events';
+export const learnSkillToolName = 'learn_skill';
+export const getInstruction = async (instruction) => {
+    if (typeof instruction === 'string') {
+        return instruction;
+    }
+    return await instruction();
+};
+export const skill = (definition) => {
+    return { ...definition };
+};
+export function agentAcademy(skills, options) {
+    const skillMap = new Map();
+    for (const skill of skills) {
+        if (skillMap.has(skill.name)) {
+            throw new Error(`Duplicate skill name: ${skill.name}`);
+        }
+        skillMap.set(skill.name, skill);
+    }
+    const learnSkillToolDefinition = {
+        id: learnSkillToolName,
+        description: 'Learns a new skill from the available agent academy.',
+        icon: 'lucide:graduation-cap',
+        parameters: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'The name of the skill to learn.',
+                },
+            },
+            required: ['name'],
+        },
+    };
+    const learnSkillPromptFn = options?.learnSkillPrompt ?? defaultPrompt;
+    return {
+        name: 'agent-academy',
+        generateSystemPrompts: async (context) => {
+            if (!learnSkillPromptFn) {
+                return [];
+            }
+            const prompt = await learnSkillPromptFn(skills, context);
+            if (typeof prompt === 'string') {
+                return [
+                    {
+                        content: prompt,
+                        position: 'before',
+                        positionSequence: 100,
+                    },
+                ];
+            }
+            return [
+                {
+                    ...prompt,
+                    positionSequence: prompt.positionSequence ?? 100,
+                },
+            ];
+        },
+        listTools: async () => {
+            return [learnSkillToolDefinition];
+        },
+        getTool: async (toolId) => {
+            if (toolId === learnSkillToolName) {
+                return learnSkillToolDefinition;
+            }
+            return undefined;
+        },
+        executeTool: (toolCall, _context) => defer(async () => {
+            if (toolCall.function.name !== learnSkillToolName) {
+                return {
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.function.name,
+                    success: false,
+                    result: null,
+                    error: `Tool ${toolCall.function.name} not found`,
+                };
+            }
+            try {
+                const schema = z.object({
+                    name: z.string().describe('The name of the skill to learn.'),
+                });
+                const validatedParams = schema.parse(toolCall.function.arguments);
+                const foundSkill = skillMap.get(validatedParams.name);
+                if (!foundSkill) {
+                    const availableSkills = Array.from(skillMap.values())
+                        .map((s) => `'${s.name}'`)
+                        .join(', ');
+                    return {
+                        toolCallId: toolCall.id,
+                        toolName: toolCall.function.name,
+                        success: false,
+                        result: null,
+                        error: `Skill '${validatedParams.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 {
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.function.name,
+                    success: true,
+                    result: `Successfully learned the '${validatedParams.name}' skill.`,
+                    messages: [systemMessage],
+                };
+            }
+            catch (error) {
+                if (error instanceof z.ZodError) {
+                    return {
+                        toolCallId: toolCall.id,
+                        toolName: toolCall.function.name,
+                        success: false,
+                        result: null,
+                        error: `Invalid arguments: ${error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ')}`,
+                    };
+                }
+                const err = error instanceof Error ? error : new Error(String(error));
+                return {
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.function.name,
+                    success: false,
+                    result: null,
+                    error: err.message,
+                };
+            }
+        }).pipe(mergeMap((result) => toolResultToEvents(result)), catchError((error) => of(toolErrorEvent(toolCall, error instanceof Error ? error.message : String(error))))),
+    };
+}
+const defaultPrompt = (skills) => {
+    const skillList = skills
+        .map((skill) => `- **${skill.name}**: ${typeof skill.instruction === 'string' ? skill.instruction : 'A useful skill.'}`)
+        .join('\n');
+    return `You can learn new skills using the learn_skill tool. The available skills are:\n\n${skillList}\n\nTo learn a skill, call the learn_skill tool with the name of the skill you want to learn.`;
+};

package/dist/plugins/index.d.ts

@@ -0,0 +1,2 @@
+export * from './agent-academy';
+export * from './system-prompt';

package/dist/plugins/index.js

@@ -0,0 +1,2 @@
+export * from './agent-academy';
+export * from './system-prompt';

package/dist/plugins/system-prompt.d.ts

@@ -0,0 +1,3 @@
+import type { IterationContext, Plugin, SystemPrompt } from '../types/core';
+export declare const literalPrompt: <AuthContext = any>(content: string) => Plugin<AuthContext>;
+export declare const asyncPrompt: <AuthContext>(content: (context: IterationContext<AuthContext>) => Promise<string | SystemPrompt>) => Plugin<AuthContext>;

package/dist/plugins/system-prompt.js

@@ -0,0 +1,20 @@
+export const literalPrompt = (content) => {
+    return {
+        name: 'literal-prompt',
+        generateSystemPrompts: async () => {
+            return [{ content, position: 'before' }];
+        },
+    };
+};
+export const asyncPrompt = (content) => {
+    return {
+        name: 'async-prompt',
+        generateSystemPrompts: async (context) => {
+            const prompt = await content(context);
+            if (typeof prompt === 'string') {
+                return [{ content: prompt, position: 'before' }];
+            }
+            return [prompt];
+        },
+    };
+};

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

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import type { AnyEvent } from '../types/event';
 import type { LLMProvider } from '../types/llm';
-import type { Message } from '../types/message';
+import type { LLMMessage } from '../types/message';
 import type { ToolDefinition } from '../types/tools';
 export interface LiteLLMConfig {
     baseUrl: string;
@@ -20,7 +20,7 @@ export declare class LiteLLMProvider implements LLMProvider {
     private readonly logger;
     constructor(config: LiteLLMConfig);
     call(request: {
-        messages: Message[];
+        messages: LLMMessage[];
         tools?: ToolDefinition[];
         sessionId?: string;
         metadata?: Record<string, unknown>;

package/dist/providers/litellm-provider.js

@@ -215,7 +215,7 @@ export class LiteLLMProvider {
                 litellmRequest.tools = request.tools.map((tool) => ({
                     type: 'function',
                     function: {
-                        name: tool.name,
+                        name: tool.id,
                         description: tool.description,
                         parameters: tool.parameters,
                     },

package/dist/stores/artifacts/internal-event-artifact-store.d.ts

@@ -1,7 +1,7 @@
 import type { ArtifactStore, DatasetSchema, StoredArtifact } from '../../types/artifact';
-import type { ContextAnyEvent } from '../../types/event';
+import type { AnyEvent } from '../../types/event';
 export interface InternalEventEmitter {
-    emit(event: ContextAnyEvent): void;
+    emit(event: AnyEvent): void;
 }
 export interface InternalEventArtifactStoreConfig {
     delegate: ArtifactStore;

package/dist/stores/artifacts/internal-event-artifact-store.js

@@ -18,8 +18,6 @@ export class InternalEventArtifactStore {
             if (artifact && artifact.type === 'file') {
                 const chunkIndex = artifact.chunks.length - 1;
                 const eventOptions = {
-                    contextId: artifact.contextId,
-                    taskId: artifact.taskId,
                     artifactId,
                     data: chunk,
                     index: chunkIndex,
@@ -50,8 +48,6 @@ export class InternalEventArtifactStore {
             const artifact = await this.delegate.getArtifact(contextId, artifactId);
             if (artifact && artifact.type === 'data') {
                 const eventOptions = {
-                    contextId: artifact.contextId,
-                    taskId: artifact.taskId,
                     artifactId,
                     data,
                     name: artifact.name,
@@ -78,8 +74,6 @@ export class InternalEventArtifactStore {
             if (artifact && artifact.type === 'dataset') {
                 const batchIndex = artifact.totalChunks - 1;
                 const eventOptions = {
-                    contextId: artifact.contextId,
-                    taskId: artifact.taskId,
                     artifactId,
                     rows,
                     index: batchIndex,

package/dist/stores/filesystem/filesystem-message-store.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from '../../types/message';
+import type { LLMMessage } from '../../types/message';
 import type { CompactionOptions, CompactionResult, MessageStore } from '../messages/interfaces';
 export interface FileSystemMessageStoreConfig {
     basePath?: string;
@@ -9,14 +9,14 @@ export declare class FileSystemMessageStore implements MessageStore {
     private agentId;
     private messageIndex;
     constructor(config: FileSystemMessageStoreConfig);
-    append(contextId: string, messages: Message[]): Promise<void>;
+    append(contextId: string, messages: LLMMessage[]): Promise<void>;
     getRecent(contextId: string, options?: {
         maxMessages?: number;
         maxTokens?: number;
-    }): Promise<Message[]>;
-    getAll(contextId: string): Promise<Message[]>;
+    }): Promise<LLMMessage[]>;
+    getAll(contextId: string): Promise<LLMMessage[]>;
     getCount(contextId: string): Promise<number>;
-    getRange(contextId: string, startIndex: number, endIndex: number): Promise<Message[]>;
+    getRange(contextId: string, startIndex: number, endIndex: number): Promise<LLMMessage[]>;
     compact(contextId: string, options?: CompactionOptions): Promise<CompactionResult>;
     clear(contextId: string): Promise<void>;
     private getMessagesDir;

package/dist/stores/messages/hybrid-message-store.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from '../../types/message';
+import type { LLMMessage } from '../../types/message';
 import type { CompactionOptions, CompactionResult, MessageStore } from './interfaces';
 export type SyncStrategy = 'immediate' | 'batch' | 'end-of-session';
 export interface HybridConfig {
@@ -10,20 +10,20 @@ export interface HybridConfig {
 export declare class HybridMessageStore implements MessageStore {
     private config;
     constructor(config: HybridConfig);
-    append(contextId: string, messages: Message[]): Promise<void>;
+    append(contextId: string, messages: LLMMessage[]): Promise<void>;
     getRecent(contextId: string, options?: {
         maxMessages?: number;
         maxTokens?: number;
-    }): Promise<Message[]>;
-    getAll(contextId: string): Promise<Message[]>;
+    }): Promise<LLMMessage[]>;
+    getAll(contextId: string): Promise<LLMMessage[]>;
     getCount(contextId: string): Promise<number>;
-    getRange(contextId: string, startIndex: number, endIndex: number): Promise<Message[]>;
+    getRange(contextId: string, startIndex: number, endIndex: number): Promise<LLMMessage[]>;
     compact(contextId: string, options?: CompactionOptions): Promise<CompactionResult>;
     clear(contextId: string): Promise<void>;
     syncToMemory(contextId: string): Promise<void>;
-    getMemoryContext(contextId: string): Promise<Message[]>;
+    getMemoryContext(contextId: string): Promise<LLMMessage[]>;
     getRawMessages(contextId: string, options?: {
         maxMessages?: number;
         maxTokens?: number;
-    }): Promise<Message[]>;
+    }): Promise<LLMMessage[]>;
 }

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

@@ -1,5 +1,5 @@
-import type { Message } from '../../types/message';
-export type StoredMessage = Message & {
+import type { LLMMessage } from '../../types/message';
+export type StoredMessage = LLMMessage & {
     id: string;
     contextId: string;
     index: number;
@@ -13,14 +13,14 @@ export type StoredMessage = Message & {
     };
 };
 export interface MessageStore {
-    append(contextId: string, messages: Message[]): Promise<void>;
+    append(contextId: string, messages: LLMMessage[]): Promise<void>;
     getRecent(contextId: string, options?: {
         maxMessages?: number;
         maxTokens?: number;
-    }): Promise<Message[]>;
-    getAll(contextId: string): Promise<Message[]>;
+    }): Promise<LLMMessage[]>;
+    getAll(contextId: string): Promise<LLMMessage[]>;
     getCount(contextId: string): Promise<number>;
-    getRange(contextId: string, startIndex: number, endIndex: number): Promise<Message[]>;
+    getRange(contextId: string, startIndex: number, endIndex: number): Promise<LLMMessage[]>;
     compact(contextId: string, options?: CompactionOptions): Promise<CompactionResult>;
     clear(contextId: string): Promise<void>;
 }
@@ -31,7 +31,7 @@ export interface CompactionOptions {
     summaryPrompt?: string;
 }
 export interface CompactionResult {
-    summaryMessages: Message[];
+    summaryMessages: LLMMessage[];
     compactedRange: {
         start: number;
         end: number;
@@ -39,4 +39,4 @@ export interface CompactionResult {
     tokensSaved: number;
 }
 export declare function estimateTokens(content: string | unknown): number;
-export declare function trimToTokenBudget<T extends Message>(messages: T[], maxTokens: number): T[];
+export declare function trimToTokenBudget<T extends LLMMessage>(messages: T[], maxTokens: number): T[];

package/dist/stores/messages/mem0-message-store.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from '../../types/message';
+import type { LLMMessage } from '../../types/message';
 import type { CompactionOptions, CompactionResult, MessageStore } from './interfaces';
 type MemoryClient = any;
 export type Mem0MemoryLevel = 'conversation' | 'session' | 'user' | 'org';
@@ -15,16 +15,16 @@ export declare class Mem0MessageStore implements MessageStore {
     private config;
     private messageCache;
     constructor(config: Mem0Config);
-    append(contextId: string, messages: Message[]): Promise<void>;
+    append(contextId: string, messages: LLMMessage[]): Promise<void>;
     getRecent(contextId: string, options?: {
         maxMessages?: number;
         maxTokens?: number;
-    }): Promise<Message[]>;
+    }): Promise<LLMMessage[]>;
     private searchMemories;
     private formatMemoriesAsContext;
-    getAll(contextId: string): Promise<Message[]>;
+    getAll(contextId: string): Promise<LLMMessage[]>;
     getCount(contextId: string): Promise<number>;
-    getRange(contextId: string, startIndex: number, endIndex: number): Promise<Message[]>;
+    getRange(contextId: string, startIndex: number, endIndex: number): Promise<LLMMessage[]>;
     compact(contextId: string, options?: CompactionOptions): Promise<CompactionResult>;
     clear(contextId: string): Promise<void>;
     private extractUserId;

package/dist/stores/messages/memory-message-store.d.ts

@@ -1,5 +1,5 @@
 import type { LLMProvider } from '../../types/llm';
-import type { Message } from '../../types/message';
+import type { LLMMessage } from '../../types/message';
 import type { CompactionOptions, CompactionResult, MessageStore } from './interfaces';
 export interface InMemoryMessageStoreConfig {
     llmProvider?: LLMProvider;
@@ -9,14 +9,14 @@ export declare class InMemoryMessageStore implements MessageStore {
     private messages;
     private config;
     constructor(config?: InMemoryMessageStoreConfig);
-    append(contextId: string, messages: Message[]): Promise<void>;
+    append(contextId: string, messages: LLMMessage[]): Promise<void>;
     getRecent(contextId: string, options?: {
         maxMessages?: number;
         maxTokens?: number;
-    }): Promise<Message[]>;
-    getAll(contextId: string): Promise<Message[]>;
+    }): Promise<LLMMessage[]>;
+    getAll(contextId: string): Promise<LLMMessage[]>;
     getCount(contextId: string): Promise<number>;
-    getRange(contextId: string, startIndex: number, endIndex: number): Promise<Message[]>;
+    getRange(contextId: string, startIndex: number, endIndex: number): Promise<LLMMessage[]>;
     compact(contextId: string, options?: CompactionOptions): Promise<CompactionResult>;
     clear(contextId: string): Promise<void>;
     private compactSlidingWindow;

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

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import z from 'zod';
-import type { ContextAnyEvent, ExecutionContext } from '../types';
-import type { ToolCall, ToolDefinition, ToolProvider } from '../types/tools';
+import type { AnyEvent, ExecutionContext, Plugin } from '../types';
+import type { ToolCall, ToolDefinition } from '../types/tools';
 export type HeaderFactory<AuthContext> = (context: ExecutionContext<AuthContext>, card: AgentCard) => Promise<Record<string, string | undefined>>;
 declare const cardSchema: z.ZodObject<{
     name: z.ZodString;
@@ -19,7 +19,7 @@ declare const cardSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type AgentCard = z.infer<typeof cardSchema>;
-export declare class AgentToolProvider<AuthContext> implements ToolProvider<AuthContext> {
+export declare class AgentToolProvider<AuthContext> implements Plugin<AuthContext> {
     readonly card: AgentCard;
     readonly getHeaders?: HeaderFactory<AuthContext> | undefined;
     static fromUrl: <AuthContext_1>(cardUrl: string, getHeaders?: HeaderFactory<AuthContext_1>) => Promise<AgentToolProvider<AuthContext_1>>;
@@ -30,7 +30,7 @@ export declare class AgentToolProvider<AuthContext> implements ToolProvider<Auth
     private readonly logger;
     constructor(card: AgentCard, getHeaders?: HeaderFactory<AuthContext> | undefined);
     getTool(toolName: string): Promise<ToolDefinition | undefined>;
-    getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext<AuthContext>): Observable<ContextAnyEvent>;
+    listTools(): Promise<ToolDefinition[]>;
+    executeTool(toolCall: ToolCall, context: ExecutionContext<AuthContext>): Observable<AnyEvent>;
 }
 export {};

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

@@ -50,7 +50,7 @@ export class AgentToolProvider {
         this.logger = getLogger({ component: 'agent-tool-provider', agentName: this.agentName });
         this.tools = [
             {
-                name: `${this.name}__invoke`,
+                id: `${this.name}__invoke`,
                 description: `Invoke the ${card.name} agent.\n\n${card.description}` ||
                     `Invoke the ${card.name} agent`,
                 icon: card.icon,
@@ -68,13 +68,13 @@ export class AgentToolProvider {
         ];
     }
     getTool(toolName) {
-        const tool = this.tools.find((t) => t.name === toolName);
+        const tool = this.tools.find((t) => t.id === toolName);
         return Promise.resolve(tool);
     }
-    getTools() {
+    listTools() {
         return Promise.resolve(this.tools);
     }
-    execute(toolCall, context) {
+    executeTool(toolCall, context) {
         const logger = this.logger.child({
             taskId: context.taskId,
             toolCallId: toolCall.id,
@@ -86,14 +86,14 @@ export class AgentToolProvider {
                 const tool = await this.getTool(toolCall.function.name);
                 if (!tool) {
                     logger.error({ toolName: toolCall.function.name }, 'Tool not found');
-                    subscriber.next(toolErrorEvent(context, toolCall, `Tool not found: ${toolCall.function.name}`));
+                    subscriber.next(toolErrorEvent(toolCall, `Tool not found: ${toolCall.function.name}`));
                     subscriber.complete();
                     return;
                 }
                 const prompt = toolCall.function.arguments.prompt;
                 if (!prompt || typeof prompt !== 'string') {
                     logger.error('Invalid tool call arguments');
-                    subscriber.next(toolErrorEvent(context, toolCall, 'Tool argument must include "prompt" and it must be a string'));
+                    subscriber.next(toolErrorEvent(toolCall, 'Tool argument must include "prompt" and it must be a string'));
                     subscriber.complete();
                     return;
                 }
@@ -111,14 +111,14 @@ export class AgentToolProvider {
                 });
                 if (!res.ok) {
                     logger.error({ status: res.status, statusText: res.statusText }, 'Agent call failed');
-                    subscriber.next(toolErrorEvent(context, toolCall, `Agent endpoint responded with ${res.status} ${res.statusText}`));
+                    subscriber.next(toolErrorEvent(toolCall, `Agent endpoint responded with ${res.status} ${res.statusText}`));
                     subscriber.complete();
                     return;
                 }
                 const body = res.body;
                 if (!body) {
                     logger.error('Agent response has no body');
-                    subscriber.next(toolErrorEvent(context, toolCall, 'Agent returned no response body'));
+                    subscriber.next(toolErrorEvent(toolCall, 'Agent returned no response body'));
                     subscriber.complete();
                     return;
                 }
@@ -131,6 +131,12 @@ export class AgentToolProvider {
                         kind: e.event,
                         parentTaskId: context.taskId,
                         ...data,
+                        path: [
+                            `agent:${this.card.name}`,
+                            ...('path' in data && Array.isArray(data.path)
+                                ? data.path.filter((p) => typeof p === 'string' && p)
+                                : []),
+                        ],
                     });
                     if (e.event === 'task-complete') {
                         content = data.content;
@@ -140,8 +146,6 @@ export class AgentToolProvider {
                 if (!subscriber.closed) {
                     const toolCompleteEvent = {
                         kind: 'tool-complete',
-                        contextId: context.contextId,
-                        taskId: context.taskId,
                         toolCallId: toolCall.id,
                         toolName: toolCall.function.name,
                         success: true,

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

@@ -1,4 +1,4 @@
 import type { ArtifactStore } from '../types/artifact';
+import type { Plugin } from '../types/core';
 import type { TaskStateStore } from '../types/state';
-import type { ToolProvider } from '../types/tools';
-export declare function createArtifactTools<AuthContext>(artifactStore: ArtifactStore, taskStateStore: TaskStateStore): ToolProvider<AuthContext>;
+export declare function createArtifactTools<AuthContext>(artifactStore: ArtifactStore, taskStateStore: TaskStateStore): Plugin<AuthContext>;