@looopy-ai/core 1.2.0 → 2.0.0

package/dist/server/sse.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEvent } from '../types/event';
+import type { ContextAnyEvent } from '../types/event';
 import { EventBuffer, type EventBufferConfig } from './event-buffer';
 import { EventRouter, type Subscriber, type SubscriptionConfig } from './event-router';
 export interface SSEResponse {
@@ -25,7 +25,7 @@ export declare class SSEConnection implements Subscriber {
     private closed;
     private lastEventId?;
     constructor(id: string, connectionConfig: SSEConnectionConfig);
-    send(event: AnyEvent, eventId: string): void;
+    send(event: ContextAnyEvent, eventId: string): void;
     private sendHeartbeat;
     private startHeartbeat;
     private stopHeartbeat;
@@ -48,7 +48,7 @@ export declare class SSEServer {
     private heartbeatInterval;
     constructor(config?: SSEServerConfig);
     subscribe(response: SSEResponse, config: SubscriptionConfig, lastEventId?: string): SSEConnection;
-    emit(contextId: string, event: AnyEvent): number;
+    emit(contextId: string, event: ContextAnyEvent): number;
     getSubscriberCount(contextId: string): number;
     getActiveContexts(): string[];
     getStats(): {

package/dist/skills/registry.js

@@ -29,6 +29,7 @@ export class SkillRegistry {
     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.'),

package/dist/stores/artifacts/internal-event-artifact-store.d.ts

@@ -1,7 +1,7 @@
 import type { ArtifactStore, DatasetSchema, StoredArtifact } from '../../types/artifact';
-import type { AnyEvent } from '../../types/event';
+import type { ContextAnyEvent } from '../../types/event';
 export interface InternalEventEmitter {
-    emit(event: AnyEvent): void;
+    emit(event: ContextAnyEvent): void;
 }
 export interface InternalEventArtifactStoreConfig {
     delegate: ArtifactStore;

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

@@ -0,0 +1,36 @@
+import { Observable } from 'rxjs';
+import z from 'zod';
+import type { ContextAnyEvent, ExecutionContext } from '../types';
+import type { ToolCall, ToolDefinition, ToolProvider } from '../types/tools';
+export type HeaderFactory = (context?: ExecutionContext) => Promise<Record<string, string>>;
+declare const cardSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    url: z.ZodURL;
+    icon: z.ZodOptional<z.ZodString>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        issuer: z.ZodString;
+        audience: z.ZodString;
+        scopes: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type AgentCard = z.infer<typeof cardSchema>;
+export declare class AgentToolProvider implements ToolProvider {
+    readonly card: AgentCard;
+    readonly getHeaders?: HeaderFactory | undefined;
+    static fromUrl: (cardUrl: string, getHeaders?: HeaderFactory) => Promise<AgentToolProvider>;
+    static from: (card: AgentCard, getHeaders?: HeaderFactory) => AgentToolProvider;
+    private readonly agentName;
+    readonly name: string;
+    private readonly tools;
+    private readonly logger;
+    constructor(card: AgentCard, getHeaders?: HeaderFactory | undefined);
+    getTool(toolName: string): Promise<ToolDefinition | undefined>;
+    getTools(): Promise<ToolDefinition[]>;
+    execute(toolCall: ToolCall, context: ExecutionContext): Observable<ContextAnyEvent>;
+}
+export {};

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

@@ -0,0 +1,156 @@
+import { consumeSSEStream } from '@geee-be/sse-stream-parser';
+import { Observable } from 'rxjs';
+import z from 'zod';
+import { getLogger } from '../core';
+import { toolErrorEvent } from './tool-result-events';
+const cardSchema = z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    url: z.url(),
+    icon: z.string().optional(),
+    skills: z
+        .array(z.object({
+        name: z.string(),
+        description: z.string().optional(),
+    }))
+        .optional(),
+    auth: z
+        .object({
+        issuer: z.string(),
+        audience: z.string(),
+        scopes: z.array(z.string()),
+    })
+        .optional(),
+});
+const safeName = (name) => name.replace(/[^a-zA-Z0-9-]+/g, '-').toLowerCase();
+export class AgentToolProvider {
+    card;
+    getHeaders;
+    static fromUrl = (cardUrl, getHeaders) => {
+        return fetch(cardUrl)
+            .then((response) => response.json())
+            .then((card) => {
+            return AgentToolProvider.from(card, getHeaders);
+        });
+    };
+    static from = (card, getHeaders) => {
+        const parsed = cardSchema.parse(card);
+        return new AgentToolProvider(parsed, getHeaders);
+    };
+    agentName;
+    name;
+    tools;
+    logger;
+    constructor(card, getHeaders) {
+        this.card = card;
+        this.getHeaders = getHeaders;
+        this.agentName = safeName(card.name);
+        this.name = `agent__${this.agentName}`;
+        this.logger = getLogger({ component: 'agent-tool-provider', agentName: this.agentName });
+        this.tools = [
+            {
+                name: `${this.name}__invoke`,
+                description: `Invoke the ${card.name} agent.\n\n${card.description}` ||
+                    `Invoke the ${card.name} agent`,
+                icon: card.icon,
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        prompt: {
+                            type: 'string',
+                            description: 'The prompt to send to the agent. This will call or invoke the agent sending this prompt as the input. This will start or continue a conversation "turn" with this agent. Example: "What is the weather today?"',
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+        ];
+    }
+    getTool(toolName) {
+        const tool = this.tools.find((t) => t.name === toolName);
+        return Promise.resolve(tool);
+    }
+    getTools() {
+        return Promise.resolve(this.tools);
+    }
+    execute(toolCall, context) {
+        this.logger.debug({ toolCallId: toolCall.id, toolName: toolCall.function.name }, 'Executing agent tool call');
+        return new Observable((subscriber) => {
+            const abortController = new AbortController();
+            const run = async () => {
+                const tool = await this.getTool(toolCall.function.name);
+                if (!tool) {
+                    this.logger.error({ toolName: toolCall.function.name }, 'Tool not found');
+                    subscriber.next(toolErrorEvent(context, toolCall, `Tool not found: ${toolCall.function.name}`));
+                    subscriber.complete();
+                    return;
+                }
+                const prompt = toolCall.function.arguments.prompt;
+                if (!prompt || typeof prompt !== 'string') {
+                    this.logger.error('Invalid tool call arguments');
+                    subscriber.next(toolErrorEvent(context, toolCall, 'Tool argument must include "prompt" and it must be a string'));
+                    subscriber.complete();
+                    return;
+                }
+                const res = await fetch(`${this.card.url}/invocations?qualifier=DEFAULT`, {
+                    method: 'POST',
+                    headers: {
+                        Accept: 'text/event-stream',
+                        'X-Amzn-Bedrock-AgentCore-Runtime-Session-Id': context.contextId,
+                        ...(await this.getHeaders?.(context)),
+                    },
+                    body: JSON.stringify({ prompt }),
+                    signal: abortController.signal,
+                });
+                if (!res.ok) {
+                    this.logger.error({ status: res.status, statusText: res.statusText }, 'Agent call failed');
+                    subscriber.next(toolErrorEvent(context, toolCall, `Agent endpoint responded with ${res.status} ${res.statusText}`));
+                    subscriber.complete();
+                    return;
+                }
+                const body = res.body;
+                if (!body) {
+                    this.logger.error('Agent response has no body');
+                    subscriber.next(toolErrorEvent(context, toolCall, 'Agent returned no response body'));
+                    subscriber.complete();
+                    return;
+                }
+                await consumeSSEStream(body, (e) => {
+                    if (subscriber.closed)
+                        return;
+                    subscriber.next({
+                        kind: e.event,
+                        parentTaskId: context.taskId,
+                        ...JSON.parse(e.data),
+                    });
+                    this.logger.debug({ event: e.event }, 'Received SSE event');
+                }, () => {
+                    if (!subscriber.closed) {
+                        const toolCompleteEvent = {
+                            kind: 'tool-complete',
+                            contextId: context.contextId,
+                            taskId: context.taskId,
+                            toolCallId: toolCall.id,
+                            toolName: toolCall.function.name,
+                            success: true,
+                            result: 'Complete',
+                            timestamp: new Date().toISOString(),
+                        };
+                        subscriber.next(toolCompleteEvent);
+                        subscriber.complete();
+                        this.logger.debug('Tool execution complete');
+                    }
+                });
+            };
+            run().catch((err) => {
+                this.logger.error({ err }, 'Tool execution error');
+                if (!subscriber.closed) {
+                    subscriber.error(err);
+                }
+            });
+            return () => {
+                abortController.abort();
+            };
+        });
+    }
+}

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

@@ -11,7 +11,7 @@ export declare class ClientToolProvider implements ToolProvider {
     private readonly onInputRequired;
     constructor(config: ClientToolConfig);
     getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext): Promise<ToolResult>;
+    execute(toolCall: ToolCall, context: ExecutionContext): import("rxjs").Observable<import("..").ContextAnyEvent | import("..").ContextEvent<import("..").ToolCompleteEvent>>;
     getTool(name: string): Promise<ToolDefinition | undefined>;
     validateToolArguments(toolCall: ToolCall): Promise<{
         valid: boolean;

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

@@ -1,4 +1,6 @@
+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;
@@ -25,39 +27,42 @@ export class ClientToolProvider {
     async getTools() {
         return [...this.tools];
     }
-    async execute(toolCall, context) {
-        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) {
+    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: `Invalid tool arguments: must be an object.`,
+                    error: `Tool ${toolCall.function.name} not found in client tools`,
                 };
             }
-            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),
-            };
-        }
+            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);

package/dist/tools/index.d.ts

@@ -1,4 +1,6 @@
+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,4 +1,6 @@
+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.js

@@ -1,4 +1,6 @@
+import { catchError, defer, mergeMap, of } from 'rxjs';
 import { z } from 'zod';
+import { toolErrorEvent, toolResultToEvents } from './tool-result-events';
 export function tool(definition) {
     return { ...definition };
 }
@@ -38,7 +40,7 @@ export function localTools(tools) {
                 parameters: zodToJsonSchema(toolDef.schema),
             };
         },
-        execute: async (toolCall, context) => {
+        execute: (toolCall, context) => defer(async () => {
             const toolDef = toolMap.get(toolCall.function.name);
             if (!toolDef) {
                 return {
@@ -80,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))))),
     };
 }

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

@@ -1,5 +1,5 @@
 import type { AuthContext, ExecutionContext } from '../types/context';
-import type { ToolCall, ToolDefinition, ToolProvider, ToolResult } from '../types/tools';
+import type { ToolCall, ToolDefinition, ToolProvider } from '../types/tools';
 export interface MCPProviderConfig {
     serverId: string;
     serverUrl: string;
@@ -17,8 +17,7 @@ export declare class McpToolProvider implements ToolProvider {
     private ongoingRequest;
     constructor(config: MCPProviderConfig);
     getTool(toolName: string): Promise<ToolDefinition | undefined>;
-    executeBatch(toolCalls: ToolCall[], context: ExecutionContext): Promise<ToolResult[]>;
     getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext): Promise<ToolResult>;
+    execute(toolCall: ToolCall, context: ExecutionContext): import("rxjs").Observable<import("..").ContextAnyEvent | import("..").ContextEvent<import("..").ToolCompleteEvent>>;
     private convertMCPTool;
 }

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

@@ -1,4 +1,6 @@
+import { catchError, defer, mergeMap, of } from 'rxjs';
 import { MCPClient } from './mcp-client';
+import { toolErrorEvent, toolResultToEvents } from './tool-result-events';
 export const mcp = (config) => {
     return new McpToolProvider(config);
 };
@@ -22,9 +24,6 @@ export class McpToolProvider {
         const tools = await this.getTools();
         return tools.find((tool) => tool.name === toolName);
     }
-    async executeBatch(toolCalls, context) {
-        return Promise.all(toolCalls.map((call) => this.execute(call, context)));
-    }
     async getTools() {
         if (this.toolCache.size > 0 && this.cacheExpiry && Date.now() < this.cacheExpiry) {
             return Array.from(this.toolCache.values());
@@ -48,38 +47,40 @@ export class McpToolProvider {
         });
         return this.ongoingRequest;
     }
-    async execute(toolCall, context) {
-        const { name, arguments: args } = toolCall.function;
-        if (typeof args !== 'object' || args === null) {
-            return {
-                toolCallId: toolCall.id,
-                toolName: name,
-                success: false,
-                error: 'Tool arguments must be an object',
-                result: null,
-            };
-        }
-        try {
-            const response = await this.client.callTool({
-                name,
-                arguments: args,
-            }, context.authContext);
-            return {
-                toolCallId: toolCall.id,
-                toolName: name,
-                success: true,
-                result: response.result,
-            };
-        }
-        catch (error) {
-            return {
-                toolCallId: toolCall.id,
-                toolName: name,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                result: null,
-            };
-        }
+    execute(toolCall, context) {
+        return defer(async () => {
+            const { name, arguments: args } = toolCall.function;
+            if (typeof args !== 'object' || args === null) {
+                return {
+                    toolCallId: toolCall.id,
+                    toolName: name,
+                    success: false,
+                    error: 'Tool arguments must be an object',
+                    result: null,
+                };
+            }
+            try {
+                const response = await this.client.callTool({
+                    name,
+                    arguments: args,
+                }, context.authContext);
+                return {
+                    toolCallId: toolCall.id,
+                    toolName: name,
+                    success: true,
+                    result: response.result,
+                };
+            }
+            catch (error) {
+                return {
+                    toolCallId: toolCall.id,
+                    toolName: name,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    result: null,
+                };
+            }
+        }).pipe(mergeMap((result) => toolResultToEvents(context, toolCall, result)), catchError((error) => of(toolErrorEvent(context, toolCall, error instanceof Error ? error.message : String(error)))));
     }
     convertMCPTool = (mcpTool) => {
         return {

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

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

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

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