@looopy-ai/core 2.1.9 → 2.1.12

package/dist/tools/artifact-tools.js

@@ -14,7 +14,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
     const scheduledStore = new ArtifactScheduler(artifactStore);
     return localTools([
         tool({
-            name: 'create_file_artifact',
+            id: 'create_file_artifact',
             description: 'Create a new file artifact for streaming text or binary content. Use append_file_chunk to add content. Set override=true to replace existing artifact.',
             schema: z.object({
                 artifactId: z
@@ -64,7 +64,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'append_file_chunk',
+            id: 'append_file_chunk',
             description: 'Append a chunk of content to a file artifact. Call multiple times to stream content.',
             schema: z.object({
                 artifactId: z.string().describe('The artifact ID to append to'),
@@ -93,7 +93,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'get_file_content',
+            id: 'get_file_content',
             description: 'Get the complete content of a file artifact',
             schema: z.object({
                 artifactId: z.string().describe('The artifact ID to retrieve'),
@@ -110,7 +110,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'create_data_artifact',
+            id: 'create_data_artifact',
             description: 'Create a data artifact with structured JSON data. Set override=true to replace existing artifact.',
             schema: z.object({
                 artifactId: z.string().describe('Unique identifier for the artifact'),
@@ -148,7 +148,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'update_data_artifact',
+            id: 'update_data_artifact',
             description: 'Update the data content of an existing data artifact',
             schema: z.object({
                 artifactId: z.string().describe('The artifact ID to update'),
@@ -168,7 +168,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'get_data_content',
+            id: 'get_data_content',
             description: 'Get the content of a data artifact',
             schema: z.object({
                 artifactId: z.string().describe('The artifact ID to retrieve'),
@@ -185,7 +185,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'get_data_artifact',
+            id: 'get_data_artifact',
             description: 'Get the data content of a data artifact',
             schema: z.object({
                 artifactId: z.string().describe('The artifact ID to retrieve'),
@@ -202,7 +202,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'create_dataset_artifact',
+            id: 'create_dataset_artifact',
             description: 'Create a dataset artifact for tabular data with a schema. Set override=true to replace existing artifact.',
             schema: z.object({
                 artifactId: z.string().describe('Unique identifier for the dataset'),
@@ -246,7 +246,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'append_dataset_row',
+            id: 'append_dataset_row',
             description: 'Append a single row to a dataset artifact',
             schema: z.object({
                 artifactId: z.string().describe('The dataset artifact ID'),
@@ -265,7 +265,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'append_dataset_rows',
+            id: 'append_dataset_rows',
             description: 'Append multiple rows to a dataset artifact',
             schema: z.object({
                 artifactId: z.string().describe('The dataset artifact ID'),
@@ -287,7 +287,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'get_dataset_rows',
+            id: 'get_dataset_rows',
             description: 'Get all rows from a dataset artifact',
             schema: z.object({
                 artifactId: z.string().describe('The dataset artifact ID'),
@@ -305,7 +305,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'list_artifacts',
+            id: 'list_artifacts',
             description: 'List all artifacts in the current context, optionally filtered by task',
             schema: z.object({
                 taskId: z.string().optional().describe('Filter artifacts by task ID'),
@@ -331,7 +331,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'get_artifact',
+            id: 'get_artifact',
             description: 'Get metadata for a specific artifact by ID',
             schema: z.object({
                 artifactId: z.string().describe('The artifact ID to retrieve'),
@@ -368,7 +368,7 @@ export function createArtifactTools(artifactStore, taskStateStore) {
             },
         }),
         tool({
-            name: 'delete_artifact',
+            id: 'delete_artifact',
             description: 'Delete an artifact by ID',
             schema: z.object({
                 artifactId: z.string().describe('The artifact ID to delete'),

package/dist/tools/index.d.ts

@@ -1,6 +1,5 @@
 export * from './agent-tool-provider';
 export * from './artifact-tools';
-export * from './client-tool-provider';
 export * from './local-tools';
 export * from './mcp-tool-provider';
 export * from './tool-result-events';

package/dist/tools/index.js

@@ -1,6 +1,5 @@
 export * from './agent-tool-provider';
 export * from './artifact-tools';
-export * from './client-tool-provider';
 export * from './local-tools';
 export * from './mcp-tool-provider';
 export * from './tool-result-events';

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

@@ -1,15 +1,16 @@
 import { z } from 'zod';
 import type { ExecutionContext } from '../types/context';
-import type { ToolProvider, ToolResult } from '../types/tools';
+import type { Plugin } from '../types/core';
+import type { ToolResult } from '../types/tools';
 type InternalToolResult = Omit<ToolResult, 'toolCallId' | 'toolName'>;
 export type ToolHandler<TParams, AuthContext> = (params: TParams, context: ExecutionContext<AuthContext>) => Promise<InternalToolResult> | InternalToolResult;
 export interface LocalToolDefinition<TSchema extends z.ZodObject, AuthContext> {
-    name: string;
+    id: string;
     description: string;
     icon?: string;
     schema: TSchema;
     handler: ToolHandler<z.infer<TSchema>, AuthContext>;
 }
 export declare function tool<TSchema extends z.ZodObject, AuthContext>(definition: LocalToolDefinition<TSchema, AuthContext>): LocalToolDefinition<TSchema, AuthContext>;
-export declare function localTools<AuthContext>(tools: LocalToolDefinition<z.ZodObject, AuthContext>[]): ToolProvider<AuthContext>;
+export declare function localTools<AuthContext>(tools: LocalToolDefinition<z.ZodObject, AuthContext>[]): Plugin<AuthContext>;
 export {};

package/dist/tools/local-tools.js

@@ -15,15 +15,15 @@ const zodToJsonSchema = (schema) => {
 export function localTools(tools) {
     const toolMap = new Map();
     for (const tool of tools) {
-        if (toolMap.has(tool.name)) {
-            throw new Error(`Duplicate tool name: ${tool.name}`);
+        if (toolMap.has(tool.id)) {
+            throw new Error(`Duplicate tool name: ${tool.id}`);
         }
-        toolMap.set(tool.name, tool);
+        toolMap.set(tool.id, tool);
     }
     return {
         name: 'local-tool-provider',
-        getTools: async () => tools.map((t) => ({
-            name: t.name,
+        listTools: async () => tools.map((t) => ({
+            id: t.id,
             description: t.description,
             icon: t.icon,
             parameters: zodToJsonSchema(t.schema),
@@ -34,13 +34,13 @@ export function localTools(tools) {
                 return undefined;
             }
             return {
-                name: toolDef.name,
+                id: toolDef.id,
                 description: toolDef.description,
                 icon: toolDef.icon,
                 parameters: zodToJsonSchema(toolDef.schema),
             };
         },
-        execute: (toolCall, context) => defer(async () => {
+        executeTool: (toolCall, context) => defer(async () => {
             const toolDef = toolMap.get(toolCall.function.name);
             if (!toolDef) {
                 return {
@@ -82,6 +82,6 @@ export function localTools(tools) {
                     error: err.message,
                 };
             }
-        }).pipe(mergeMap((result) => toolResultToEvents(context, toolCall, result)), catchError((error) => of(toolErrorEvent(context, toolCall, error instanceof Error ? error.message : String(error))))),
+        }).pipe(mergeMap((result) => toolResultToEvents(result)), catchError((error) => of(toolErrorEvent(toolCall, error instanceof Error ? error.message : String(error))))),
     };
 }

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

@@ -1,5 +1,6 @@
+import type { Plugin } from '..';
 import type { ExecutionContext } from '../types/context';
-import type { ToolCall, ToolDefinition, ToolProvider } from '../types/tools';
+import type { ToolCall, ToolDefinition } from '../types/tools';
 export interface MCPProviderConfig<AuthContext> {
     serverId: string;
     serverUrl: string;
@@ -7,7 +8,7 @@ export interface MCPProviderConfig<AuthContext> {
     getHeaders: (authContext?: AuthContext) => Record<string, string>;
 }
 export declare const mcp: <AuthContext>(config: MCPProviderConfig<AuthContext>) => McpToolProvider<AuthContext>;
-export declare class McpToolProvider<AuthContext> implements ToolProvider<AuthContext> {
+export declare class McpToolProvider<AuthContext> implements Plugin<AuthContext> {
     name: string;
     readonly id: string;
     private readonly client;
@@ -17,7 +18,7 @@ export declare class McpToolProvider<AuthContext> implements ToolProvider<AuthCo
     private ongoingRequest;
     constructor(config: MCPProviderConfig<AuthContext>);
     getTool(toolName: string): Promise<ToolDefinition | undefined>;
-    getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext<AuthContext>): import("rxjs").Observable<import("..").ContextAnyEvent | import("..").ContextEvent<import("..").ToolCompleteEvent>>;
+    listTools(): Promise<ToolDefinition[]>;
+    executeTool(toolCall: ToolCall, context: ExecutionContext<AuthContext>): import("rxjs").Observable<import("..").AnyEvent>;
     private convertMCPTool;
 }

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

@@ -21,10 +21,10 @@ export class McpToolProvider {
         });
     }
     async getTool(toolName) {
-        const tools = await this.getTools();
-        return tools.find((tool) => tool.name === toolName);
+        const tools = await this.listTools();
+        return tools.find((tool) => tool.id === toolName);
     }
-    async getTools() {
+    async listTools() {
         if (this.toolCache.size > 0 && this.cacheExpiry && Date.now() < this.cacheExpiry) {
             return Array.from(this.toolCache.values());
         }
@@ -37,7 +37,7 @@ export class McpToolProvider {
             const toolDefs = tools.map(this.convertMCPTool);
             this.toolCache.clear();
             for (const tool of toolDefs) {
-                this.toolCache.set(tool.name, tool);
+                this.toolCache.set(tool.id, tool);
             }
             this.cacheExpiry = Date.now() + this.cacheTTL;
             return toolDefs;
@@ -47,7 +47,7 @@ export class McpToolProvider {
         });
         return this.ongoingRequest;
     }
-    execute(toolCall, context) {
+    executeTool(toolCall, context) {
         return defer(async () => {
             const { name, arguments: args } = toolCall.function;
             if (typeof args !== 'object' || args === null) {
@@ -80,11 +80,11 @@ export class McpToolProvider {
                     result: null,
                 };
             }
-        }).pipe(mergeMap((result) => toolResultToEvents(context, toolCall, result)), catchError((error) => of(toolErrorEvent(context, toolCall, error instanceof Error ? error.message : String(error)))));
+        }).pipe(mergeMap((result) => toolResultToEvents(result)), catchError((error) => of(toolErrorEvent(toolCall, error instanceof Error ? error.message : String(error)))));
     }
     convertMCPTool = (mcpTool) => {
         return {
-            name: mcpTool.name,
+            id: mcpTool.name,
             description: mcpTool.description,
             parameters: mcpTool.inputSchema,
         };

package/dist/tools/tool-result-events.d.ts

@@ -1,6 +1,5 @@
 import { type Observable } from 'rxjs';
-import type { ExecutionContext } from '../types/context';
-import type { ContextAnyEvent, ContextEvent, ToolCompleteEvent } from '../types/event';
+import type { AnyEvent, ToolCompleteEvent } from '../types/event';
 import type { ToolCall, ToolResult } from '../types/tools';
-export declare const toolErrorEvent: <AuthContext>(context: ExecutionContext<AuthContext>, toolCall: ToolCall, errorMessage: string) => ContextEvent<ToolCompleteEvent>;
-export declare const toolResultToEvents: <AuthContext>(context: ExecutionContext<AuthContext>, _toolCall: ToolCall, result: ToolResult) => Observable<ContextAnyEvent>;
+export declare const toolErrorEvent: (toolCall: ToolCall, errorMessage: string) => ToolCompleteEvent;
+export declare const toolResultToEvents: (result: ToolResult) => Observable<AnyEvent>;

package/dist/tools/tool-result-events.js

@@ -1,8 +1,6 @@
 import { concat, EMPTY, from, of } from 'rxjs';
-export const toolErrorEvent = (context, toolCall, errorMessage) => ({
+export const toolErrorEvent = (toolCall, errorMessage) => ({
     kind: 'tool-complete',
-    contextId: context.contextId,
-    taskId: context.taskId,
     toolCallId: toolCall.id,
     toolName: toolCall.function.name,
     success: false,
@@ -10,11 +8,9 @@ export const toolErrorEvent = (context, toolCall, errorMessage) => ({
     error: errorMessage,
     timestamp: new Date().toISOString(),
 });
-export const toolResultToEvents = (context, _toolCall, result) => {
+export const toolResultToEvents = (result) => {
     const toolCompleteEvent = {
         kind: 'tool-complete',
-        contextId: context.contextId,
-        taskId: context.taskId,
         toolCallId: result.toolCallId,
         toolName: result.toolName,
         success: result.success,
@@ -24,8 +20,6 @@ export const toolResultToEvents = (context, _toolCall, result) => {
     };
     const messageEvents = result.messages?.map((message) => ({
         kind: 'internal:tool-message',
-        contextId: context.contextId,
-        taskId: context.taskId,
         message,
         timestamp: new Date().toISOString(),
     })) ?? [];

package/dist/types/a2a.d.ts

@@ -1,8 +1,8 @@
-import type { Message } from './message';
+import type { LLMMessage } from './message';
 export type A2ATaskState = 'submitted' | 'working' | 'input-required' | 'completed' | 'canceled' | 'failed' | 'rejected' | 'auth-required' | 'unknown';
 export interface A2ATaskStatus {
     state: A2ATaskState;
-    message?: Message;
+    message?: LLMMessage;
     timestamp?: string;
 }
 export type A2APart = A2ATextPart | A2AFilePart | A2ADataPart;

package/dist/types/agent.d.ts

@@ -1,6 +1,20 @@
+import type { MessageStore } from '../stores/messages';
 import type { SerializedError } from '../utils/error';
+import type { Plugin } from './core';
+import type { LLMProvider } from './llm';
+export interface AgentConfig<AuthContext> {
+    agentId: string;
+    contextId: string;
+    llmProvider: LLMProvider;
+    messageStore: MessageStore;
+    agentStore?: AgentStore;
+    autoCompact?: boolean;
+    maxMessages?: number;
+    plugins?: Plugin<AuthContext>[];
+    logger?: import('pino').Logger;
+}
 export interface AgentState {
-    status: 'created' | 'ready' | 'busy' | 'shutdown' | 'error';
+    status: 'created' | 'idle' | 'busy' | 'shutdown' | 'error';
     turnCount: number;
     lastActivity: Date;
     createdAt: Date;

package/dist/types/core.d.ts

@@ -0,0 +1,56 @@
+import type pino from 'pino';
+import type { Observable } from 'rxjs';
+import type { LLMProvider } from '../types/llm';
+import type { AnyEvent, ContextAnyEvent } from './event';
+import type { ToolCall, ToolDefinition } from './tools';
+export type AgentContext<AuthContext> = Readonly<{
+    agentId: string;
+    contextId: string;
+    parentContext: import('@opentelemetry/api').Context;
+    authContext?: AuthContext;
+    logger: pino.Logger;
+    plugins: readonly Plugin<AuthContext>[];
+    metadata?: Record<string, unknown>;
+}>;
+export type TurnContext<AuthContext> = AgentContext<AuthContext> & Readonly<{
+    taskId: string;
+    turnNumber: number;
+}>;
+export type LoopContext<AuthContext> = TurnContext<AuthContext>;
+export type IterationContext<AuthContext> = TurnContext<AuthContext>;
+export type LoopConfig = {
+    llmProvider: LLMProvider;
+    maxIterations: number;
+    stopOnToolError: boolean;
+};
+export type IterationConfig<AuthContext> = {
+    llmProvider: LLMProvider | ((context: LoopContext<AuthContext>, systemPromptMetadata: Record<string, unknown> | undefined) => LLMProvider);
+    iterationNumber: number;
+};
+export type Plugin<AuthContext> = BasePlugin & Partial<SystemPromptPlugin<AuthContext>> & Partial<ToolPlugin<AuthContext>>;
+type BasePlugin = {
+    readonly name: string;
+    readonly version?: string;
+};
+export type SystemPromptPlugin<AuthContext> = {
+    generateSystemPrompts: (context: IterationContext<AuthContext>) => SystemPrompt[] | Promise<SystemPrompt[]>;
+};
+export declare const isSystemPromptPlugin: <AuthContext>(plugin: Plugin<AuthContext>) => plugin is BasePlugin & SystemPromptPlugin<AuthContext>;
+export type ToolPlugin<AuthContext> = {
+    listTools: () => Promise<ToolDefinition[]>;
+    getTool: (toolId: string) => Promise<ToolDefinition | undefined>;
+    executeTool: (toolCall: ToolCall, context: IterationContext<AuthContext>) => Observable<ContextAnyEvent | AnyEvent>;
+};
+export declare const isToolPlugin: <AuthContext>(plugin: Plugin<AuthContext>) => plugin is BasePlugin & ToolPlugin<AuthContext>;
+export type SystemPrompt = {
+    content: string;
+    position: 'before' | 'after';
+    positionSequence?: number;
+    metadata?: Record<string, unknown>;
+    source?: {
+        providerName: string;
+        promptName: string;
+        promptVersion?: number;
+    };
+};
+export {};

package/dist/types/core.js

@@ -0,0 +1,8 @@
+export const isSystemPromptPlugin = (plugin) => {
+    return typeof plugin.generateSystemPrompts === 'function';
+};
+export const isToolPlugin = (plugin) => {
+    return (typeof plugin.listTools === 'function' &&
+        typeof plugin.getTool === 'function' &&
+        typeof plugin.executeTool === 'function');
+};

package/dist/types/event.d.ts

@@ -1,12 +1,12 @@
-import type { Message, SystemMessage } from './message';
+import type { LLMMessage, SystemLLMMessage } 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';
 export type ThoughtType = 'analysis' | 'planning' | 'reasoning' | 'reflection' | 'thinking' | 'decision' | 'observation' | 'strategy';
-export type InputType = 'tool-execution' | 'confirmation' | 'clarification' | 'selection' | 'custom';
+export type InputType = 'confirmation' | 'clarification' | 'selection' | 'data';
 export type AuthType = 'oauth2' | 'api-key' | 'password' | 'biometric' | 'custom';
 export type TaskInitiator = 'user' | 'agent';
-export type InputProvider = 'user' | 'agent';
+export type InputProvider = 'user' | 'any';
 export interface JSONSchema {
     type?: string;
     properties?: Record<string, JSONSchema>;
@@ -269,7 +269,7 @@ export interface InternalLLMCallEvent {
 }
 export interface InternalToolMessageEvent {
     kind: 'internal:tool-message';
-    message: SystemMessage;
+    message: SystemLLMMessage;
     timestamp: string;
 }
 export interface InternalCheckpointEvent {
@@ -307,13 +307,14 @@ export interface LLMUsageEvent {
 export type UsageEvent = LLMUsageEvent;
 export interface MessageEvent {
     kind: 'message';
-    message: Message;
+    message: LLMMessage;
     timestamp: string;
 }
 export type AnyEvent = TaskLifecycleEvent | ContentStreamingEvent | ToolExecutionEvent | InputRequestEvent | AuthenticationEvent | ArtifactEvent | SubAgentEvent | ThoughtStreamEvent | InternalDebugEvent | UsageEvent | MessageEvent;
 export type ContextEvent<T> = T & {
     contextId: string;
     taskId: string;
+    path?: string[];
 };
 export type ChildTaskEvent<T> = T & {
     parentTaskId: string;

package/dist/types/index.d.ts

@@ -2,9 +2,11 @@ export * from './a2a';
 export * from './agent';
 export * from './artifact';
 export * from './context';
+export * from './core';
 export * from './event';
 export * from './llm';
 export * from './message';
+export * from './prettify';
 export * from './skills';
 export * from './state';
 export * from './tools';

package/dist/types/index.js

@@ -2,9 +2,11 @@ export * from './a2a';
 export * from './agent';
 export * from './artifact';
 export * from './context';
+export * from './core';
 export * from './event';
 export * from './llm';
 export * from './message';
+export * from './prettify';
 export * from './skills';
 export * from './state';
 export * from './tools';

package/dist/types/llm.d.ts

@@ -1,17 +1,17 @@
 import type { Observable } from 'rxjs';
 import type { AnyEvent } from './event';
-import type { Message } from './message';
+import type { LLMMessage } from './message';
 import type { ToolCall, ToolDefinition } from './tools';
 export interface LLMProvider {
     call(request: {
-        messages: Message[];
+        messages: LLMMessage[];
         tools?: ToolDefinition[];
         stream?: boolean;
         sessionId?: string;
     }): Observable<AnyEvent>;
 }
 export interface LLMResponse {
-    message: Message;
+    message: LLMMessage;
     toolCalls?: ToolCall[];
     finished: boolean;
     finishReason?: 'stop' | 'length' | 'tool_calls' | 'content_filter';

package/dist/types/message.d.ts

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

package/dist/types/prettify.d.ts

@@ -0,0 +1,3 @@
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/state.d.ts

@@ -1,12 +1,12 @@
 import type { LLMResponse } from './llm';
-import type { Message } from './message';
+import type { LLMMessage } from './message';
 import type { ToolCall, ToolDefinition, ToolResult } from './tools';
 export interface PersistedLoopState {
     taskId: string;
     agentId: string;
     parentTaskId?: string;
     contextId: string;
-    messages: Message[];
+    messages: LLMMessage[];
     systemPrompt: string;
     iteration: number;
     completed: boolean;

package/dist/types/tools.d.ts

@@ -1,8 +1,5 @@
-import type { Observable } from 'rxjs';
 import { z } from 'zod';
-import type { ExecutionContext } from './context';
-import type { ContextAnyEvent } from './event';
-import type { SystemMessage } from './message';
+import type { SystemLLMMessage } from './message';
 export interface ToolCall {
     id: string;
     type: 'function';
@@ -17,7 +14,7 @@ export interface ToolResult {
     success: boolean;
     result: unknown;
     error?: string;
-    messages?: SystemMessage[];
+    messages?: SystemLLMMessage[];
 }
 export declare const JsonSchemaPropertySchema: z.ZodType<unknown>;
 export type JsonSchemaProperty = z.infer<typeof JsonSchemaPropertySchema>;
@@ -29,7 +26,7 @@ export declare const FunctionParametersSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type FunctionParameters = z.infer<typeof FunctionParametersSchema>;
 export declare const ToolDefinitionSchema: z.ZodObject<{
-    name: z.ZodString;
+    id: z.ZodString;
     description: z.ZodString;
     icon: z.ZodOptional<z.ZodString>;
     parameters: z.ZodObject<{
@@ -54,9 +51,3 @@ export declare const ToolCallSchema: z.ZodObject<{
         arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export type ToolProvider<AuthContext> = {
-    get name(): string;
-    getTool(toolName: string): Promise<ToolDefinition | undefined>;
-    getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext<AuthContext>): Observable<ContextAnyEvent>;
-};

package/dist/types/tools.js

@@ -25,11 +25,11 @@ export const FunctionParametersSchema = z.object({
     additionalProperties: z.boolean().optional(),
 });
 export const ToolDefinitionSchema = z.object({
-    name: z
+    id: z
         .string()
         .min(1)
         .max(64)
-        .regex(/^[a-zA-Z0-9_-]+$/, 'Tool name must contain only alphanumeric characters, underscores, and hyphens'),
+        .regex(/^[a-zA-Z0-9_-]+$/, 'Tool ID must contain only alphanumeric characters, underscores, and hyphens'),
     description: z.string().min(1).max(1024),
     icon: z.string().optional(),
     parameters: FunctionParametersSchema,

package/dist/utils/prompt.d.ts

@@ -1,9 +1,6 @@
-import type { LoopContext } from '../core/types';
-export type SystemPrompt = {
-    prompt: string;
-    name?: string;
-    version?: number;
-    metadata?: Record<string, unknown>;
+import type { IterationContext, Plugin, SystemPrompt } from '../types/core';
+export type SystemPrompts = {
+    before: readonly SystemPrompt[];
+    after: readonly SystemPrompt[];
 };
-export type SystemPromptProp<AuthContext> = string | SystemPrompt | ((loopContext: LoopContext<AuthContext>) => Promise<SystemPrompt> | SystemPrompt);
-export declare const getSystemPrompt: <AuthContext>(systemPrompt: SystemPromptProp<AuthContext> | undefined, loopContext: LoopContext<AuthContext>) => Promise<SystemPrompt | undefined>;
+export declare const getSystemPrompts: <AuthContext>(plugins: readonly Plugin<AuthContext>[] | undefined, loopContext: IterationContext<AuthContext>) => Promise<SystemPrompts>;