@looopy-ai/core 2.1.19 → 2.1.21

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,7 +1,6 @@
 import { concat, defer, filter, map, mergeMap, shareReplay } from 'rxjs';
 import { startLLMCallSpan, startLoopIterationSpan } from '../observability/spans';
-import { toolErrorEvent } from '../tools/tool-result-events';
-import { safeValidateToolCall } from '../types/tools';
+import { isToolPlugin, } from '../types/core';
 import { getSystemPrompts } from '../utils/prompt';
 import { runToolCall } from './tools';
 export const runIteration = (context, config, history) => {
@@ -37,35 +36,7 @@ export const runIteration = (context, config, history) => {
             stream: true,
             sessionId: context.taskId,
         })
-            .pipe(finishLLMCallSpan, map((event) => {
-            if (event.kind === 'tool-call') {
-                const validation = safeValidateToolCall({
-                    id: event.toolCallId,
-                    type: 'function',
-                    function: {
-                        name: event.toolName,
-                        arguments: event.arguments,
-                    },
-                });
-                if (!validation.success) {
-                    const errorMessage = `Invalid tool call format: ${(validation.errors || []).map((e) => `${e.path.join('.')}: ${e.message}`).join(', ')}`;
-                    context.logger.error({
-                        toolCallId: event.toolCallId,
-                        toolName: event.toolName,
-                        errors: validation.errors,
-                    }, 'Invalid tool call from LLM - tool name must match ^[a-zA-Z0-9_-]+$');
-                    return toolErrorEvent({
-                        id: event.toolCallId,
-                        type: 'function',
-                        function: {
-                            name: event.toolName,
-                            arguments: event.arguments,
-                        },
-                    }, errorMessage);
-                }
-            }
-            return event;
-        }), map((event) => ({
+            .pipe(finishLLMCallSpan, map((event) => ({
             contextId: context.contextId,
             taskId: context.taskId,
             path: undefined,
@@ -89,8 +60,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/providers/litellm-provider.js

@@ -88,7 +88,7 @@ export class LiteLLMProvider {
                 id: tc.id,
                 type: 'function',
                 function: {
-                    name: tc.function?.name,
+                    name: fixToolFunctionName(tc.function?.name),
                     arguments: (typeof tc.function?.arguments === 'string'
                         ? JSON.parse(tc.function?.arguments)
                         : tc.function?.arguments) || {},
@@ -111,7 +111,7 @@ export class LiteLLMProvider {
         const toolCalls$ = contentComplete$.pipe(filter((event) => event.finishReason === 'tool_calls'), mergeMap((event) => event.toolCalls?.map((tc) => ({
             kind: 'tool-call',
             toolCallId: tc.id,
-            toolName: tc.function.name,
+            toolName: fixToolFunctionName(tc.function.name),
             arguments: tc.function.arguments,
             timestamp: event.timestamp,
         })) || []));
@@ -191,7 +191,7 @@ export class LiteLLMProvider {
                             id: tc.id,
                             type: tc.type,
                             function: {
-                                name: tc.function.name,
+                                name: fixToolFunctionName(tc.function.name),
                                 arguments: typeof tc.function.arguments === 'string'
                                     ? tc.function.arguments
                                     : JSON.stringify(tc.function.arguments),
@@ -216,7 +216,7 @@ export class LiteLLMProvider {
                 litellmRequest.tools = request.tools.map((tool) => ({
                     type: 'function',
                     function: {
-                        name: getValidToolName(tool.id),
+                        name: fixToolFunctionName(tool.id),
                         description: tool.description,
                         parameters: tool.parameters,
                     },
@@ -378,7 +378,7 @@ export const LiteLLM = {
         });
     },
 };
-const getValidToolName = (toolId) => {
+const fixToolFunctionName = (toolId) => {
     const match = toolId.match(/^[a-zA-Z0-9_-]+/);
     return match ? match[0] : 'invalid_tool_name';
 };

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<{
@@ -18,7 +18,7 @@ export declare const cardSchema: z.ZodObject<{
     }, z.core.$loose>>;
 }, 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/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/core.d.ts

@@ -27,16 +27,16 @@ 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>>;
+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.19",
+  "version": "2.1.21",
   "description": "RxJS-based AI agent framework",
   "repository": {
     "url": "https://github.com/looopy-ai/lib"