@looopy-ai/core 2.0.1 → 2.1.1

package/dist/core/agent.d.ts

@@ -2,17 +2,16 @@ import { Observable } from 'rxjs';
 import type { SkillRegistry } from '../skills';
 import type { MessageStore } from '../stores/messages/interfaces';
 import type { AgentState, AgentStore } from '../types/agent';
-import type { AuthContext } from '../types/context';
 import type { ContextAnyEvent } from '../types/event';
 import type { LLMProvider } from '../types/llm';
 import type { Message } from '../types/message';
 import type { ToolProvider } from '../types/tools';
 import type { SystemPromptProp } from '../utils/prompt';
-export interface AgentConfig {
+export interface AgentConfig<AuthContext> {
     agentId: string;
     contextId: string;
     llmProvider: LLMProvider;
-    toolProviders: ToolProvider[];
+    toolProviders: ToolProvider<AuthContext>[];
     messageStore: MessageStore;
     agentStore?: AgentStore;
     autoCompact?: boolean;
@@ -25,13 +24,13 @@ export interface GetMessagesOptions {
     maxMessages?: number;
     maxTokens?: number;
 }
-export declare class Agent {
+export declare class Agent<AuthContext> {
     private readonly config;
     private _state;
     private logger;
     private shuttingDown;
     private shutdownComplete;
-    constructor(config: AgentConfig);
+    constructor(config: AgentConfig<AuthContext>);
     get state(): Readonly<AgentState>;
     get agentId(): string;
     get contextId(): string;

package/dist/core/iteration.d.ts

@@ -2,4 +2,4 @@ import { type Observable } from 'rxjs';
 import type { ContextAnyEvent } from '../types/event';
 import type { Message } from '../types/message';
 import type { IterationConfig, LoopContext } from './types';
-export declare const runIteration: (context: LoopContext, config: IterationConfig, history: Message[]) => Observable<ContextAnyEvent>;
+export declare const runIteration: <AuthContext>(context: LoopContext<AuthContext>, config: IterationConfig, history: Message[]) => Observable<ContextAnyEvent>;

package/dist/core/loop.d.ts

@@ -1,4 +1,4 @@
 import type { ContextAnyEvent } from '../types/event';
 import type { Message } from '../types/message';
 import type { LoopConfig, TurnContext } from './types';
-export declare const runLoop: (context: TurnContext, config: LoopConfig, history: Message[]) => import("rxjs").Observable<ContextAnyEvent>;
+export declare const runLoop: <AuthContext>(context: TurnContext<AuthContext>, config: LoopConfig, history: Message[]) => import("rxjs").Observable<ContextAnyEvent>;

package/dist/core/tools.d.ts

@@ -1,4 +1,4 @@
 import { type Observable } from 'rxjs';
 import type { ContextAnyEvent, ContextEvent, ToolCallEvent } from '../types/event';
 import type { IterationContext } from './types';
-export declare const runToolCall: (context: IterationContext, toolCall: ContextEvent<ToolCallEvent>) => Observable<ContextAnyEvent>;
+export declare const runToolCall: <AuthContext>(context: IterationContext<AuthContext>, toolCall: ContextEvent<ToolCallEvent>) => Observable<ContextAnyEvent>;

package/dist/core/types.d.ts

@@ -1,26 +1,25 @@
 import type pino from 'pino';
 import type { SkillRegistry } from '../skills';
-import type { AuthContext } from '../types/context';
 import type { LLMProvider } from '../types/llm';
 import type { ToolProvider } from '../types/tools';
 import type { SystemPromptProp } from '../utils';
-export type AgentContext = {
+export type AgentContext<AuthContext> = {
     agentId: string;
     contextId: string;
     parentContext: import('@opentelemetry/api').Context;
     authContext?: AuthContext;
-    toolProviders: ToolProvider[];
+    toolProviders: ToolProvider<AuthContext>[];
     logger: pino.Logger;
     systemPrompt?: SystemPromptProp;
     skillRegistry?: SkillRegistry;
     metadata?: Record<string, unknown>;
 };
-export type TurnContext = AgentContext & {
+export type TurnContext<AuthContext> = AgentContext<AuthContext> & {
     taskId: string;
     turnNumber: number;
 };
-export type LoopContext = TurnContext;
-export type IterationContext = TurnContext;
+export type LoopContext<AuthContext> = TurnContext<AuthContext>;
+export type IterationContext<AuthContext> = TurnContext<AuthContext>;
 export type LoopConfig = {
     llmProvider: LLMProvider;
     maxIterations: number;

package/dist/observability/spans/iteration.d.ts

@@ -7,7 +7,7 @@ export interface LoopIterationSpanParams {
     iteration: number;
     parentContext: import('@opentelemetry/api').Context;
 }
-export declare const startLoopIterationSpan: (context: LoopContext, iteration: number) => {
+export declare const startLoopIterationSpan: <AuthContext>(context: LoopContext<AuthContext>, iteration: number) => {
     span: import("@opentelemetry/api").Span;
     traceContext: import("@opentelemetry/api").Context;
     tapFinish: import("rxjs").MonoTypeOperatorFunction<ContextAnyEvent>;

package/dist/observability/spans/llm-call.d.ts

@@ -1,7 +1,7 @@
-import type { ToolDefinition } from '../..';
 import type { LoopContext } from '../../core/types';
 import type { AnyEvent } from '../../types/event';
 import type { Message } from '../../types/message';
+import type { ToolDefinition } from '../../types/tools';
 import type { SystemPrompt } from '../../utils/prompt';
 export interface LLMCallSpanParams {
     agentId: string;
@@ -9,7 +9,7 @@ export interface LLMCallSpanParams {
     messages: Message[];
     parentContext: import('@opentelemetry/api').Context;
 }
-export declare const startLLMCallSpan: (context: LoopContext, systemPrompt: SystemPrompt | undefined, messages: Message[], tools: ToolDefinition[]) => {
+export declare const startLLMCallSpan: <AuthContext>(context: LoopContext<AuthContext>, systemPrompt: SystemPrompt | undefined, messages: Message[], tools: ToolDefinition[]) => {
     span: import("@opentelemetry/api").Span;
     traceContext: import("@opentelemetry/api").Context;
     tapFinish: import("rxjs").MonoTypeOperatorFunction<AnyEvent>;

package/dist/observability/spans/tool.d.ts

@@ -7,7 +7,7 @@ export interface ToolExecutionSpanParams {
     toolCall: ToolCall;
     parentContext?: import('@opentelemetry/api').Context;
 }
-export declare const startToolExecuteSpan: (context: IterationContext, toolStart: ToolCallEvent) => {
+export declare const startToolExecuteSpan: <AuthContext>(context: IterationContext<AuthContext>, toolStart: ToolCallEvent) => {
     span: import("@opentelemetry/api").Span;
     traceContext: import("@opentelemetry/api").Context;
     tapFinish: import("rxjs").MonoTypeOperatorFunction<ContextAnyEvent>;

package/dist/skills/registry.d.ts

@@ -10,5 +10,5 @@ export declare class SkillRegistry {
     list(): Skill[];
     tool(): import("..").LocalToolDefinition<z.ZodObject<{
         name: z.ZodString;
-    }, z.core.$strip>>;
+    }, z.core.$strip>, unknown>;
 }

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

@@ -2,7 +2,7 @@ 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, card: AgentCard) => Promise<Record<string, string | undefined>>;
+export type HeaderFactory<AuthContext> = (context: ExecutionContext<AuthContext>, card: AgentCard) => Promise<Record<string, string | undefined>>;
 declare const cardSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -19,18 +19,18 @@ declare const cardSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type AgentCard = z.infer<typeof cardSchema>;
-export declare class AgentToolProvider implements ToolProvider {
+export declare class AgentToolProvider<AuthContext> implements ToolProvider<AuthContext> {
     readonly card: AgentCard;
-    readonly getHeaders?: HeaderFactory | undefined;
-    static fromUrl: (cardUrl: string, getHeaders?: HeaderFactory) => Promise<AgentToolProvider>;
-    static from: (card: AgentCard, getHeaders?: HeaderFactory) => AgentToolProvider;
+    readonly getHeaders?: HeaderFactory<AuthContext> | undefined;
+    static fromUrl: <AuthContext_1>(cardUrl: string, getHeaders?: HeaderFactory<AuthContext_1>) => Promise<AgentToolProvider<AuthContext_1>>;
+    static from: <AuthContext_1>(card: AgentCard, getHeaders?: HeaderFactory<AuthContext_1>) => AgentToolProvider<AuthContext_1>;
     private readonly agentName;
     readonly name: string;
     private readonly tools;
     private readonly logger;
-    constructor(card: AgentCard, getHeaders?: HeaderFactory | undefined);
+    constructor(card: AgentCard, getHeaders?: HeaderFactory<AuthContext> | undefined);
     getTool(toolName: string): Promise<ToolDefinition | undefined>;
     getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext): Observable<ContextAnyEvent>;
+    execute(toolCall: ToolCall, context: ExecutionContext<AuthContext>): Observable<ContextAnyEvent>;
 }
 export {};

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

@@ -74,20 +74,24 @@ export class AgentToolProvider {
         return Promise.resolve(this.tools);
     }
     execute(toolCall, context) {
-        this.logger.debug({ toolCallId: toolCall.id, toolName: toolCall.function.name }, 'Executing agent tool call');
+        const logger = this.logger.child({
+            taskId: context.taskId,
+            toolCallId: toolCall.id,
+        });
+        logger.debug({ toolCallId: toolCall.id }, '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');
+                    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');
+                    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;
@@ -103,47 +107,51 @@ export class AgentToolProvider {
                     signal: abortController.signal,
                 });
                 if (!res.ok) {
-                    this.logger.error({ status: res.status, statusText: res.statusText }, 'Agent call failed');
+                    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');
+                    logger.error('Agent response has no body');
                     subscriber.next(toolErrorEvent(context, toolCall, 'Agent returned no response body'));
                     subscriber.complete();
                     return;
                 }
+                let content = '';
                 await consumeSSEStream(body, (e) => {
                     if (subscriber.closed)
                         return;
+                    const data = JSON.parse(e.data);
                     subscriber.next({
                         kind: e.event,
                         parentTaskId: context.taskId,
-                        ...JSON.parse(e.data),
+                        ...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');
+                    if (e.event === 'task-complete') {
+                        content = data.content;
                     }
+                    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: content || 'Complete',
+                        timestamp: new Date().toISOString(),
+                    };
+                    subscriber.next(toolCompleteEvent);
+                    subscriber.complete();
+                    logger.debug('Tool execution complete');
+                }
             };
             run().catch((err) => {
-                this.logger.error({ err }, 'Tool execution error');
+                logger.error({ err }, 'Tool execution error');
                 if (!subscriber.closed) {
                     subscriber.error(err);
                 }

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

@@ -1,4 +1,4 @@
 import type { ArtifactStore } from '../types/artifact';
 import type { TaskStateStore } from '../types/state';
 import type { ToolProvider } from '../types/tools';
-export declare function createArtifactTools(artifactStore: ArtifactStore, taskStateStore: TaskStateStore): ToolProvider;
+export declare function createArtifactTools<AuthContext>(artifactStore: ArtifactStore, taskStateStore: TaskStateStore): ToolProvider<AuthContext>;

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

@@ -1,17 +1,17 @@
 import type { ExecutionContext } from '../types/context';
 import { type ToolCall, type ToolDefinition, type ToolProvider, type ToolResult } from '../types/tools';
-export interface ClientToolConfig {
+export interface ClientToolConfig<AuthContext> {
     tools: unknown;
-    onInputRequired: (toolCall: ToolCall, context: ExecutionContext) => Promise<ToolResult>;
+    onInputRequired: (toolCall: ToolCall, context: ExecutionContext<AuthContext>) => Promise<ToolResult>;
 }
-export declare class ClientToolProvider implements ToolProvider {
+export declare class ClientToolProvider<AuthContext> implements ToolProvider<AuthContext> {
     name: string;
     private readonly tools;
     private readonly toolNames;
     private readonly onInputRequired;
-    constructor(config: ClientToolConfig);
+    constructor(config: ClientToolConfig<AuthContext>);
     getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext): import("rxjs").Observable<import("..").ContextAnyEvent | import("..").ContextEvent<import("..").ToolCompleteEvent>>;
+    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;

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

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

package/dist/tools/mcp-client.d.ts

@@ -1,4 +1,3 @@
-import type { AuthContext } from '../types/context';
 import type { FunctionParameters } from '../types/tools';
 export interface MCPTool {
     name: string;
@@ -10,16 +9,16 @@ export interface MCPToolResponse {
     result: unknown;
     executionTime: number;
 }
-export interface MCPClientConfig {
+export interface MCPClientConfig<AuthContext> {
     baseUrl: string;
     getHeaders: (authContext?: AuthContext) => Record<string, string>;
     timeout?: number;
 }
-export declare class MCPClient {
+export declare class MCPClient<AuthContext> {
     private readonly baseUrl;
     private readonly timeout;
     private readonly getHeaders;
-    constructor(config: MCPClientConfig);
+    constructor(config: MCPClientConfig<AuthContext>);
     listTools(): Promise<MCPTool[]>;
     callTool(params: {
         name: string;

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

@@ -1,13 +1,13 @@
-import type { AuthContext, ExecutionContext } from '../types/context';
+import type { ExecutionContext } from '../types/context';
 import type { ToolCall, ToolDefinition, ToolProvider } from '../types/tools';
-export interface MCPProviderConfig {
+export interface MCPProviderConfig<AuthContext> {
     serverId: string;
     serverUrl: string;
     timeout?: number;
     getHeaders: (authContext?: AuthContext) => Record<string, string>;
 }
-export declare const mcp: (config: MCPProviderConfig) => McpToolProvider;
-export declare class McpToolProvider implements ToolProvider {
+export declare const mcp: <AuthContext>(config: MCPProviderConfig<AuthContext>) => McpToolProvider<AuthContext>;
+export declare class McpToolProvider<AuthContext> implements ToolProvider<AuthContext> {
     name: string;
     readonly id: string;
     private readonly client;
@@ -15,9 +15,9 @@ export declare class McpToolProvider implements ToolProvider {
     private cacheExpiry;
     private readonly cacheTTL;
     private ongoingRequest;
-    constructor(config: MCPProviderConfig);
+    constructor(config: MCPProviderConfig<AuthContext>);
     getTool(toolName: string): Promise<ToolDefinition | undefined>;
     getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext): import("rxjs").Observable<import("..").ContextAnyEvent | import("..").ContextEvent<import("..").ToolCompleteEvent>>;
+    execute(toolCall: ToolCall, context: ExecutionContext<AuthContext>): import("rxjs").Observable<import("..").ContextAnyEvent | import("..").ContextEvent<import("..").ToolCompleteEvent>>;
     private convertMCPTool;
 }

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

@@ -2,5 +2,5 @@ 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>;
+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>;

package/dist/types/context.d.ts

@@ -1,9 +1,4 @@
-export interface AuthContext {
-    userId?: string;
-    credentials?: Record<string, unknown>;
-    scopes?: string[];
-}
-export interface ExecutionContext {
+export interface ExecutionContext<AuthContext> {
     taskId: string;
     contextId: string;
     agentId: string;

package/dist/types/tools.d.ts

@@ -54,9 +54,9 @@ export declare const ToolCallSchema: z.ZodObject<{
         arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export type ToolProvider = {
+export type ToolProvider<AuthContext> = {
     get name(): string;
     getTool(toolName: string): Promise<ToolDefinition | undefined>;
     getTools(): Promise<ToolDefinition[]>;
-    execute(toolCall: ToolCall, context: ExecutionContext): Observable<ContextAnyEvent>;
+    execute(toolCall: ToolCall, context: ExecutionContext<AuthContext>): Observable<ContextAnyEvent>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looopy-ai/core",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "RxJS-based AI agent framework",
   "keywords": [
     "agent",
@@ -27,7 +27,7 @@
     "dist"
   ],
   "dependencies": {
-    "@geee-be/sse-stream-parser": "^1.0.1",
+    "@geee-be/sse-stream-parser": "^1.0.2",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.207.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.207.0",