@looopy-ai/core 2.1.20 → 2.1.22

package/dist/core/agent.js

@@ -174,6 +174,7 @@ export class Agent {
                         turnNumber,
                         metadata,
                     }, {
+                        filterPlugins: this.config.filterPlugins,
                         llmProvider: this.config.llmProvider,
                         maxIterations: 5,
                         stopOnToolError: false,

package/dist/core/iteration.d.ts

@@ -1,5 +1,5 @@
 import { type Observable } from 'rxjs';
-import type { IterationConfig, IterationContext } from '../types/core';
+import { type IterationConfig, type IterationContext } from '../types/core';
 import type { ContextAnyEvent } from '../types/event';
 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,5 +1,6 @@
 import { concat, defer, filter, map, mergeMap, shareReplay } from 'rxjs';
 import { startLLMCallSpan, startLoopIterationSpan } from '../observability/spans';
+import { isToolPlugin, } from '../types/core';
 import { getSystemPrompts } from '../utils/prompt';
 import { runToolCall } from './tools';
 export const runIteration = (context, config, history) => {
@@ -9,10 +10,18 @@ export const runIteration = (context, config, history) => {
     });
     const { traceContext: iterationContext, tapFinish: finishIterationSpan } = startLoopIterationSpan({ ...context, logger }, config.iterationNumber);
     const llmEvents$ = defer(async () => {
-        const systemPrompts = await getSystemPrompts(context.plugins, context);
+        const allowedPlugins = config.filterPlugins
+            ? config.filterPlugins(context.plugins, context)
+            : context.plugins;
+        const systemPrompts = await getSystemPrompts(allowedPlugins, 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');
+        const tools = await prepareTools(allowedPlugins);
+        logger.debug({
+            systemPrompts,
+            messages: messages.length,
+            plugins: allowedPlugins.map((p) => p.name).join(', '),
+            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);
@@ -59,8 +68,8 @@ const prepareMessages = async (systemPrompts, history) => {
         content: sp.content,
     })));
 };
-const prepareTools = async (toolProviders) => {
-    const toolPromises = toolProviders.map((p) => p.listTools?.());
+const prepareTools = async (plugins) => {
+    const toolPromises = plugins.filter(isToolPlugin).map((p) => p.listTools());
     const toolArrays = await Promise.all(toolPromises);
     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 { LLMMessage } from '../types/message';
-export declare const runLoop: <AuthContext>(context: LoopContext<AuthContext>, config: LoopConfig, history: LLMMessage[]) => import("rxjs").Observable<ContextAnyEvent>;
+export declare const runLoop: <AuthContext>(context: LoopContext<AuthContext>, config: LoopConfig<AuthContext>, history: LLMMessage[]) => import("rxjs").Observable<ContextAnyEvent>;

package/dist/core/loop.js

@@ -35,6 +35,7 @@ export const runLoop = (context, config, history) => {
     }, (state) => runIteration({ ...context, parentContext: loopContext }, {
         llmProvider: config.llmProvider,
         iterationNumber: state.iteration,
+        filterPlugins: config.filterPlugins,
     }, state.messages), (state, { events }) => ({
         ...state,
         messages: [...state.messages, ...eventsToMessages(events)],

package/dist/stores/messages/memory-message-store.js

@@ -26,10 +26,10 @@ export class InMemoryMessageStore {
         if (maxTokens) {
             messages = trimToTokenBudget(messages, maxTokens);
         }
-        return messages;
+        return messages.slice();
     }
     async getAll(contextId) {
-        return this.messages.get(contextId) || [];
+        return (this.messages.get(contextId) || []).slice();
     }
     async getCount(contextId) {
         const messages = this.messages.get(contextId) || [];

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

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import z from 'zod';
-import type { AnyEvent, ExecutionContext, Plugin } from '../types';
+import type { AnyEvent, ExecutionContext, ToolPlugin } from '../types';
 import type { ToolCall, ToolDefinition } from '../types/tools';
 export type HeaderFactory<AuthContext> = (context: ExecutionContext<AuthContext>, card: AgentCard) => Promise<Record<string, string | undefined>>;
 export declare const cardSchema: z.ZodObject<{
@@ -16,9 +16,10 @@ export declare const cardSchema: z.ZodObject<{
         token_endpoint: z.ZodString;
         scopes: z.ZodArray<z.ZodString>;
     }, z.core.$loose>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 export type AgentCard = z.infer<typeof cardSchema>;
-export declare class AgentToolProvider<AuthContext> implements Plugin<AuthContext> {
+export declare class AgentToolProvider<AuthContext> implements ToolPlugin<AuthContext> {
     readonly card: AgentCard;
     readonly getHeaders?: HeaderFactory<AuthContext> | undefined;
     static fromUrl: <AuthContext_1>(cardUrl: string, getHeaders?: HeaderFactory<AuthContext_1>) => Promise<AgentToolProvider<AuthContext_1>>;

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

@@ -22,6 +22,7 @@ export const cardSchema = z.object({
     })
         .loose()
         .optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
 });
 const safeName = (name) => name.replace(/[^a-zA-Z0-9-]+/g, '-').toLowerCase();
 export class AgentToolProvider {

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { ExecutionContext } from '../types/context';
-import type { Plugin } from '../types/core';
+import type { ToolPlugin } 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;
@@ -12,5 +12,5 @@ export interface LocalToolDefinition<TSchema extends z.ZodObject, AuthContext> {
     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>[]): Plugin<AuthContext>;
+export declare function localTools<AuthContext>(tools: LocalToolDefinition<z.ZodObject, AuthContext>[]): ToolPlugin<AuthContext>;
 export {};

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

@@ -1,4 +1,4 @@
-import type { Plugin } from '..';
+import type { ToolPlugin } from '..';
 import type { ExecutionContext } from '../types/context';
 import type { ToolCall, ToolDefinition } from '../types/tools';
 export interface MCPProviderConfig<AuthContext> {
@@ -8,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 Plugin<AuthContext> {
+export declare class McpToolProvider<AuthContext> implements ToolPlugin<AuthContext> {
     name: string;
     readonly id: string;
     private readonly client;

package/dist/types/agent.d.ts

@@ -1,11 +1,12 @@
 import type { MessageStore } from '../stores/messages';
 import type { SerializedError } from '../utils/error';
-import type { Plugin } from './core';
+import type { FilterPlugins, Plugin } from './core';
 import type { LLMProvider } from './llm';
 export interface AgentConfig<AuthContext> {
     agentId: string;
     contextId: string;
     llmProvider: LLMProvider;
+    filterPlugins?: FilterPlugins<AuthContext>;
     messageStore: MessageStore;
     agentStore?: AgentStore;
     autoCompact?: boolean;

package/dist/types/core.d.ts

@@ -3,6 +3,7 @@ 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 FilterPlugins<AuthContext> = (availablePlugins: readonly Plugin<AuthContext>[], context: IterationContext<AuthContext>) => readonly Plugin<AuthContext>[];
 export type AgentContext<AuthContext> = Readonly<{
     agentId: string;
     contextId: string;
@@ -18,25 +19,27 @@ export type TurnContext<AuthContext> = AgentContext<AuthContext> & Readonly<{
 }>;
 export type LoopContext<AuthContext> = TurnContext<AuthContext>;
 export type IterationContext<AuthContext> = TurnContext<AuthContext>;
-export type LoopConfig = {
+export type LoopConfig<AuthContext> = {
+    filterPlugins: FilterPlugins<AuthContext> | undefined;
     llmProvider: LLMProvider;
     maxIterations: number;
     stopOnToolError: boolean;
 };
 export type IterationConfig<AuthContext> = {
+    filterPlugins: FilterPlugins<AuthContext> | undefined;
     llmProvider: LLMProvider | ((context: LoopContext<AuthContext>, systemPromptMetadata: Record<string, unknown> | undefined) => LLMProvider);
     iterationNumber: number;
 };
-export type Plugin<AuthContext> = BasePlugin & Partial<SystemPromptPlugin<AuthContext>> & Partial<ToolPlugin<AuthContext>>;
+export type Plugin<AuthContext> = SystemPromptPlugin<AuthContext> | ToolPlugin<AuthContext>;
 type BasePlugin = {
     readonly name: string;
     readonly version?: string;
 };
-export type SystemPromptPlugin<AuthContext> = {
+export type SystemPromptPlugin<AuthContext> = BasePlugin & {
     generateSystemPrompts: (context: IterationContext<AuthContext>) => SystemPrompt[] | Promise<SystemPrompt[]>;
 };
 export declare const isSystemPromptPlugin: <AuthContext>(plugin: Plugin<AuthContext>) => plugin is BasePlugin & SystemPromptPlugin<AuthContext>;
-export type ToolPlugin<AuthContext> = {
+export type ToolPlugin<AuthContext> = BasePlugin & {
     listTools: () => Promise<ToolDefinition[]>;
     getTool: (toolId: string) => Promise<ToolDefinition | undefined>;
     executeTool: (toolCall: ToolCall, context: IterationContext<AuthContext>) => Observable<ContextAnyEvent | AnyEvent>;

package/dist/utils/prompt.d.ts

@@ -1,4 +1,4 @@
-import type { IterationContext, Plugin, SystemPrompt } from '../types/core';
+import { type IterationContext, type Plugin, type SystemPrompt } from '../types/core';
 export type SystemPrompts = {
     before: readonly SystemPrompt[];
     after: readonly SystemPrompt[];

package/dist/utils/prompt.js

@@ -1,8 +1,9 @@
+import { isSystemPromptPlugin, } from '../types/core';
 export const getSystemPrompts = async (plugins, loopContext) => {
     if (!plugins?.length) {
         return { before: [], after: [] };
     }
-    const prompts = await Promise.all(plugins.map((p) => p.generateSystemPrompts?.(loopContext)));
+    const prompts = await Promise.all(plugins.filter(isSystemPromptPlugin).map((p) => p.generateSystemPrompts?.(loopContext)));
     const flattened = prompts.flat().filter((p) => p !== undefined);
     const before = Object.freeze(flattened
         .filter((p) => p.position === 'before')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looopy-ai/core",
-  "version": "2.1.20",
+  "version": "2.1.22",
   "description": "RxJS-based AI agent framework",
   "repository": {
     "url": "https://github.com/looopy-ai/lib"
@@ -34,15 +34,15 @@
     "@opentelemetry/exporter-metrics-otlp-http": "^0.207.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.207.0",
     "@opentelemetry/instrumentation": "^0.207.0",
-    "@opentelemetry/resources": "^2.2.0",
-    "@opentelemetry/sdk-metrics": "^2.2.0",
-    "@opentelemetry/sdk-trace-base": "^2.2.0",
-    "@opentelemetry/sdk-trace-node": "^2.2.0",
-    "@opentelemetry/semantic-conventions": "^1.37.0",
+    "@opentelemetry/resources": "^2.4.0",
+    "@opentelemetry/sdk-metrics": "^2.4.0",
+    "@opentelemetry/sdk-trace-base": "^2.4.0",
+    "@opentelemetry/sdk-trace-node": "^2.4.0",
+    "@opentelemetry/semantic-conventions": "^1.39.0",
     "pino": "^9.14.0",
-    "pino-pretty": "^13.1.2",
+    "pino-pretty": "^13.1.3",
     "rxjs": "^7.8.2",
-    "zod": "^4.1.11"
+    "zod": "^4.3.5"
   },
   "publishConfig": {
     "access": "public"