@looopy-ai/core 1.0.1

package/dist/core/loop.js

@@ -0,0 +1,125 @@
+import { concat, EMPTY, expand, map, mergeMap, of, reduce, share, shareReplay, } from 'rxjs';
+import { createTaskCompleteEvent, createTaskCreatedEvent, createTaskStatusEvent } from '../events';
+import { startAgentLoopSpan } from '../observability/spans';
+import { runIteration } from './iteration';
+export const runLoop = (context, config, history) => {
+    const logger = context.logger.child({ component: 'loop' });
+    const { traceContext: loopContext, tapFinish } = startAgentLoopSpan({
+        agentId: context.agentId,
+        contextId: context.contextId,
+        taskId: context.taskId,
+        prompt: history.filter((m) => m.role === 'user').at(-1)?.content || '',
+        parentContext: context.parentContext,
+    });
+    logger.debug('Starting agent loop');
+    const taskEvent = createTaskCreatedEvent({
+        contextId: context.contextId,
+        taskId: context.taskId,
+        initiator: 'user',
+        metadata: {
+            historyLength: history.length,
+        },
+    });
+    const workingEvent = createTaskStatusEvent({
+        contextId: context.contextId,
+        taskId: context.taskId,
+        status: 'working',
+        metadata: {},
+    });
+    const merged$ = recursiveMerge({
+        messages: history,
+        completed: false,
+        iteration: 0,
+    }, (state) => runIteration({ ...context, parentContext: loopContext }, {
+        llmProvider: config.llmProvider,
+        iterationNumber: state.iteration,
+    }, state.messages), (state, { events }) => ({
+        ...state,
+        messages: [...state.messages, ...eventsToMessages(events)],
+    }), (e) => e.kind === 'content-complete' && e.finishReason !== 'tool_calls').pipe(shareReplay());
+    const finalSummary$ = merged$.pipe(reduce((last, e) => (e.kind === 'content-complete' ? e : last), null), mergeMap((last) => {
+        if (!last)
+            return EMPTY;
+        return of(createTaskCompleteEvent({
+            contextId: context.contextId,
+            taskId: context.taskId,
+            content: last.content,
+            metadata: { finishReason: last.finishReason },
+        }));
+    }));
+    return concat(of(taskEvent, workingEvent), merged$, finalSummary$).pipe(tapFinish);
+};
+function recursiveMerge(initial, eventsFor, next, isStop) {
+    const seed = {
+        state: initial,
+        iteration: 0,
+        events$: eventsFor({ ...initial, iteration: 0 }).pipe(shareReplay()),
+    };
+    const iterations$ = of(seed).pipe(expand(({ state, iteration, events$ }) => events$.pipe(reduce((acc, e) => {
+        acc.events.push(e);
+        if (isStop(e))
+            acc.sawStop = true;
+        return acc;
+    }, { events: [], sawStop: false }), mergeMap(({ events, sawStop }) => {
+        if (sawStop)
+            return EMPTY;
+        return of(next(state, { iteration, events })).pipe(map((nextState) => {
+            const nextIter = iteration + 1;
+            return {
+                state: nextState,
+                iteration: nextIter,
+                events$: eventsFor({
+                    ...nextState,
+                    iteration: nextIter,
+                }).pipe(share()),
+            };
+        }));
+    }))));
+    return iterations$.pipe(mergeMap(({ events$ }) => events$));
+}
+const eventsToMessages = (events) => {
+    const messages = [];
+    for (const event of events) {
+        switch (event.kind) {
+            case 'content-complete':
+                if (event.content) {
+                    messages.push({
+                        role: 'assistant',
+                        content: event.content,
+                    });
+                }
+                break;
+            case 'tool-call':
+                messages.push({
+                    role: 'assistant',
+                    content: '',
+                    toolCalls: [
+                        {
+                            id: event.toolCallId,
+                            type: 'function',
+                            function: {
+                                name: event.toolName,
+                                arguments: event.arguments,
+                            },
+                        },
+                    ],
+                });
+                break;
+            case 'tool-complete':
+                messages.push({
+                    role: 'tool',
+                    name: event.toolName,
+                    content: event.success
+                        ? event.result
+                            ? JSON.stringify(event.result)
+                            : 'Success'
+                        : event.error || 'Error executing tool',
+                    toolCallId: event.toolCallId,
+                });
+                break;
+            default:
+                break;
+        }
+    }
+    return messages;
+};

package/dist/core/tools.d.ts

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

package/dist/core/tools.js

@@ -0,0 +1,78 @@
+import { concat, defer, of } from 'rxjs';
+import { startToolExecuteSpan } from '../observability/spans';
+export const runToolCall = (context, toolCall) => {
+    const logger = context.logger.child({
+        component: 'tool-call',
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+    });
+    const toolStartEvent = {
+        kind: 'tool-start',
+        contextId: context.contextId,
+        taskId: context.taskId,
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        arguments: toolCall.arguments,
+        timestamp: new Date().toISOString(),
+    };
+    const { tapFinish } = startToolExecuteSpan(context, toolStartEvent);
+    const toolResultEvents$ = defer(async () => {
+        logger.trace('Executing tool');
+        const provider = context.toolProviders.find((p) => p.canHandle(toolCall.toolName));
+        if (!provider) {
+            logger.warn('No provider found for tool');
+            const errorMessage = `No provider found for tool: ${toolCall.toolName}`;
+            return createToolErrorEvent(context, toolCall, errorMessage);
+        }
+        try {
+            const result = await provider.execute({
+                id: toolCall.toolCallId,
+                type: 'function',
+                function: {
+                    name: toolCall.toolName,
+                    arguments: toolCall.arguments,
+                },
+            }, {
+                contextId: context.contextId,
+                taskId: context.taskId,
+                agentId: context.agentId,
+                parentContext: context.parentContext,
+                authContext: context.authContext,
+            });
+            logger.trace({
+                success: result.success,
+            }, 'Tool execution complete');
+            return createToolCompleteEvent(context, toolCall, result.result);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            logger.error({
+                error: err.message,
+                stack: err.stack,
+            }, 'Tool execution failed');
+            return createToolErrorEvent(context, toolCall, err.message);
+        }
+    });
+    return concat(of(toolStartEvent), toolResultEvents$).pipe(tapFinish);
+};
+const createToolCompleteEvent = (context, toolCall, result) => ({
+    kind: 'tool-complete',
+    contextId: context.contextId,
+    taskId: context.taskId,
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    success: true,
+    result: result,
+    timestamp: new Date().toISOString(),
+});
+const createToolErrorEvent = (context, toolCall, errorMessage) => ({
+    kind: 'tool-complete',
+    contextId: context.contextId,
+    taskId: context.taskId,
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    success: false,
+    result: null,
+    error: errorMessage,
+    timestamp: new Date().toISOString(),
+});

package/dist/core/types.d.ts

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

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/events/index.d.ts

@@ -0,0 +1,3 @@
+export { isArtifactEvent, isAuthenticationEvent, isContentStreamingEvent, isDebugEvent, isExternalEvent, isInputRequestEvent, isSubAgentEvent, isTaskLifecycleEvent, isThoughtStreamEvent, isToolExecutionEvent, } from '../types/event';
+export type { CreateAuthCompletedEventOptions, CreateAuthRequiredEventOptions, CreateContentCompleteEventOptions, CreateContentDeltaEventOptions, CreateDatasetWriteEventOptions, CreateDataWriteEventOptions, CreateFileWriteEventOptions, CreateInputReceivedEventOptions, CreateInputRequiredEventOptions, CreateInternalCheckpointEventOptions, CreateInternalLLMCallEventOptions, CreateInternalThoughtProcessEventOptions, CreateSubtaskCreatedEventOptions, CreateTaskCompleteEventOptions, CreateTaskCreatedEventOptions, CreateTaskStatusEventOptions, CreateThoughtStreamEventOptions, CreateToolCompleteEventOptions, CreateToolProgressEventOptions, CreateToolStartEventOptions, } from './utils';
+export { createAuthCompletedEvent, createAuthRequiredEvent, createContentCompleteEvent, createContentDeltaEvent, createDatasetWriteEvent, createDataWriteEvent, createFileWriteEvent, createInputReceivedEvent, createInputRequiredEvent, createInternalCheckpointEvent, createInternalLLMCallEvent, createInternalThoughtProcessEvent, createSubtaskCreatedEvent, createTaskCompleteEvent, createTaskCreatedEvent, createTaskStatusEvent, createThoughtStreamEvent, createToolCompleteEvent, createToolProgressEvent, createToolStartEvent, filterByContextId, filterByKind, filterByTaskId, filterExternalEvents, generateEventId, } from './utils';

package/dist/events/index.js

@@ -0,0 +1,2 @@
+export { isArtifactEvent, isAuthenticationEvent, isContentStreamingEvent, isDebugEvent, isExternalEvent, isInputRequestEvent, isSubAgentEvent, isTaskLifecycleEvent, isThoughtStreamEvent, isToolExecutionEvent, } from '../types/event';
+export { createAuthCompletedEvent, createAuthRequiredEvent, createContentCompleteEvent, createContentDeltaEvent, createDatasetWriteEvent, createDataWriteEvent, createFileWriteEvent, createInputReceivedEvent, createInputRequiredEvent, createInternalCheckpointEvent, createInternalLLMCallEvent, createInternalThoughtProcessEvent, createSubtaskCreatedEvent, createTaskCompleteEvent, createTaskCreatedEvent, createTaskStatusEvent, createThoughtStreamEvent, createToolCompleteEvent, createToolProgressEvent, createToolStartEvent, filterByContextId, filterByKind, filterByTaskId, filterExternalEvents, generateEventId, } from './utils';

package/dist/events/utils.d.ts

@@ -0,0 +1,250 @@
+import type { AnyEvent, AuthCompletedEvent, AuthRequiredEvent, AuthType, ContentCompleteEvent, ContentDeltaEvent, DatasetWriteEvent, DataWriteEvent, FileWriteEvent, FinishReason, InputProvider, InputReceivedEvent, InputRequiredEvent, InputType, InternalCheckpointEvent, InternalLLMCallEvent, InternalThoughtProcessEvent, JSONSchema, SubtaskCreatedEvent, TaskCompleteEvent, TaskCreatedEvent, TaskInitiator, TaskStatus, TaskStatusEvent, ThoughtStreamEvent, ThoughtType, ThoughtVerbosity, ToolCompleteEvent, ToolProgressEvent, ToolStartEvent } from '../types/event';
+export declare function generateEventId(): string;
+export interface CreateTaskCreatedEventOptions {
+    contextId: string;
+    taskId: string;
+    parentTaskId?: string;
+    initiator: TaskInitiator;
+    metadata?: {
+        agentId?: string;
+        model?: string;
+        [key: string]: unknown;
+    };
+}
+export declare function createTaskCreatedEvent(options: CreateTaskCreatedEventOptions): TaskCreatedEvent;
+export interface CreateTaskStatusEventOptions {
+    contextId: string;
+    taskId: string;
+    status: TaskStatus;
+    message?: string;
+    metadata?: {
+        reason?: string;
+        blockedBy?: string;
+        [key: string]: unknown;
+    };
+}
+export declare function createTaskStatusEvent(options: CreateTaskStatusEventOptions): TaskStatusEvent;
+export interface CreateTaskCompleteEventOptions {
+    contextId: string;
+    taskId: string;
+    content?: string;
+    artifacts?: string[];
+    metadata?: {
+        duration?: number;
+        iterations?: number;
+        tokensUsed?: number;
+        [key: string]: unknown;
+    };
+}
+export declare function createTaskCompleteEvent(options: CreateTaskCompleteEventOptions): TaskCompleteEvent;
+export interface CreateContentDeltaEventOptions {
+    contextId: string;
+    taskId: string;
+    delta: string;
+    index: number;
+}
+export declare function createContentDeltaEvent(options: CreateContentDeltaEventOptions): ContentDeltaEvent;
+export interface CreateContentCompleteEventOptions {
+    contextId: string;
+    taskId: string;
+    content: string;
+    finishReason?: FinishReason;
+}
+export declare function createContentCompleteEvent(options: CreateContentCompleteEventOptions): ContentCompleteEvent;
+export interface CreateToolStartEventOptions {
+    contextId: string;
+    taskId: string;
+    toolCallId: string;
+    toolName: string;
+    arguments: Record<string, unknown>;
+    metadata?: {
+        provider?: string;
+        concurrent?: boolean;
+        [key: string]: unknown;
+    };
+}
+export declare function createToolStartEvent(options: CreateToolStartEventOptions): ToolStartEvent;
+export interface CreateToolProgressEventOptions {
+    contextId: string;
+    taskId: string;
+    toolCallId: string;
+    progress: number;
+    message?: string;
+    metadata?: {
+        step?: string;
+        stepsCompleted?: number;
+        stepsTotal?: number;
+        [key: string]: unknown;
+    };
+}
+export declare function createToolProgressEvent(options: CreateToolProgressEventOptions): ToolProgressEvent;
+export interface CreateToolCompleteEventOptions {
+    contextId: string;
+    taskId: string;
+    toolCallId: string;
+    toolName: string;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+    metadata?: {
+        duration?: number;
+        cached?: boolean;
+        retries?: number;
+        [key: string]: unknown;
+    };
+}
+export declare function createToolCompleteEvent(options: CreateToolCompleteEventOptions): ToolCompleteEvent;
+export interface CreateInputRequiredEventOptions {
+    contextId: string;
+    taskId: string;
+    inputId: string;
+    requireUser?: boolean;
+    inputType: InputType;
+    prompt: string;
+    schema?: JSONSchema;
+    options?: unknown[];
+    metadata?: Record<string, unknown>;
+}
+export declare function createInputRequiredEvent(options: CreateInputRequiredEventOptions): InputRequiredEvent;
+export interface CreateInputReceivedEventOptions {
+    contextId: string;
+    taskId: string;
+    inputId: string;
+    providedBy: InputProvider;
+    userId?: string;
+    agentId?: string;
+    metadata?: {
+        duration?: number;
+        [key: string]: unknown;
+    };
+}
+export declare function createInputReceivedEvent(options: CreateInputReceivedEventOptions): InputReceivedEvent;
+export interface CreateAuthRequiredEventOptions {
+    contextId: string;
+    taskId: string;
+    authId: string;
+    authType: AuthType;
+    provider?: string;
+    scopes?: string[];
+    prompt: string;
+    authUrl?: string;
+    metadata?: {
+        expiresIn?: number;
+        [key: string]: unknown;
+    };
+}
+export declare function createAuthRequiredEvent(options: CreateAuthRequiredEventOptions): AuthRequiredEvent;
+export interface CreateAuthCompletedEventOptions {
+    contextId: string;
+    taskId: string;
+    authId: string;
+    userId: string;
+    metadata?: {
+        expiresAt?: string;
+        [key: string]: unknown;
+    };
+}
+export declare function createAuthCompletedEvent(options: CreateAuthCompletedEventOptions): AuthCompletedEvent;
+export interface CreateFileWriteEventOptions {
+    contextId: string;
+    taskId: string;
+    artifactId: string;
+    data: string;
+    index: number;
+    complete: boolean;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+    encoding?: 'utf-8' | 'base64';
+    metadata?: {
+        toolCallId?: string;
+        totalSize?: number;
+        [key: string]: unknown;
+    };
+}
+export declare function createFileWriteEvent(options: CreateFileWriteEventOptions): FileWriteEvent;
+export interface CreateDataWriteEventOptions {
+    contextId: string;
+    taskId: string;
+    artifactId: string;
+    data: Record<string, unknown>;
+    name?: string;
+    description?: string;
+    metadata?: {
+        toolCallId?: string;
+        version?: number;
+        [key: string]: unknown;
+    };
+}
+export declare function createDataWriteEvent(options: CreateDataWriteEventOptions): DataWriteEvent;
+export interface CreateDatasetWriteEventOptions {
+    contextId: string;
+    taskId: string;
+    artifactId: string;
+    rows: Record<string, unknown>[];
+    index: number;
+    complete: boolean;
+    name?: string;
+    description?: string;
+    schema?: JSONSchema;
+    metadata?: {
+        toolCallId?: string;
+        totalRows?: number;
+        batchSize?: number;
+        [key: string]: unknown;
+    };
+}
+export declare function createDatasetWriteEvent(options: CreateDatasetWriteEventOptions): DatasetWriteEvent;
+export interface CreateSubtaskCreatedEventOptions {
+    contextId: string;
+    taskId: string;
+    subtaskId: string;
+    agentId?: string;
+    prompt: string;
+}
+export declare function createSubtaskCreatedEvent(options: CreateSubtaskCreatedEventOptions): SubtaskCreatedEvent;
+export interface CreateThoughtStreamEventOptions {
+    contextId: string;
+    taskId: string;
+    thoughtId: string;
+    thoughtType: ThoughtType;
+    verbosity: ThoughtVerbosity;
+    content: string;
+    index: number;
+    metadata?: {
+        confidence?: number;
+        alternatives?: string[];
+        relatedTo?: string;
+        [key: string]: unknown;
+    };
+}
+export declare function createThoughtStreamEvent(options: CreateThoughtStreamEventOptions): ThoughtStreamEvent;
+export interface CreateInternalThoughtProcessEventOptions {
+    contextId: string;
+    taskId: string;
+    iteration: number;
+    stage: 'pre-llm' | 'post-llm' | 'pre-tool' | 'post-tool';
+    reasoning: string;
+    state: Record<string, unknown>;
+}
+export declare function createInternalThoughtProcessEvent(options: CreateInternalThoughtProcessEventOptions): InternalThoughtProcessEvent;
+export interface CreateInternalLLMCallEventOptions {
+    contextId: string;
+    taskId: string;
+    iteration: number;
+    messageCount: number;
+    toolCount: number;
+}
+export declare function createInternalLLMCallEvent(options: CreateInternalLLMCallEventOptions): InternalLLMCallEvent;
+export interface CreateInternalCheckpointEventOptions {
+    contextId: string;
+    taskId: string;
+    iteration: number;
+}
+export declare function createInternalCheckpointEvent(options: CreateInternalCheckpointEventOptions): InternalCheckpointEvent;
+export declare function filterExternalEvents(events: AnyEvent[]): AnyEvent[];
+export declare function filterByTaskId(events: AnyEvent[], taskId: string): AnyEvent[];
+export declare function filterByContextId(events: AnyEvent[], contextId: string): AnyEvent[];
+export declare function filterByKind<K extends AnyEvent['kind']>(events: AnyEvent[], kind: K): Extract<AnyEvent, {
+    kind: K;
+}>[];