@looopy-ai/core 2.1.8 → 2.1.11

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@looopy-ai/core",
-  "version": "2.1.8",
+  "version": "2.1.11",
   "description": "RxJS-based AI agent framework",
+  "repository": {
+    "url": "https://github.com/looopy-ai/lib"
+  },
   "keywords": [
     "agent",
     "ai",
@@ -18,8 +21,7 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
-    "./package.json": "./package.json",
-    "./ts": "./src/index.ts"
+    "./package.json": "./package.json"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/core/types.d.ts

@@ -1,31 +0,0 @@
-import type pino from 'pino';
-import type { SkillRegistry } from '../skills';
-import type { LLMProvider } from '../types/llm';
-import type { ToolProvider } from '../types/tools';
-import type { SystemPromptProp } from '../utils';
-export type AgentContext<AuthContext> = {
-    agentId: string;
-    contextId: string;
-    parentContext: import('@opentelemetry/api').Context;
-    authContext?: AuthContext;
-    toolProviders: ToolProvider<AuthContext>[];
-    logger: pino.Logger;
-    systemPrompt?: SystemPromptProp;
-    skillRegistry?: SkillRegistry;
-    metadata?: Record<string, unknown>;
-};
-export type TurnContext<AuthContext> = AgentContext<AuthContext> & {
-    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 = {
-    llmProvider: LLMProvider;
-    iterationNumber: number;
-};

package/dist/skills/index.d.ts

@@ -1 +0,0 @@
-export * from './registry';

package/dist/skills/index.js

@@ -1 +0,0 @@
-export * from './registry';

package/dist/skills/registry.d.ts

@@ -1,14 +0,0 @@
-import z from 'zod';
-import type { Skill } from '../types';
-export declare const learnSkillToolName = "learn_skill";
-export declare const skill: (definition: Skill) => Skill;
-export declare class SkillRegistry {
-    private skills;
-    constructor(skills?: Skill[]);
-    register(skill: Skill): void;
-    get(name: string): Skill | undefined;
-    list(): Skill[];
-    tool(): import("..").LocalToolDefinition<z.ZodObject<{
-        name: z.ZodString;
-    }, z.core.$strip>, unknown>;
-}

package/dist/skills/registry.js

@@ -1,61 +0,0 @@
-import z from 'zod';
-import { tool } from '../tools/local-tools';
-export const learnSkillToolName = 'learn_skill';
-const getInstruction = async (instruction) => {
-    if (typeof instruction === 'string') {
-        return instruction;
-    }
-    return await instruction();
-};
-export const skill = (definition) => {
-    return { ...definition };
-};
-export class SkillRegistry {
-    skills = {};
-    constructor(skills = []) {
-        skills.forEach((skill) => {
-            this.skills[skill.name] = skill;
-        });
-    }
-    register(skill) {
-        this.skills[skill.name] = skill;
-    }
-    get(name) {
-        return this.skills[name];
-    }
-    list() {
-        return Object.values(this.skills);
-    }
-    tool() {
-        return tool({
-            name: learnSkillToolName,
-            icon: 'lucide:graduation-cap',
-            description: 'Learns a new skill from the available skill registry.',
-            schema: z.object({
-                name: z.string().describe('The name of the skill to learn.'),
-            }),
-            handler: async ({ name }) => {
-                const foundSkill = this.get(name);
-                if (!foundSkill) {
-                    const availableSkills = this.list()
-                        .map((s) => `'${s.name}'`)
-                        .join(', ');
-                    return {
-                        success: false,
-                        result: null,
-                        error: `Skill '${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 {
-                    success: true,
-                    result: `Successfully learned the '${name}' skill.`,
-                    messages: [systemMessage],
-                };
-            },
-        });
-    }
-}

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

@@ -1,25 +0,0 @@
-import type { ExecutionContext } from '../types/context';
-import { type ToolCall, type ToolDefinition, type ToolProvider, type ToolResult } from '../types/tools';
-export interface ClientToolConfig<AuthContext> {
-    tools: unknown;
-    onInputRequired: (toolCall: ToolCall, context: ExecutionContext<AuthContext>) => Promise<ToolResult>;
-}
-export declare class ClientToolProvider<AuthContext> implements ToolProvider<AuthContext> {
-    name: string;
-    private readonly tools;
-    private readonly toolNames;
-    private readonly onInputRequired;
-    constructor(config: ClientToolConfig<AuthContext>);
-    getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext<AuthContext>): import("rxjs").Observable<import("..").ContextAnyEvent | import("..").ContextEvent<import("..").ToolCompleteEvent>>;
-    getTool(name: string): Promise<ToolDefinition | undefined>;
-    validateToolArguments(toolCall: ToolCall): Promise<{
-        valid: boolean;
-        errors?: string[];
-    }>;
-    private validateRequiredParams;
-    private validateUnknownParams;
-    private validateParamTypes;
-    private checkParamType;
-    private getJsonSchemaType;
-}

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

@@ -1,143 +0,0 @@
-import { catchError, defer, mergeMap, of } from 'rxjs';
-import { validateToolDefinitions, } from '../types/tools';
-import { toolErrorEvent, toolResultToEvents } from './tool-result-events';
-export class ClientToolProvider {
-    name = 'client-tool-provider';
-    tools;
-    toolNames;
-    onInputRequired;
-    constructor(config) {
-        try {
-            this.tools = validateToolDefinitions(config.tools);
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                throw new Error(`Invalid client tool definitions: ${error.message}`);
-            }
-            throw error;
-        }
-        this.toolNames = new Set(this.tools.map((t) => t.name));
-        if (this.toolNames.size !== this.tools.length) {
-            const names = this.tools.map((t) => t.name);
-            const duplicates = names.filter((name, index) => names.indexOf(name) !== index);
-            throw new Error(`Duplicate tool names: ${duplicates.join(', ')}`);
-        }
-        this.onInputRequired = config.onInputRequired;
-    }
-    async getTools() {
-        return [...this.tools];
-    }
-    execute(toolCall, context) {
-        return defer(async () => {
-            const tool = await this.getTool(toolCall.function.name);
-            if (!tool) {
-                return {
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.function.name,
-                    success: false,
-                    result: null,
-                    error: `Tool ${toolCall.function.name} not found in client tools`,
-                };
-            }
-            try {
-                if (typeof toolCall.function.arguments !== 'object' ||
-                    toolCall.function.arguments === null) {
-                    return {
-                        toolCallId: toolCall.id,
-                        toolName: toolCall.function.name,
-                        success: false,
-                        result: null,
-                        error: `Invalid tool arguments: must be an object.`,
-                    };
-                }
-                const result = await this.onInputRequired(toolCall, context);
-                return result;
-            }
-            catch (error) {
-                return {
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.function.name,
-                    success: false,
-                    result: null,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-            }
-        }).pipe(mergeMap((result) => toolResultToEvents(context, toolCall, result)), catchError((error) => of(toolErrorEvent(context, toolCall, error instanceof Error ? error.message : String(error)))));
-    }
-    async getTool(name) {
-        return this.tools.find((t) => t.name === name);
-    }
-    async validateToolArguments(toolCall) {
-        const tool = await this.getTool(toolCall.function.name);
-        if (!tool) {
-            return { valid: false, errors: [`Tool ${toolCall.function.name} not found`] };
-        }
-        if (typeof toolCall.function.arguments !== 'object' || toolCall.function.arguments === null) {
-            return {
-                valid: false,
-                errors: ['Arguments are not valid: must be an object.'],
-            };
-        }
-        const args = toolCall.function.arguments;
-        const errors = [];
-        this.validateRequiredParams(tool, args, errors);
-        this.validateUnknownParams(tool, args, errors);
-        this.validateParamTypes(tool, args, errors);
-        return errors.length > 0 ? { valid: false, errors } : { valid: true };
-    }
-    validateRequiredParams(tool, args, errors) {
-        const required = tool.parameters.required || [];
-        for (const param of required) {
-            if (!(param in args)) {
-                errors.push(`Missing required parameter: ${param}`);
-            }
-        }
-    }
-    validateUnknownParams(tool, args, errors) {
-        if (tool.parameters.additionalProperties === false) {
-            const allowedParams = new Set(Object.keys(tool.parameters.properties));
-            for (const param of Object.keys(args)) {
-                if (!allowedParams.has(param)) {
-                    errors.push(`Unknown parameter: ${param}`);
-                }
-            }
-        }
-    }
-    validateParamTypes(tool, args, errors) {
-        for (const [paramName, paramValue] of Object.entries(args)) {
-            const schema = tool.parameters.properties[paramName];
-            if (!schema)
-                continue;
-            const type = schema.type;
-            if (!type)
-                continue;
-            const typeError = this.checkParamType(paramName, paramValue, type);
-            if (typeError) {
-                errors.push(typeError);
-            }
-        }
-    }
-    checkParamType(paramName, paramValue, expectedType) {
-        const actualType = this.getJsonSchemaType(paramValue);
-        if (expectedType === 'integer') {
-            if (actualType !== 'number') {
-                return `Parameter ${paramName} has wrong type: expected integer, got ${actualType}`;
-            }
-            if (!Number.isInteger(paramValue)) {
-                return `Parameter ${paramName} must be an integer, got: ${paramValue}`;
-            }
-            return null;
-        }
-        if (actualType !== expectedType) {
-            return `Parameter ${paramName} has wrong type: expected ${expectedType}, got ${actualType}`;
-        }
-        return null;
-    }
-    getJsonSchemaType(value) {
-        if (Array.isArray(value))
-            return 'array';
-        if (value === null)
-            return 'null';
-        return typeof value;
-    }
-}