@looopy-ai/core 2.1.8 → 2.1.11

package/dist/core/agent.d.ts

@@ -1,23 +1,19 @@
 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 { Plugin } from '../types/core';
 import type { ContextAnyEvent } from '../types/event';
 import type { LLMProvider } from '../types/llm';
-import type { Message } from '../types/message';
-import type { ToolProvider } from '../types/tools';
-import type { SystemPromptProp } from '../utils/prompt';
+import type { LLMMessage } from '../types/message';
 export interface AgentConfig<AuthContext> {
     agentId: string;
     contextId: string;
     llmProvider: LLMProvider;
-    toolProviders: ToolProvider<AuthContext>[];
     messageStore: MessageStore;
     agentStore?: AgentStore;
     autoCompact?: boolean;
     maxMessages?: number;
-    systemPrompt?: SystemPromptProp;
-    skillRegistry?: SkillRegistry;
+    plugins?: Plugin<AuthContext>[];
     logger?: import('pino').Logger;
 }
 export interface GetMessagesOptions {
@@ -42,7 +38,7 @@ export declare class Agent<AuthContext> {
     }): Promise<Observable<ContextAnyEvent>>;
     private executeInternal;
     shutdown(): Promise<void>;
-    getMessages(options?: GetMessagesOptions): Promise<Message[]>;
+    getMessages(options?: GetMessagesOptions): Promise<LLMMessage[]>;
     clear(): Promise<void>;
     private persistState;
     private persistStateSafely;

package/dist/core/agent.js

@@ -58,7 +58,7 @@ export class Agent {
                 }
                 setResumeAttributes(span, existingMessages.length);
             }
-            this._state.status = 'ready';
+            this._state.status = 'idle';
             this._state.lastActivity = new Date();
             await this.persistState();
             this.logger.info({ status: this._state.status }, 'Agent initialized');
@@ -169,10 +169,8 @@ export class Agent {
                         taskId,
                         authContext,
                         parentContext: turnContext,
-                        systemPrompt: this.config.systemPrompt,
-                        toolProviders: this.config.toolProviders,
-                        skillRegistry: this.config.skillRegistry,
                         logger: this.config.logger.child({ taskId, turnNumber }),
+                        plugins: this.config.plugins || [],
                         turnNumber,
                         metadata,
                     }, {
@@ -237,7 +235,7 @@ export class Agent {
                             try {
                                 this._state.turnCount++;
                                 this._state.lastActivity = new Date();
-                                this._state.status = 'ready';
+                                this._state.status = 'idle';
                                 await this.persistState();
                                 setTurnCountAttribute(turnSpan, this._state.turnCount);
                                 if (this.config.autoCompact) {

package/dist/core/index.d.ts

@@ -1,4 +1,3 @@
 export { Agent, type AgentConfig, type GetMessagesOptions } from './agent';
 export { StateCleanupService } from './cleanup';
 export { createLogger, getLogger, type LoggerConfig, type LogLevel, setDefaultLogger, } from './logger';
-export * from './types';

package/dist/core/index.js

@@ -1,4 +1,3 @@
 export { Agent } from './agent';
 export { StateCleanupService } from './cleanup';
 export { createLogger, getLogger, setDefaultLogger, } from './logger';
-export * from './types';

package/dist/core/iteration.d.ts

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

package/dist/core/iteration.js

@@ -1,6 +1,6 @@
 import { concat, defer, filter, map, mergeMap, shareReplay } from 'rxjs';
 import { startLLMCallSpan, startLoopIterationSpan } from '../observability/spans';
-import { getSystemPrompt } from '../utils/prompt';
+import { getSystemPrompts } from '../utils/prompt';
 import { runToolCall } from './tools';
 export const runIteration = (context, config, history) => {
     const logger = context.logger.child({
@@ -9,17 +9,26 @@ 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, context);
-        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, tools);
-        return config.llmProvider
+        const systemPrompts = await getSystemPrompts(context.plugins, context);
+        const messages = await prepareMessages(systemPrompts, history);
+        const tools = await prepareTools(context.plugins);
+        logger.debug({ systemPrompts, messages: messages.length, tools: tools.map((t) => t.id).join(', ') }, 'Prepared messages and tools for LLM call');
+        return { messages, tools, systemPrompts };
+    }).pipe(mergeMap(({ messages, tools, systemPrompts }) => {
+        const { tapFinish: finishLLMCallSpan } = startLLMCallSpan({ ...context, parentContext: iterationContext }, systemPrompts, messages, tools);
+        const metadata = systemPrompts.before
+            .concat(systemPrompts.after)
+            .reverse()
+            .reduce((acc, sp) => {
+            if (sp.metadata) {
+                return Object.assign(acc, sp.metadata);
+            }
+            return acc;
+        }, {});
+        const llmProvider = typeof config.llmProvider === 'function'
+            ? config.llmProvider(context, metadata)
+            : config.llmProvider;
+        return llmProvider
             .call({
             messages,
             tools,
@@ -29,6 +38,7 @@ export const runIteration = (context, config, history) => {
             .pipe(finishLLMCallSpan, map((event) => ({
             contextId: context.contextId,
             taskId: context.taskId,
+            path: undefined,
             ...event,
         })));
     }), shareReplay({ refCount: true }));
@@ -39,29 +49,18 @@ export const runIteration = (context, config, history) => {
     }, event)));
     return concat(llmEvents$.pipe(filter((event) => event.kind !== 'tool-call')), toolEvents$).pipe(finishIterationSpan);
 };
-const prepareMessages = async (systemPrompt, skillRegistry, history) => {
-    const messages = [];
-    if (systemPrompt) {
-        messages.push({
-            role: 'system',
-            content: systemPrompt.prompt,
-        });
-    }
-    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: `You can learn new skills by using the 'learn_skill' tool. Available skills:\n\n${skillList}`,
-            };
-            messages.push(skillMessage);
-        }
-    }
-    return messages.concat(history);
+const prepareMessages = async (systemPrompts, history) => {
+    const messages = systemPrompts.before.map((sp) => ({
+        role: 'system',
+        content: sp.content,
+    }));
+    return messages.concat(history, systemPrompts.after.map((sp) => ({
+        role: 'system',
+        content: sp.content,
+    })));
 };
 const prepareTools = async (toolProviders) => {
-    const toolPromises = toolProviders.map((p) => p.getTools());
+    const toolPromises = toolProviders.map((p) => p.listTools?.());
     const toolArrays = await Promise.all(toolPromises);
-    return toolArrays.flat();
+    return toolArrays.filter(Boolean).flat();
 };

package/dist/core/loop.d.ts

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

package/dist/core/tools.d.ts

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

package/dist/core/tools.js

@@ -1,7 +1,8 @@
-import { catchError, concat, defer, mergeMap, of, tap } from 'rxjs';
+import { catchError, concat, defer, map, mergeMap, of, tap } from 'rxjs';
 import { isChildTaskEvent } from '../events/utils';
 import { startToolExecuteSpan } from '../observability/spans';
 import { toolErrorEvent } from '../tools/tool-result-events';
+import { isToolPlugin } from '../types/core';
 export const runToolCall = (context, toolCall) => {
     const logger = context.logger.child({
         component: 'tool-call',
@@ -9,21 +10,19 @@ export const runToolCall = (context, toolCall) => {
         toolName: toolCall.toolName,
     });
     return defer(async () => {
-        const matchingProviders = await Promise.all(context.toolProviders.map(async (p) => ({
-            provider: p,
-            tool: await p.getTool(toolCall.toolName),
+        const matchingPlugins = await Promise.all(context.plugins.filter(isToolPlugin).map(async (p) => ({
+            plugin: p,
+            tool: await p.getTool?.(toolCall.toolName),
         })));
-        const matchingProvider = matchingProviders.find((p) => p.tool !== undefined);
-        if (!matchingProvider) {
-            logger.warn('No tool provider found for tool');
+        const matchingPlugin = matchingPlugins.find((p) => p.tool !== undefined);
+        if (!matchingPlugin?.tool) {
+            logger.warn('No plugin found for tool');
             return of(toolCall);
         }
-        const { provider, tool } = matchingProvider;
-        logger.debug({ providerName: provider.name, toolIcon: tool.icon }, 'Found tool provider for tool');
+        const { plugin, tool } = matchingPlugin;
+        logger.debug({ providerName: plugin.name, toolIcon: tool.icon }, 'Found tool provider for tool');
         const toolStartEvent = {
             kind: 'tool-start',
-            contextId: context.contextId,
-            taskId: context.taskId,
             toolCallId: toolCall.toolCallId,
             icon: tool.icon,
             toolName: toolCall.toolName,
@@ -41,34 +40,42 @@ export const runToolCall = (context, toolCall) => {
         const { tapFinish } = startToolExecuteSpan(context, toolCall);
         const execution$ = defer(() => {
             try {
-                logger.trace({ providerName: provider.name }, 'Executing tool');
-                return provider.execute(toolCallInput, context).pipe(tap((event) => {
+                logger.trace({ providerName: plugin.name }, 'Executing tool');
+                if (!isToolPlugin(plugin)) {
+                    return of(toolErrorEvent(toolCallInput, 'Plugin does not implement tools'));
+                }
+                return plugin.executeTool(toolCallInput, context).pipe(tap((event) => {
                     if (isChildTaskEvent(event))
                         return;
                     if (event.kind !== 'tool-complete') {
                         return;
                     }
-                    logger.trace({ providerName: provider.name, success: event.success }, 'Tool execution complete');
+                    logger.trace({ providerName: plugin.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,
+                        providerName: plugin.name,
                         error: err.message,
                         stack: err.stack,
                     }, 'Tool execution error');
-                    return of(toolErrorEvent(context, toolCallInput, err.message));
+                    return of(toolErrorEvent(toolCallInput, err.message));
                 }));
             }
             catch (error) {
                 const err = error instanceof Error ? error : new Error(String(error));
                 logger.error({
-                    providerName: provider.name,
+                    providerName: plugin.name,
                     error: err.message,
                     stack: err.stack,
                 }, 'Tool execution error');
-                return of(toolErrorEvent(context, toolCallInput, err.message));
+                return of(toolErrorEvent(toolCallInput, err.message));
             }
         });
         return concat(of(toolStartEvent), execution$);
-    }).pipe(mergeMap((obs) => obs));
+    }).pipe(mergeMap((obs) => obs), map((event) => ({
+        contextId: context.contextId,
+        taskId: context.taskId,
+        path: [`tool:${toolCall.toolName}`],
+        ...event,
+    })));
 };

package/dist/events/utils.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEvent, 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';
+import type { AnyEvent, AuthCompletedEvent, AuthRequiredEvent, AuthType, ChildTaskEvent, 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;
@@ -38,22 +38,16 @@ export interface CreateTaskCompleteEventOptions {
 }
 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): ContextEvent<ContentDeltaEvent>;
+export declare function createContentDeltaEvent(options: CreateContentDeltaEventOptions): ContentDeltaEvent;
 export interface CreateContentCompleteEventOptions {
-    contextId: string;
-    taskId: string;
     content: string;
     finishReason?: FinishReason;
 }
-export declare function createContentCompleteEvent(options: CreateContentCompleteEventOptions): ContextEvent<ContentCompleteEvent>;
+export declare function createContentCompleteEvent(options: CreateContentCompleteEventOptions): ContentCompleteEvent;
 export interface CreateToolStartEventOptions {
-    contextId: string;
-    taskId: string;
     toolCallId: string;
     toolName: string;
     arguments: Record<string, unknown>;
@@ -63,10 +57,8 @@ export interface CreateToolStartEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createToolStartEvent(options: CreateToolStartEventOptions): ContextEvent<ToolStartEvent>;
+export declare function createToolStartEvent(options: CreateToolStartEventOptions): ToolStartEvent;
 export interface CreateToolProgressEventOptions {
-    contextId: string;
-    taskId: string;
     toolCallId: string;
     progress: number;
     message?: string;
@@ -77,10 +69,8 @@ export interface CreateToolProgressEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createToolProgressEvent(options: CreateToolProgressEventOptions): ContextEvent<ToolProgressEvent>;
+export declare function createToolProgressEvent(options: CreateToolProgressEventOptions): ToolProgressEvent;
 export interface CreateToolCompleteEventOptions {
-    contextId: string;
-    taskId: string;
     toolCallId: string;
     toolName: string;
     success: boolean;
@@ -93,10 +83,8 @@ export interface CreateToolCompleteEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createToolCompleteEvent(options: CreateToolCompleteEventOptions): ContextEvent<ToolCompleteEvent>;
+export declare function createToolCompleteEvent(options: CreateToolCompleteEventOptions): ToolCompleteEvent;
 export interface CreateInputRequiredEventOptions {
-    contextId: string;
-    taskId: string;
     inputId: string;
     requireUser?: boolean;
     inputType: InputType;
@@ -105,10 +93,8 @@ export interface CreateInputRequiredEventOptions {
     options?: unknown[];
     metadata?: Record<string, unknown>;
 }
-export declare function createInputRequiredEvent(options: CreateInputRequiredEventOptions): ContextEvent<InputRequiredEvent>;
+export declare function createInputRequiredEvent(options: CreateInputRequiredEventOptions): InputRequiredEvent;
 export interface CreateInputReceivedEventOptions {
-    contextId: string;
-    taskId: string;
     inputId: string;
     providedBy: InputProvider;
     userId?: string;
@@ -118,10 +104,8 @@ export interface CreateInputReceivedEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createInputReceivedEvent(options: CreateInputReceivedEventOptions): ContextEvent<InputReceivedEvent>;
+export declare function createInputReceivedEvent(options: CreateInputReceivedEventOptions): InputReceivedEvent;
 export interface CreateAuthRequiredEventOptions {
-    contextId: string;
-    taskId: string;
     authId: string;
     authType: AuthType;
     provider?: string;
@@ -133,10 +117,8 @@ export interface CreateAuthRequiredEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createAuthRequiredEvent(options: CreateAuthRequiredEventOptions): ContextEvent<AuthRequiredEvent>;
+export declare function createAuthRequiredEvent(options: CreateAuthRequiredEventOptions): AuthRequiredEvent;
 export interface CreateAuthCompletedEventOptions {
-    contextId: string;
-    taskId: string;
     authId: string;
     userId: string;
     metadata?: {
@@ -144,10 +126,8 @@ export interface CreateAuthCompletedEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createAuthCompletedEvent(options: CreateAuthCompletedEventOptions): ContextEvent<AuthCompletedEvent>;
+export declare function createAuthCompletedEvent(options: CreateAuthCompletedEventOptions): AuthCompletedEvent;
 export interface CreateFileWriteEventOptions {
-    contextId: string;
-    taskId: string;
     artifactId: string;
     data: string;
     index: number;
@@ -162,10 +142,8 @@ export interface CreateFileWriteEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createFileWriteEvent(options: CreateFileWriteEventOptions): ContextEvent<FileWriteEvent>;
+export declare function createFileWriteEvent(options: CreateFileWriteEventOptions): FileWriteEvent;
 export interface CreateDataWriteEventOptions {
-    contextId: string;
-    taskId: string;
     artifactId: string;
     data: Record<string, unknown>;
     name?: string;
@@ -176,10 +154,8 @@ export interface CreateDataWriteEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createDataWriteEvent(options: CreateDataWriteEventOptions): ContextEvent<DataWriteEvent>;
+export declare function createDataWriteEvent(options: CreateDataWriteEventOptions): DataWriteEvent;
 export interface CreateDatasetWriteEventOptions {
-    contextId: string;
-    taskId: string;
     artifactId: string;
     rows: Record<string, unknown>[];
     index: number;
@@ -194,18 +170,14 @@ export interface CreateDatasetWriteEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createDatasetWriteEvent(options: CreateDatasetWriteEventOptions): ContextEvent<DatasetWriteEvent>;
+export declare function createDatasetWriteEvent(options: CreateDatasetWriteEventOptions): DatasetWriteEvent;
 export interface CreateSubtaskCreatedEventOptions {
-    contextId: string;
-    taskId: string;
     subtaskId: string;
     agentId?: string;
     prompt: string;
 }
-export declare function createSubtaskCreatedEvent(options: CreateSubtaskCreatedEventOptions): ContextEvent<SubtaskCreatedEvent>;
+export declare function createSubtaskCreatedEvent(options: CreateSubtaskCreatedEventOptions): SubtaskCreatedEvent;
 export interface CreateThoughtStreamEventOptions {
-    contextId: string;
-    taskId: string;
     thoughtId: string;
     thoughtType: ThoughtType;
     verbosity: ThoughtVerbosity;
@@ -218,34 +190,28 @@ export interface CreateThoughtStreamEventOptions {
         [key: string]: unknown;
     };
 }
-export declare function createThoughtStreamEvent(options: CreateThoughtStreamEventOptions): ContextEvent<ThoughtStreamEvent>;
+export declare function createThoughtStreamEvent(options: CreateThoughtStreamEventOptions): ThoughtStreamEvent;
 export interface CreateInternalThoughtProcessEventOptions {
-    contextId: string;
-    taskId: string;
     iteration: number;
     stage: 'pre-llm' | 'post-llm' | 'pre-tool' | 'post-tool';
     reasoning: string;
     state: Record<string, unknown>;
 }
-export declare function createInternalThoughtProcessEvent(options: CreateInternalThoughtProcessEventOptions): ContextEvent<InternalThoughtProcessEvent>;
+export declare function createInternalThoughtProcessEvent(options: CreateInternalThoughtProcessEventOptions): InternalThoughtProcessEvent;
 export interface CreateInternalLLMCallEventOptions {
-    contextId: string;
-    taskId: string;
     iteration: number;
     messageCount: number;
     toolCount: number;
 }
-export declare function createInternalLLMCallEvent(options: CreateInternalLLMCallEventOptions): ContextEvent<InternalLLMCallEvent>;
+export declare function createInternalLLMCallEvent(options: CreateInternalLLMCallEventOptions): InternalLLMCallEvent;
 export interface CreateInternalCheckpointEventOptions {
-    contextId: string;
-    taskId: string;
     iteration: number;
 }
-export declare function createInternalCheckpointEvent(options: CreateInternalCheckpointEventOptions): ContextEvent<InternalCheckpointEvent>;
+export declare function createInternalCheckpointEvent(options: CreateInternalCheckpointEventOptions): 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;
 }>[];
-export declare const isChildTaskEvent: (event: AnyEvent) => boolean;
+export declare const isChildTaskEvent: (event: AnyEvent) => event is ChildTaskEvent<ContextAnyEvent>;

package/dist/events/utils.js

@@ -37,8 +37,6 @@ export function createTaskCompleteEvent(options) {
 export function createContentDeltaEvent(options) {
     return {
         kind: 'content-delta',
-        contextId: options.contextId,
-        taskId: options.taskId,
         delta: options.delta,
         index: options.index,
         timestamp: new Date().toISOString(),
@@ -47,8 +45,6 @@ export function createContentDeltaEvent(options) {
 export function createContentCompleteEvent(options) {
     return {
         kind: 'content-complete',
-        contextId: options.contextId,
-        taskId: options.taskId,
         content: options.content,
         finishReason: options.finishReason || 'stop',
         timestamp: new Date().toISOString(),
@@ -57,8 +53,6 @@ export function createContentCompleteEvent(options) {
 export function createToolStartEvent(options) {
     return {
         kind: 'tool-start',
-        contextId: options.contextId,
-        taskId: options.taskId,
         toolCallId: options.toolCallId,
         toolName: options.toolName,
         arguments: options.arguments,
@@ -69,8 +63,6 @@ export function createToolStartEvent(options) {
 export function createToolProgressEvent(options) {
     return {
         kind: 'tool-progress',
-        contextId: options.contextId,
-        taskId: options.taskId,
         toolCallId: options.toolCallId,
         progress: options.progress,
         message: options.message,
@@ -81,8 +73,6 @@ export function createToolProgressEvent(options) {
 export function createToolCompleteEvent(options) {
     return {
         kind: 'tool-complete',
-        contextId: options.contextId,
-        taskId: options.taskId,
         toolCallId: options.toolCallId,
         toolName: options.toolName,
         success: options.success,
@@ -95,8 +85,6 @@ export function createToolCompleteEvent(options) {
 export function createInputRequiredEvent(options) {
     return {
         kind: 'input-required',
-        contextId: options.contextId,
-        taskId: options.taskId,
         inputId: options.inputId,
         requireUser: options.requireUser,
         inputType: options.inputType,
@@ -110,8 +98,6 @@ export function createInputRequiredEvent(options) {
 export function createInputReceivedEvent(options) {
     return {
         kind: 'input-received',
-        contextId: options.contextId,
-        taskId: options.taskId,
         inputId: options.inputId,
         providedBy: options.providedBy,
         userId: options.userId,
@@ -123,8 +109,6 @@ export function createInputReceivedEvent(options) {
 export function createAuthRequiredEvent(options) {
     return {
         kind: 'auth-required',
-        contextId: options.contextId,
-        taskId: options.taskId,
         authId: options.authId,
         authType: options.authType,
         provider: options.provider,
@@ -138,8 +122,6 @@ export function createAuthRequiredEvent(options) {
 export function createAuthCompletedEvent(options) {
     return {
         kind: 'auth-completed',
-        contextId: options.contextId,
-        taskId: options.taskId,
         authId: options.authId,
         userId: options.userId,
         timestamp: new Date().toISOString(),
@@ -149,8 +131,6 @@ export function createAuthCompletedEvent(options) {
 export function createFileWriteEvent(options) {
     return {
         kind: 'file-write',
-        contextId: options.contextId,
-        taskId: options.taskId,
         artifactId: options.artifactId,
         data: options.data,
         index: options.index,
@@ -166,8 +146,6 @@ export function createFileWriteEvent(options) {
 export function createDataWriteEvent(options) {
     return {
         kind: 'data-write',
-        contextId: options.contextId,
-        taskId: options.taskId,
         artifactId: options.artifactId,
         data: options.data,
         name: options.name,
@@ -179,8 +157,6 @@ export function createDataWriteEvent(options) {
 export function createDatasetWriteEvent(options) {
     return {
         kind: 'dataset-write',
-        contextId: options.contextId,
-        taskId: options.taskId,
         artifactId: options.artifactId,
         rows: options.rows,
         index: options.index,
@@ -195,8 +171,6 @@ export function createDatasetWriteEvent(options) {
 export function createSubtaskCreatedEvent(options) {
     return {
         kind: 'subtask-created',
-        contextId: options.contextId,
-        taskId: options.taskId,
         subtaskId: options.subtaskId,
         agentId: options.agentId,
         prompt: options.prompt,
@@ -206,8 +180,6 @@ export function createSubtaskCreatedEvent(options) {
 export function createThoughtStreamEvent(options) {
     return {
         kind: 'thought-stream',
-        contextId: options.contextId,
-        taskId: options.taskId,
         thoughtId: options.thoughtId,
         thoughtType: options.thoughtType,
         verbosity: options.verbosity,
@@ -220,8 +192,6 @@ export function createThoughtStreamEvent(options) {
 export function createInternalThoughtProcessEvent(options) {
     return {
         kind: 'internal:thought-process',
-        contextId: options.contextId,
-        taskId: options.taskId,
         iteration: options.iteration,
         stage: options.stage,
         reasoning: options.reasoning,
@@ -232,8 +202,6 @@ export function createInternalThoughtProcessEvent(options) {
 export function createInternalLLMCallEvent(options) {
     return {
         kind: 'internal:llm-call',
-        contextId: options.contextId,
-        taskId: options.taskId,
         iteration: options.iteration,
         messageCount: options.messageCount,
         toolCount: options.toolCount,
@@ -243,8 +211,6 @@ export function createInternalLLMCallEvent(options) {
 export function createInternalCheckpointEvent(options) {
     return {
         kind: 'internal:checkpoint',
-        contextId: options.contextId,
-        taskId: options.taskId,
         iteration: options.iteration,
         timestamp: new Date().toISOString(),
     };

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 export * from './core';
 export * from './events';
 export * from './observability';
+export * from './plugins';
 export * from './providers';
 export * from './server';
-export * from './skills';
 export * from './stores';
 export * from './tools';
 export * from './types';

package/dist/index.js

@@ -1,9 +1,9 @@
 export * from './core';
 export * from './events';
 export * from './observability';
+export * from './plugins';
 export * from './providers';
 export * from './server';
-export * from './skills';
 export * from './stores';
 export * from './tools';
 export * from './types';