@looopy-ai/core 1.0.1

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

@@ -0,0 +1,86 @@
+import { MCPClient } from './mcp-client';
+export const mcp = (config) => {
+    return new McpToolProvider(config);
+};
+export class McpToolProvider {
+    id;
+    client;
+    toolCache = new Map();
+    cacheExpiry = null;
+    cacheTTL = 300_000;
+    ongoingRequest = null;
+    constructor(config) {
+        this.id = `mcp:${config.serverId}`;
+        this.client = new MCPClient({
+            baseUrl: config.serverUrl,
+            timeout: config.timeout || 30000,
+            getHeaders: config.getHeaders,
+        });
+    }
+    async getTools() {
+        if (this.toolCache.size > 0 && this.cacheExpiry && Date.now() < this.cacheExpiry) {
+            return Array.from(this.toolCache.values());
+        }
+        if (this.ongoingRequest) {
+            return this.ongoingRequest;
+        }
+        this.ongoingRequest = this.client
+            .listTools()
+            .then((tools) => {
+            const toolDefs = tools.map(this.convertMCPTool);
+            this.toolCache.clear();
+            for (const tool of toolDefs) {
+                this.toolCache.set(tool.name, tool);
+            }
+            this.cacheExpiry = Date.now() + this.cacheTTL;
+            return toolDefs;
+        })
+            .finally(() => {
+            this.ongoingRequest = null;
+        });
+        return this.ongoingRequest;
+    }
+    canHandle(toolName) {
+        return this.toolCache.has(toolName);
+    }
+    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,
+            };
+        }
+    }
+    convertMCPTool = (mcpTool) => {
+        return {
+            name: mcpTool.name,
+            description: mcpTool.description,
+            parameters: mcpTool.inputSchema,
+        };
+    };
+}

package/dist/types/a2a.d.ts

@@ -0,0 +1,36 @@
+import type { Message } from './message';
+export type A2ATaskState = 'submitted' | 'working' | 'input-required' | 'completed' | 'canceled' | 'failed' | 'rejected' | 'auth-required' | 'unknown';
+export interface A2ATaskStatus {
+    state: A2ATaskState;
+    message?: Message;
+    timestamp?: string;
+}
+export type A2APart = A2ATextPart | A2AFilePart | A2ADataPart;
+export interface A2ATextPart {
+    kind: 'text';
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+export interface A2AFilePart {
+    kind: 'file';
+    file: {
+        name?: string;
+        mimeType?: string;
+        bytes?: string;
+        uri?: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface A2ADataPart {
+    kind: 'data';
+    data: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface A2AArtifact {
+    artifactId: string;
+    name?: string;
+    description?: string;
+    parts: A2APart[];
+    metadata?: Record<string, unknown>;
+    extensions?: string[];
+}

package/dist/types/a2a.js

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

package/dist/types/agent.d.ts

@@ -0,0 +1,14 @@
+import type { SerializedError } from '../utils/error';
+export interface AgentState {
+    status: 'created' | 'ready' | 'busy' | 'shutdown' | 'error';
+    turnCount: number;
+    lastActivity: Date;
+    createdAt: Date;
+    error?: SerializedError;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentStore {
+    load(contextId: string): Promise<AgentState | null>;
+    save(contextId: string, state: AgentState): Promise<void>;
+    delete?(contextId: string): Promise<void>;
+}

package/dist/types/agent.js

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

package/dist/types/artifact.d.ts

@@ -0,0 +1,126 @@
+export type ArtifactType = 'file' | 'data' | 'dataset';
+export interface ArtifactStore {
+    createFileArtifact(params: {
+        artifactId: string;
+        taskId: string;
+        contextId: string;
+        name?: string;
+        description?: string;
+        mimeType?: string;
+        encoding?: 'utf-8' | 'base64';
+        override?: boolean;
+    }): Promise<string>;
+    createDataArtifact(params: {
+        artifactId: string;
+        taskId: string;
+        contextId: string;
+        name?: string;
+        description?: string;
+        override?: boolean;
+    }): Promise<string>;
+    createDatasetArtifact(params: {
+        artifactId: string;
+        taskId: string;
+        contextId: string;
+        name?: string;
+        description?: string;
+        schema?: DatasetSchema;
+        override?: boolean;
+    }): Promise<string>;
+    appendFileChunk(contextId: string, artifactId: string, chunk: string, options?: {
+        isLastChunk?: boolean;
+        encoding?: 'utf-8' | 'base64';
+    }): Promise<void>;
+    writeData(contextId: string, artifactId: string, data: Record<string, unknown>): Promise<void>;
+    appendDatasetBatch(contextId: string, artifactId: string, rows: Record<string, unknown>[], options?: {
+        isLastBatch?: boolean;
+    }): Promise<void>;
+    getArtifact(contextId: string, artifactId: string): Promise<StoredArtifact | null>;
+    getFileContent(contextId: string, artifactId: string): Promise<string>;
+    getDataContent(contextId: string, artifactId: string): Promise<Record<string, unknown>>;
+    getDatasetRows(contextId: string, artifactId: string): Promise<Record<string, unknown>[]>;
+    listArtifacts(contextId: string, taskId?: string): Promise<string[]>;
+    deleteArtifact(contextId: string, artifactId: string): Promise<void>;
+}
+export interface DatasetSchema {
+    columns: DatasetColumn[];
+    primaryKey?: string[];
+    indexes?: string[][];
+}
+export interface DatasetColumn {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'date' | 'json' | 'null';
+    nullable?: boolean;
+    description?: string;
+}
+export interface BaseArtifact {
+    artifactId: string;
+    taskId: string;
+    contextId: string;
+    name?: string;
+    description?: string;
+    status: 'building' | 'complete' | 'failed';
+    version: number;
+    operations: ArtifactOperation[];
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+    externalStorage?: {
+        provider: 'local' | 's3' | 'gcs' | 'azure';
+        key: string;
+        bucket?: string;
+        region?: string;
+        checksum?: string;
+    };
+}
+export interface FileArtifact extends BaseArtifact {
+    type: 'file';
+    chunks: ArtifactChunk[];
+    mimeType?: string;
+    encoding?: 'utf-8' | 'base64';
+    totalChunks: number;
+    totalSize: number;
+}
+export interface DataArtifact extends BaseArtifact {
+    type: 'data';
+    data: Record<string, unknown>;
+}
+export interface DatasetArtifact extends BaseArtifact {
+    type: 'dataset';
+    rows: Record<string, unknown>[];
+    schema?: DatasetSchema;
+    totalChunks: number;
+    totalSize: number;
+}
+export type StoredArtifact = FileArtifact | DataArtifact | DatasetArtifact;
+export interface ArtifactChunk {
+    index: number;
+    data: string;
+    size: number;
+    checksum?: string;
+    timestamp: string;
+}
+export interface ArtifactPart {
+    index: number;
+    kind: 'text' | 'file' | 'data';
+    content?: string;
+    data?: Record<string, unknown>;
+    fileReference?: {
+        storageKey: string;
+        size: number;
+        checksum?: string;
+    };
+    metadata?: {
+        mimeType?: string;
+        fileName?: string;
+        [key: string]: unknown;
+    };
+}
+export interface ArtifactOperation {
+    operationId: string;
+    type: 'create' | 'append' | 'replace' | 'complete' | 'reset';
+    timestamp: string;
+    partIndex?: number;
+    chunkIndex?: number;
+    replacedPartIndexes?: number[];
+}

package/dist/types/artifact.js

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

package/dist/types/context.d.ts

@@ -0,0 +1,13 @@
+export interface AuthContext {
+    userId?: string;
+    credentials?: Record<string, unknown>;
+    scopes?: string[];
+}
+export interface ExecutionContext {
+    taskId: string;
+    contextId: string;
+    agentId: string;
+    parentContext: import('@opentelemetry/api').Context;
+    authContext?: AuthContext;
+    metadata?: Record<string, unknown>;
+}

package/dist/types/context.js

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

package/dist/types/event.d.ts

@@ -0,0 +1,360 @@
+import type { ToolCall } from './tools';
+export type TaskStatus = 'working' | 'waiting-input' | 'waiting-auth' | 'waiting-subtask' | 'completed' | 'failed' | 'canceled';
+export type ThoughtVerbosity = 'brief' | 'normal' | 'detailed';
+export type ThoughtType = 'analysis' | 'planning' | 'reasoning' | 'reflection' | 'thinking' | 'decision' | 'observation' | 'strategy';
+export type InputType = 'tool-execution' | 'confirmation' | 'clarification' | 'selection' | 'custom';
+export type AuthType = 'oauth2' | 'api-key' | 'password' | 'biometric' | 'custom';
+export type TaskInitiator = 'user' | 'agent';
+export type InputProvider = 'user' | 'agent';
+export interface JSONSchema {
+    type?: string;
+    properties?: Record<string, JSONSchema>;
+    required?: string[];
+    items?: JSONSchema;
+    format?: string;
+    [key: string]: unknown;
+}
+export interface TaskCreatedEvent {
+    kind: 'task-created';
+    contextId: string;
+    taskId: string;
+    parentTaskId?: string;
+    initiator: TaskInitiator;
+    timestamp: string;
+    metadata?: {
+        agentId?: string;
+        model?: string;
+        [key: string]: unknown;
+    };
+}
+export interface TaskStatusEvent {
+    kind: 'task-status';
+    contextId: string;
+    taskId: string;
+    status: TaskStatus;
+    message?: string;
+    timestamp: string;
+    metadata?: {
+        reason?: string;
+        blockedBy?: string;
+        [key: string]: unknown;
+    };
+}
+export interface TaskCompleteEvent {
+    kind: 'task-complete';
+    contextId: string;
+    taskId: string;
+    content?: string;
+    artifacts?: string[];
+    timestamp: string;
+    metadata?: {
+        duration?: number;
+        iterations?: number;
+        tokensUsed?: number;
+        [key: string]: unknown;
+    };
+}
+export type TaskLifecycleEvent = TaskCreatedEvent | TaskStatusEvent | TaskCompleteEvent;
+export interface ContentDeltaEvent {
+    kind: 'content-delta';
+    contextId: string;
+    taskId: string;
+    delta: string;
+    index: number;
+    timestamp: string;
+}
+export type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter';
+export interface ContentCompleteEvent {
+    kind: 'content-complete';
+    contextId: string;
+    taskId: string;
+    content: string;
+    finishReason: FinishReason;
+    toolCalls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: Record<string, unknown>;
+        };
+    }>;
+    timestamp: string;
+}
+export type ContentStreamingEvent = ContentDeltaEvent | ContentCompleteEvent;
+export interface ToolCallEvent {
+    kind: 'tool-call';
+    contextId: string;
+    taskId: string;
+    toolCallId: string;
+    toolName: string;
+    arguments: Record<string, unknown>;
+    timestamp: string;
+    metadata?: {
+        [key: string]: unknown;
+    };
+}
+export interface ToolStartEvent {
+    kind: 'tool-start';
+    contextId: string;
+    taskId: string;
+    toolCallId: string;
+    toolName: string;
+    arguments: Record<string, unknown>;
+    timestamp: string;
+    metadata?: {
+        provider?: string;
+        concurrent?: boolean;
+        [key: string]: unknown;
+    };
+}
+export interface ToolProgressEvent {
+    kind: 'tool-progress';
+    contextId: string;
+    taskId: string;
+    toolCallId: string;
+    progress: number;
+    message?: string;
+    timestamp: string;
+    metadata?: {
+        step?: string;
+        stepsCompleted?: number;
+        stepsTotal?: number;
+        [key: string]: unknown;
+    };
+}
+export interface ToolCompleteEvent {
+    kind: 'tool-complete';
+    contextId: string;
+    taskId: string;
+    toolCallId: string;
+    toolName: string;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+    timestamp: string;
+    metadata?: {
+        duration?: number;
+        cached?: boolean;
+        retries?: number;
+        [key: string]: unknown;
+    };
+}
+export type ToolExecutionEvent = ToolCallEvent | ToolStartEvent | ToolProgressEvent | ToolCompleteEvent;
+export interface InputRequiredEvent {
+    kind: 'input-required';
+    contextId: string;
+    taskId: string;
+    inputId: string;
+    requireUser?: boolean;
+    inputType: InputType;
+    prompt: string;
+    schema?: JSONSchema;
+    options?: unknown[];
+    timestamp: string;
+    metadata?: {
+        toolCall?: ToolCall;
+        urgency?: 'low' | 'medium' | 'high';
+        timeout?: number;
+        [key: string]: unknown;
+    };
+}
+export interface InputReceivedEvent {
+    kind: 'input-received';
+    contextId: string;
+    taskId: string;
+    inputId: string;
+    providedBy: InputProvider;
+    userId?: string;
+    agentId?: string;
+    timestamp: string;
+    metadata?: {
+        duration?: number;
+        [key: string]: unknown;
+    };
+}
+export type InputRequestEvent = InputRequiredEvent | InputReceivedEvent;
+export interface AuthRequiredEvent {
+    kind: 'auth-required';
+    contextId: string;
+    taskId: string;
+    authId: string;
+    authType: AuthType;
+    provider?: string;
+    scopes?: string[];
+    prompt: string;
+    authUrl?: string;
+    timestamp: string;
+    metadata?: {
+        expiresIn?: number;
+        [key: string]: unknown;
+    };
+}
+export interface AuthCompletedEvent {
+    kind: 'auth-completed';
+    contextId: string;
+    taskId: string;
+    authId: string;
+    userId: string;
+    timestamp: string;
+    metadata?: {
+        expiresAt?: string;
+        [key: string]: unknown;
+    };
+}
+export type AuthenticationEvent = AuthRequiredEvent | AuthCompletedEvent;
+export interface FileWriteEvent {
+    kind: 'file-write';
+    contextId: string;
+    taskId: string;
+    artifactId: string;
+    data: string;
+    index: number;
+    complete: boolean;
+    timestamp: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+    encoding?: 'utf-8' | 'base64';
+    metadata?: {
+        toolCallId?: string;
+        totalSize?: number;
+        [key: string]: unknown;
+    };
+}
+export interface DataWriteEvent {
+    kind: 'data-write';
+    contextId: string;
+    taskId: string;
+    artifactId: string;
+    name?: string;
+    description?: string;
+    data: Record<string, unknown>;
+    timestamp: string;
+    metadata?: {
+        toolCallId?: string;
+        version?: number;
+        [key: string]: unknown;
+    };
+}
+export interface DatasetWriteEvent {
+    kind: 'dataset-write';
+    contextId: string;
+    taskId: string;
+    artifactId: string;
+    rows: Record<string, unknown>[];
+    index: number;
+    complete: boolean;
+    timestamp: string;
+    name?: string;
+    description?: string;
+    schema?: JSONSchema;
+    metadata?: {
+        toolCallId?: string;
+        totalRows?: number;
+        batchSize?: number;
+        [key: string]: unknown;
+    };
+}
+export type ArtifactEvent = FileWriteEvent | DataWriteEvent | DatasetWriteEvent;
+export interface SubtaskCreatedEvent {
+    kind: 'subtask-created';
+    contextId: string;
+    taskId: string;
+    subtaskId: string;
+    agentId?: string;
+    prompt: string;
+    timestamp: string;
+}
+export type SubAgentEvent = SubtaskCreatedEvent;
+export interface ThoughtStreamEvent {
+    kind: 'thought-stream';
+    contextId: string;
+    taskId: string;
+    thoughtId: string;
+    thoughtType: ThoughtType;
+    verbosity: ThoughtVerbosity;
+    content: string;
+    index: number;
+    timestamp: string;
+    metadata?: {
+        source?: 'content' | 'content-delta' | 'tool-call';
+        confidence?: number;
+        alternatives?: string[];
+        relatedTo?: string;
+        [key: string]: unknown;
+    };
+}
+export interface InternalThoughtProcessEvent {
+    kind: 'internal:thought-process';
+    contextId: string;
+    taskId: string;
+    iteration: number;
+    stage: 'pre-llm' | 'post-llm' | 'pre-tool' | 'post-tool';
+    reasoning: string;
+    state: Record<string, unknown>;
+    timestamp: string;
+}
+export interface InternalLLMCallEvent {
+    kind: 'internal:llm-call';
+    contextId: string;
+    taskId: string;
+    iteration: number;
+    messageCount: number;
+    toolCount: number;
+    timestamp: string;
+}
+export interface InternalCheckpointEvent {
+    kind: 'internal:checkpoint';
+    contextId: string;
+    taskId: string;
+    iteration: number;
+    timestamp: string;
+}
+export interface InternalToolStartEvent {
+    kind: 'internal:tool-start';
+    contextId: string;
+    taskId: string;
+    toolCallId: string;
+    toolName: string;
+    timestamp: string;
+}
+export interface InternalToolCompleteEvent {
+    kind: 'internal:tool-complete';
+    contextId: string;
+    taskId: string;
+    toolCallId: string;
+    toolName: string;
+    success: boolean;
+    error?: string;
+    timestamp: string;
+}
+export type InternalDebugEvent = InternalLLMCallEvent | InternalCheckpointEvent | InternalToolStartEvent | InternalToolCompleteEvent | InternalThoughtProcessEvent;
+export interface LLMUsageEvent {
+    kind: 'llm-usage';
+    contextId: string;
+    taskId: string;
+    model: string;
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+    completion_tokens_details?: Record<string, number>;
+    prompt_tokens_details?: Record<string, number>;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    timestamp: string;
+}
+export type UsageEvent = LLMUsageEvent;
+export type AnyEvent = TaskLifecycleEvent | ContentStreamingEvent | ToolExecutionEvent | InputRequestEvent | AuthenticationEvent | ArtifactEvent | SubAgentEvent | ThoughtStreamEvent | InternalDebugEvent | UsageEvent;
+export type LLMEvent<T> = Omit<T, 'contextId' | 'taskId'>;
+export type ExternalEvent = Exclude<AnyEvent, InternalDebugEvent>;
+export type DebugEvent = InternalDebugEvent;
+export declare function isExternalEvent(event: AnyEvent): event is ExternalEvent;
+export declare function isDebugEvent(event: AnyEvent): event is DebugEvent;
+export declare function isTaskLifecycleEvent(event: AnyEvent): event is TaskLifecycleEvent;
+export declare function isContentStreamingEvent(event: AnyEvent): event is ContentStreamingEvent;
+export declare function isToolExecutionEvent(event: AnyEvent): event is ToolExecutionEvent;
+export declare function isInputRequestEvent(event: AnyEvent): event is InputRequestEvent;
+export declare function isAuthenticationEvent(event: AnyEvent): event is AuthenticationEvent;
+export declare function isArtifactEvent(event: AnyEvent): event is ArtifactEvent;
+export declare function isSubAgentEvent(event: AnyEvent): event is SubAgentEvent;
+export declare function isThoughtStreamEvent(event: AnyEvent): event is ThoughtStreamEvent;

package/dist/types/event.js

@@ -0,0 +1,30 @@
+export function isExternalEvent(event) {
+    return !event.kind.startsWith('internal:');
+}
+export function isDebugEvent(event) {
+    return event.kind.startsWith('internal:');
+}
+export function isTaskLifecycleEvent(event) {
+    return (event.kind === 'task-created' || event.kind === 'task-status' || event.kind === 'task-complete');
+}
+export function isContentStreamingEvent(event) {
+    return event.kind === 'content-delta' || event.kind === 'content-complete';
+}
+export function isToolExecutionEvent(event) {
+    return (event.kind === 'tool-start' || event.kind === 'tool-progress' || event.kind === 'tool-complete');
+}
+export function isInputRequestEvent(event) {
+    return event.kind === 'input-required' || event.kind === 'input-received';
+}
+export function isAuthenticationEvent(event) {
+    return event.kind === 'auth-required' || event.kind === 'auth-completed';
+}
+export function isArtifactEvent(event) {
+    return (event.kind === 'file-write' || event.kind === 'data-write' || event.kind === 'dataset-write');
+}
+export function isSubAgentEvent(event) {
+    return event.kind === 'subtask-created';
+}
+export function isThoughtStreamEvent(event) {
+    return event.kind === 'thought-stream';
+}

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from './a2a';
+export * from './agent';
+export * from './artifact';
+export * from './context';
+export * from './event';
+export * from './llm';
+export * from './message';
+export * from './state';
+export * from './tools';

package/dist/types/index.js

@@ -0,0 +1,9 @@
+export * from './a2a';
+export * from './agent';
+export * from './artifact';
+export * from './context';
+export * from './event';
+export * from './llm';
+export * from './message';
+export * from './state';
+export * from './tools';