@looopy-ai/core 1.0.1

package/dist/providers/chat-completions/streaming.d.ts

@@ -0,0 +1,12 @@
+import type { Choice, LLMUsage } from './types';
+type ChatCompletionStreamData = {
+    id: string;
+    created: number;
+    model: string;
+    object: string;
+    choices: Choice[];
+    usage?: LLMUsage;
+};
+export declare const choices: <T extends ChatCompletionStreamData>() => import("rxjs").UnaryFunction<import("rxjs").Observable<T>, import("rxjs").Observable<Choice>>;
+export declare const usage: <T extends ChatCompletionStreamData>() => import("rxjs").UnaryFunction<import("rxjs").Observable<T>, import("rxjs").Observable<LLMUsage>>;
+export {};

package/dist/providers/chat-completions/streaming.js

@@ -0,0 +1,3 @@
+import { filter, map, mergeMap, pipe } from 'rxjs';
+export const choices = () => pipe(mergeMap((data) => data.choices), filter((choice) => !!choice));
+export const usage = () => pipe(map((data) => data.usage), filter((usage) => !!usage));

package/dist/providers/chat-completions/types.d.ts

@@ -0,0 +1,39 @@
+export type ToolCall = {
+    index: number;
+    id?: string | null;
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
+    type?: 'function';
+};
+export type InlineXml = {
+    name: string;
+    content?: string;
+    attributes: Record<string, string | string[]>;
+};
+export type Choice = {
+    delta?: {
+        content?: string;
+        tool_calls?: ToolCall[];
+    };
+    index: number;
+    finish_reason?: string | null;
+    thoughts?: InlineXml[];
+};
+export type ChatCompletionStreamData = {
+    id: string;
+    created: string;
+    model: string;
+    object: string;
+    choices: Choice[];
+};
+export type LLMUsage = {
+    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;
+};

package/dist/providers/chat-completions/types.js

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

package/dist/providers/index.d.ts

@@ -0,0 +1,2 @@
+export type { LiteLLMConfig } from './litellm-provider';
+export { LiteLLM, LiteLLMProvider } from './litellm-provider';

package/dist/providers/index.js

@@ -0,0 +1 @@
+export { LiteLLM, LiteLLMProvider } from './litellm-provider';

package/dist/providers/litellm-provider.d.ts

@@ -0,0 +1,43 @@
+import { Observable } from 'rxjs';
+import type { AnyEvent, LLMEvent } from '../types/event';
+import type { LLMProvider } from '../types/llm';
+import type { Message } from '../types/message';
+import type { ToolDefinition } from '../types/tools';
+export interface LiteLLMConfig {
+    baseUrl: string;
+    model: string;
+    apiKey?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    timeout?: number;
+    extraParams?: Record<string, unknown>;
+    debugLogPath?: string;
+}
+export declare class LiteLLMProvider implements LLMProvider {
+    private readonly config;
+    private debugLogInitialized;
+    private readonly logger;
+    constructor(config: LiteLLMConfig);
+    call(request: {
+        messages: Message[];
+        tools?: ToolDefinition[];
+        sessionId?: string;
+    }): Observable<LLMEvent<AnyEvent>>;
+    private debugLogRawChunk;
+    private debugLog;
+    private createSSEStream;
+    getModel(): string;
+    updateConfig(updates: Partial<LiteLLMConfig>): void;
+}
+export declare const LiteLLM: {
+    novaMicro(baseUrl: string, apiKey?: string): LiteLLMProvider;
+    novaLite(baseUrl: string, apiKey?: string, debugLogPath?: string): LiteLLMProvider;
+    gpt4(baseUrl: string, apiKey?: string): LiteLLMProvider;
+    gpt4Turbo(baseUrl: string, apiKey?: string): LiteLLMProvider;
+    gpt35Turbo(baseUrl: string, apiKey?: string): LiteLLMProvider;
+    claude3Opus(baseUrl: string, apiKey?: string): LiteLLMProvider;
+    claude3Sonnet(baseUrl: string, apiKey?: string): LiteLLMProvider;
+    claude3Haiku(baseUrl: string, apiKey?: string): LiteLLMProvider;
+    ollama(baseUrl: string, model: string): LiteLLMProvider;
+};

package/dist/providers/litellm-provider.js

@@ -0,0 +1,377 @@
+import { appendFileSync, promises as fs, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { merge, Observable } from 'rxjs';
+import { concatWith, filter, map, mergeMap, shareReplay, tap } from 'rxjs/operators';
+import { getLogger } from '../core/logger';
+import { generateEventId } from '../events/utils';
+import { aggregateChoice, aggregateLLMUsage, choices, getContent, splitInlineXml, usage, } from './chat-completions';
+const singleString = (input) => {
+    if (!input)
+        return undefined;
+    if (Array.isArray(input)) {
+        return input.join('');
+    }
+    return input;
+};
+export class LiteLLMProvider {
+    config;
+    debugLogInitialized = false;
+    logger;
+    constructor(config) {
+        this.config = {
+            ...config,
+            temperature: config.temperature ?? 0.7,
+            maxTokens: config.maxTokens ?? 4096,
+            topP: config.topP ?? 1.0,
+            timeout: config.timeout ?? 60000,
+            extraParams: config.extraParams ?? {},
+        };
+        this.logger = getLogger({ base: { component: 'LiteLLMProvider' } });
+        this.logger.info({
+            baseUrl: this.config.baseUrl,
+            model: this.config.model,
+            temperature: this.config.temperature,
+            maxTokens: this.config.maxTokens,
+            timeout: this.config.timeout,
+            hasApiKey: !!this.config.apiKey,
+        }, 'LiteLLM provider initialized');
+    }
+    call(request) {
+        const rawStream$ = this.createSSEStream(request);
+        const stream$ = (this.config.debugLogPath
+            ? rawStream$.pipe(tap((chunk) => this.debugLogRawChunk(chunk)))
+            : rawStream$).pipe(shareReplay());
+        const choices$ = stream$.pipe(choices());
+        const usage$ = stream$.pipe(usage());
+        const { content, tags } = splitInlineXml(choices$.pipe(getContent()));
+        let contentIndex = 0;
+        const contentDeltas$ = content.pipe(map((delta) => ({
+            kind: 'content-delta',
+            delta,
+            index: contentIndex++,
+            timestamp: new Date().toISOString(),
+        })), this.debugLog('content-delta'));
+        let thoughtIndex = 0;
+        const thoughts$ = tags.pipe(filter((tag) => [
+            'thinking',
+            'analysis',
+            'reasoning',
+            'reflection',
+            'planning',
+            'debugging',
+            'decision',
+            'observation',
+            'strategizing',
+        ].includes(tag.name)), map((tag) => {
+            const thoughtType = singleString(tag.attributes.thoughtType || tag.attributes.thought_type || tag.name) || 'thinking';
+            const verbosity = singleString(tag.attributes.verbosity) || 'normal';
+            const content = singleString(tag.attributes.content || tag.content) || '';
+            return {
+                kind: 'thought-stream',
+                thoughtId: generateEventId(),
+                thoughtType,
+                verbosity,
+                content,
+                index: thoughtIndex++,
+                timestamp: new Date().toISOString(),
+                metadata: {
+                    source: 'content-delta',
+                },
+            };
+        }), this.debugLog('thought-stream'));
+        const contentComplete$ = choices$.pipe(aggregateChoice(), map((aggregated) => {
+            const content = aggregated.delta?.content || '';
+            const toolCalls = aggregated.delta?.tool_calls
+                ?.filter((tc) => tc.id && tc.function?.name && tc.function?.arguments)
+                .map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: {
+                    name: tc.function?.name,
+                    arguments: (typeof tc.function?.arguments === 'string'
+                        ? JSON.parse(tc.function?.arguments)
+                        : tc.function?.arguments) || {},
+                },
+            }));
+            return {
+                kind: 'content-complete',
+                content,
+                toolCalls: toolCalls?.length ? toolCalls : undefined,
+                finishReason: aggregated.finish_reason || 'stop',
+                timestamp: new Date().toISOString(),
+            };
+        }), this.debugLog('content-complete'));
+        const usageComplete$ = usage$.pipe(aggregateLLMUsage(), map((usage) => ({
+            kind: 'llm-usage',
+            model: this.config.model,
+            ...usage,
+            timestamp: new Date().toISOString(),
+        })), this.debugLog('llm-usage'));
+        const toolCalls$ = contentComplete$.pipe(mergeMap((event) => event.toolCalls?.map((tc) => ({
+            kind: 'tool-call',
+            toolCallId: tc.id,
+            toolName: tc.function.name,
+            arguments: tc.function.arguments,
+            timestamp: event.timestamp,
+        })) || []));
+        return merge(contentDeltas$, thoughts$, usageComplete$, toolCalls$).pipe(concatWith(contentComplete$));
+    }
+    debugLogRawChunk(chunk) {
+        if (!this.config.debugLogPath) {
+            return;
+        }
+        if (!this.debugLogInitialized) {
+            try {
+                mkdirSync(dirname(this.config.debugLogPath), { recursive: true });
+                writeFileSync(this.config.debugLogPath, `# LLM Raw Stream Debug Log\n# Started: ${new Date().toISOString()}\n# Model: ${this.config.model}\n\n`, { flag: 'w' });
+                this.debugLogInitialized = true;
+            }
+            catch (error) {
+                this.logger.warn({ error }, 'Failed to initialize debug log file');
+                return;
+            }
+        }
+        try {
+            const logEntry = [
+                `chunk: ${new Date().toISOString()}`,
+                `data: ${JSON.stringify(chunk)}`,
+                '',
+            ].join('\n');
+            appendFileSync(this.config.debugLogPath, `${logEntry}\n`);
+        }
+        catch (error) {
+            this.logger.warn({ error }, 'Failed to write debug log');
+        }
+    }
+    debugLog(eventType) {
+        if (!this.config.debugLogPath) {
+            return (source) => source;
+        }
+        return (source) => source.pipe(tap(async (event) => {
+            try {
+                if (!this.config.debugLogPath) {
+                    return;
+                }
+                if (!this.debugLogInitialized) {
+                    await fs.mkdir(dirname(this.config.debugLogPath), { recursive: true });
+                    await fs.writeFile(this.config.debugLogPath, `# LLM Event Debug Log\n# Started: ${new Date().toISOString()}\n# Model: ${this.config.model}\n\n`, { flag: 'w' });
+                    this.debugLogInitialized = true;
+                }
+                const logEntry = [
+                    `event: ${eventType}`,
+                    `data: ${JSON.stringify(event)}`,
+                    `when: ${new Date().toISOString()}`,
+                    '',
+                ].join('\n');
+                await fs.appendFile(this.config.debugLogPath, `${logEntry}\n`);
+            }
+            catch (error) {
+                this.logger.warn({ error, eventType }, 'Failed to write debug log');
+            }
+        }));
+    }
+    createSSEStream(request) {
+        return new Observable((subscriber) => {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+            const litellmRequest = {
+                model: this.config.model,
+                messages: request.messages.map((msg) => {
+                    const baseMsg = {
+                        role: msg.role,
+                        content: msg.content,
+                    };
+                    if (msg.name)
+                        baseMsg.name = msg.name;
+                    if (msg.toolCallId)
+                        baseMsg.tool_call_id = msg.toolCallId;
+                    if (msg.toolCalls && msg.toolCalls.length > 0) {
+                        baseMsg.tool_calls = msg.toolCalls.map((tc) => ({
+                            id: tc.id,
+                            type: tc.type,
+                            function: {
+                                name: tc.function.name,
+                                arguments: typeof tc.function.arguments === 'string'
+                                    ? tc.function.arguments
+                                    : JSON.stringify(tc.function.arguments),
+                            },
+                        }));
+                    }
+                    return baseMsg;
+                }),
+                temperature: this.config.temperature,
+                max_tokens: this.config.maxTokens,
+                top_p: this.config.topP,
+                stream: true,
+                stream_options: { include_usage: true },
+                ...this.config.extraParams,
+            };
+            if (request.sessionId) {
+                litellmRequest.metadata = {
+                    ...(litellmRequest.metadata || {}),
+                    session_id: request.sessionId,
+                };
+            }
+            if (request.tools && request.tools.length > 0) {
+                litellmRequest.tools = request.tools.map((tool) => ({
+                    type: 'function',
+                    function: {
+                        name: tool.name,
+                        description: tool.description,
+                        parameters: tool.parameters,
+                    },
+                }));
+            }
+            const url = `${this.config.baseUrl}/chat/completions`;
+            (async () => {
+                try {
+                    const response = await fetch(url, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            ...(this.config.apiKey && {
+                                Authorization: `Bearer ${this.config.apiKey}`,
+                            }),
+                        },
+                        body: JSON.stringify(litellmRequest),
+                        signal: controller.signal,
+                    });
+                    clearTimeout(timeoutId);
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        throw new Error(`LiteLLM API error: ${response.status} ${response.statusText} - ${errorText}`);
+                    }
+                    if (!response.body) {
+                        throw new Error('No response body');
+                    }
+                    const reader = response.body.getReader();
+                    const decoder = new TextDecoder();
+                    let buffer = '';
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            break;
+                        }
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split('\n');
+                        buffer = lines.pop() || '';
+                        for (const line of lines) {
+                            if (!line.trim() || line.trim() === '')
+                                continue;
+                            if (!line.startsWith('data: '))
+                                continue;
+                            const data = line.slice(6).trim();
+                            if (data === '[DONE]')
+                                continue;
+                            try {
+                                const chunk = JSON.parse(data);
+                                subscriber.next(chunk);
+                            }
+                            catch (error) {
+                                this.logger.warn({ error, line }, 'Failed to parse SSE chunk');
+                            }
+                        }
+                    }
+                    subscriber.complete();
+                }
+                catch (error) {
+                    clearTimeout(timeoutId);
+                    subscriber.error(error);
+                }
+            })();
+            return () => {
+                clearTimeout(timeoutId);
+                controller.abort();
+            };
+        });
+    }
+    getModel() {
+        return this.config.model;
+    }
+    updateConfig(updates) {
+        Object.assign(this.config, updates);
+    }
+}
+export const LiteLLM = {
+    novaMicro(baseUrl, apiKey) {
+        return new LiteLLMProvider({
+            baseUrl,
+            model: 'amazon.nova-micro-v1:0',
+            apiKey,
+            temperature: 0.7,
+            maxTokens: 8192,
+        });
+    },
+    novaLite(baseUrl, apiKey, debugLogPath) {
+        return new LiteLLMProvider({
+            baseUrl,
+            model: 'amazon.nova-lite-v1:0',
+            apiKey,
+            temperature: 0.7,
+            maxTokens: 8192,
+            debugLogPath,
+        });
+    },
+    gpt4(baseUrl, apiKey) {
+        return new LiteLLMProvider({
+            baseUrl,
+            model: 'gpt-4',
+            apiKey,
+            temperature: 0.7,
+            maxTokens: 4096,
+        });
+    },
+    gpt4Turbo(baseUrl, apiKey) {
+        return new LiteLLMProvider({
+            baseUrl,
+            model: 'gpt-4-turbo-preview',
+            apiKey,
+            temperature: 0.7,
+            maxTokens: 4096,
+        });
+    },
+    gpt35Turbo(baseUrl, apiKey) {
+        return new LiteLLMProvider({
+            baseUrl,
+            model: 'gpt-3.5-turbo',
+            apiKey,
+            temperature: 0.7,
+            maxTokens: 4096,
+        });
+    },
+    claude3Opus(baseUrl, apiKey) {
+        return new LiteLLMProvider({
+            baseUrl,
+            model: 'claude-3-opus-20240229',
+            apiKey,
+            temperature: 0.7,
+            maxTokens: 4096,
+        });
+    },
+    claude3Sonnet(baseUrl, apiKey) {
+        return new LiteLLMProvider({
+            baseUrl,
+            model: 'claude-3-sonnet-20240229',
+            apiKey,
+            temperature: 0.7,
+            maxTokens: 4096,
+        });
+    },
+    claude3Haiku(baseUrl, apiKey) {
+        return new LiteLLMProvider({
+            baseUrl,
+            model: 'claude-3-haiku-20240307',
+            apiKey,
+            temperature: 0.7,
+            maxTokens: 4096,
+        });
+    },
+    ollama(baseUrl, model) {
+        return new LiteLLMProvider({
+            baseUrl,
+            model: `ollama/${model}`,
+            temperature: 0.7,
+            maxTokens: 2048,
+        });
+    },
+};

package/dist/server/event-buffer.d.ts

@@ -0,0 +1,37 @@
+import type { AnyEvent } from '../types/event';
+export interface BufferedEvent {
+    id: string;
+    event: AnyEvent;
+    timestamp: number;
+}
+export interface EventBufferConfig {
+    maxSize?: number;
+    ttl?: number;
+    autoCleanup?: boolean;
+    cleanupInterval?: number;
+}
+export declare class EventBuffer {
+    private buffers;
+    private eventCounters;
+    private cleanupTimer?;
+    private readonly maxSize;
+    private readonly ttl;
+    private readonly autoCleanup;
+    private readonly cleanupInterval;
+    constructor(config?: EventBufferConfig);
+    add(contextId: string, event: AnyEvent): string;
+    getEventsSince(contextId: string, lastEventId: string): BufferedEvent[];
+    getAll(contextId: string): BufferedEvent[];
+    clear(contextId: string): void;
+    clearAll(): void;
+    cleanup(): number;
+    getStats(): {
+        contexts: number;
+        totalEvents: number;
+        averageEventsPerContext: number;
+        oldestEventAge: number;
+    };
+    private startCleanup;
+    stopCleanup(): void;
+    shutdown(): void;
+}

package/dist/server/event-buffer.js

@@ -0,0 +1,116 @@
+export class EventBuffer {
+    buffers = new Map();
+    eventCounters = new Map();
+    cleanupTimer;
+    maxSize;
+    ttl;
+    autoCleanup;
+    cleanupInterval;
+    constructor(config = {}) {
+        this.maxSize = config.maxSize ?? 100;
+        this.ttl = config.ttl ?? 5 * 60 * 1000;
+        this.autoCleanup = config.autoCleanup ?? true;
+        this.cleanupInterval = config.cleanupInterval ?? 30 * 1000;
+        if (this.autoCleanup) {
+            this.startCleanup();
+        }
+    }
+    add(contextId, event) {
+        const counter = (this.eventCounters.get(contextId) ?? 0) + 1;
+        this.eventCounters.set(contextId, counter);
+        const id = `${contextId}-${counter}`;
+        let buffer = this.buffers.get(contextId);
+        if (!buffer) {
+            buffer = [];
+            this.buffers.set(contextId, buffer);
+        }
+        buffer.push({
+            id,
+            event,
+            timestamp: Date.now(),
+        });
+        if (buffer.length > this.maxSize) {
+            buffer.shift();
+        }
+        return id;
+    }
+    getEventsSince(contextId, lastEventId) {
+        const buffer = this.buffers.get(contextId);
+        if (!buffer || buffer.length === 0) {
+            return [];
+        }
+        const lastIndex = buffer.findIndex((e) => e.id === lastEventId);
+        if (lastIndex === -1) {
+            return [];
+        }
+        return buffer.slice(lastIndex + 1);
+    }
+    getAll(contextId) {
+        return this.buffers.get(contextId) ?? [];
+    }
+    clear(contextId) {
+        this.buffers.delete(contextId);
+        this.eventCounters.delete(contextId);
+    }
+    clearAll() {
+        this.buffers.clear();
+        this.eventCounters.clear();
+    }
+    cleanup() {
+        const now = Date.now();
+        let removedCount = 0;
+        for (const [contextId, buffer] of this.buffers.entries()) {
+            const originalLength = buffer.length;
+            const filtered = buffer.filter((e) => now - e.timestamp < this.ttl);
+            if (filtered.length < originalLength) {
+                removedCount += originalLength - filtered.length;
+                if (filtered.length === 0) {
+                    this.buffers.delete(contextId);
+                }
+                else {
+                    this.buffers.set(contextId, filtered);
+                }
+            }
+        }
+        return removedCount;
+    }
+    getStats() {
+        const contexts = this.buffers.size;
+        let totalEvents = 0;
+        let oldestTimestamp = Date.now();
+        for (const buffer of this.buffers.values()) {
+            totalEvents += buffer.length;
+            if (buffer.length > 0) {
+                const oldest = buffer[0].timestamp;
+                if (oldest < oldestTimestamp) {
+                    oldestTimestamp = oldest;
+                }
+            }
+        }
+        return {
+            contexts,
+            totalEvents,
+            averageEventsPerContext: contexts > 0 ? totalEvents / contexts : 0,
+            oldestEventAge: Date.now() - oldestTimestamp,
+        };
+    }
+    startCleanup() {
+        if (this.cleanupTimer) {
+            return;
+        }
+        this.cleanupTimer = setInterval(() => {
+            this.cleanup();
+        }, this.cleanupInterval);
+        this.cleanupTimer.unref?.();
+    }
+    stopCleanup() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+    }
+    shutdown() {
+        this.stopCleanup();
+        this.clearAll();
+    }
+}

package/dist/server/event-router.d.ts

@@ -0,0 +1,31 @@
+import type { AnyEvent } from '../types/event';
+export type EventFilter = (event: AnyEvent) => boolean;
+export interface SubscriptionConfig {
+    contextId: string;
+    taskId?: string;
+    filterInternal?: boolean;
+    filter?: EventFilter;
+    includeKinds?: string[];
+    excludeKinds?: string[];
+}
+export interface Subscriber {
+    id: string;
+    config: SubscriptionConfig;
+    send(event: AnyEvent, eventId: string): void;
+    close(): void;
+}
+export declare class EventRouter {
+    private subscribers;
+    subscribe(subscriber: Subscriber): void;
+    unsubscribe(subscriberId: string, contextId: string): void;
+    route(contextId: string, event: AnyEvent, eventId: string): number;
+    private shouldSendToSubscriber;
+    getSubscriberCount(contextId: string): number;
+    getActiveContexts(): string[];
+    getStats(): {
+        totalContexts: number;
+        totalSubscribers: number;
+        averageSubscribersPerContext: number;
+    };
+    clear(): void;
+}