npm - @looopy-ai/core - Versions diffs - 1.0.1 - Mend

@looopy-ai/core 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (132) hide show

package/LICENSE +9 -0
package/dist/core/agent.d.ts +53 -0
package/dist/core/agent.js +416 -0
package/dist/core/cleanup.d.ts +12 -0
package/dist/core/cleanup.js +45 -0
package/dist/core/index.d.ts +3 -0
package/dist/core/index.js +3 -0
package/dist/core/iteration.d.ts +5 -0
package/dist/core/iteration.js +60 -0
package/dist/core/logger.d.ts +11 -0
package/dist/core/logger.js +31 -0
package/dist/core/loop.d.ts +5 -0
package/dist/core/loop.js +125 -0
package/dist/core/tools.d.ts +4 -0
package/dist/core/tools.js +78 -0
package/dist/core/types.d.ts +30 -0
package/dist/core/types.js +1 -0
package/dist/events/index.d.ts +3 -0
package/dist/events/index.js +2 -0
package/dist/events/utils.d.ts +250 -0
package/dist/events/utils.js +263 -0
package/dist/index.d.ts +8 -0
package/dist/index.js +8 -0
package/dist/observability/index.d.ts +1 -0
package/dist/observability/index.js +1 -0
package/dist/observability/spans/agent-turn.d.ts +31 -0
package/dist/observability/spans/agent-turn.js +94 -0
package/dist/observability/spans/index.d.ts +5 -0
package/dist/observability/spans/index.js +5 -0
package/dist/observability/spans/iteration.d.ts +14 -0
package/dist/observability/spans/iteration.js +41 -0
package/dist/observability/spans/llm-call.d.ts +14 -0
package/dist/observability/spans/llm-call.js +50 -0
package/dist/observability/spans/loop.d.ts +14 -0
package/dist/observability/spans/loop.js +40 -0
package/dist/observability/spans/tool.d.ts +14 -0
package/dist/observability/spans/tool.js +44 -0
package/dist/observability/tracing.d.ts +58 -0
package/dist/observability/tracing.js +203 -0
package/dist/providers/chat-completions/aggregate.d.ts +4 -0
package/dist/providers/chat-completions/aggregate.js +152 -0
package/dist/providers/chat-completions/content.d.ts +25 -0
package/dist/providers/chat-completions/content.js +229 -0
package/dist/providers/chat-completions/index.d.ts +4 -0
package/dist/providers/chat-completions/index.js +4 -0
package/dist/providers/chat-completions/streaming.d.ts +12 -0
package/dist/providers/chat-completions/streaming.js +3 -0
package/dist/providers/chat-completions/types.d.ts +39 -0
package/dist/providers/chat-completions/types.js +1 -0
package/dist/providers/index.d.ts +2 -0
package/dist/providers/index.js +1 -0
package/dist/providers/litellm-provider.d.ts +43 -0
package/dist/providers/litellm-provider.js +377 -0
package/dist/server/event-buffer.d.ts +37 -0
package/dist/server/event-buffer.js +116 -0
package/dist/server/event-router.d.ts +31 -0
package/dist/server/event-router.js +91 -0
package/dist/server/index.d.ts +3 -0
package/dist/server/index.js +3 -0
package/dist/server/sse.d.ts +60 -0
package/dist/server/sse.js +159 -0
package/dist/stores/artifacts/artifact-scheduler.d.ts +50 -0
package/dist/stores/artifacts/artifact-scheduler.js +86 -0
package/dist/stores/artifacts/index.d.ts +3 -0
package/dist/stores/artifacts/index.js +3 -0
package/dist/stores/artifacts/internal-event-artifact-store.d.ts +54 -0
package/dist/stores/artifacts/internal-event-artifact-store.js +126 -0
package/dist/stores/artifacts/memory-artifact-store.d.ts +52 -0
package/dist/stores/artifacts/memory-artifact-store.js +268 -0
package/dist/stores/filesystem/filesystem-agent-store.d.ts +18 -0
package/dist/stores/filesystem/filesystem-agent-store.js +61 -0
package/dist/stores/filesystem/filesystem-artifact-store.d.ts +59 -0
package/dist/stores/filesystem/filesystem-artifact-store.js +325 -0
package/dist/stores/filesystem/filesystem-context-store.d.ts +37 -0
package/dist/stores/filesystem/filesystem-context-store.js +245 -0
package/dist/stores/filesystem/filesystem-message-store.d.ts +28 -0
package/dist/stores/filesystem/filesystem-message-store.js +149 -0
package/dist/stores/filesystem/filesystem-task-state-store.d.ts +27 -0
package/dist/stores/filesystem/filesystem-task-state-store.js +220 -0
package/dist/stores/filesystem/index.d.ts +10 -0
package/dist/stores/filesystem/index.js +5 -0
package/dist/stores/index.d.ts +5 -0
package/dist/stores/index.js +5 -0
package/dist/stores/memory/memory-state-store.d.ts +15 -0
package/dist/stores/memory/memory-state-store.js +55 -0
package/dist/stores/messages/hybrid-message-store.d.ts +29 -0
package/dist/stores/messages/hybrid-message-store.js +72 -0
package/dist/stores/messages/index.d.ts +4 -0
package/dist/stores/messages/index.js +4 -0
package/dist/stores/messages/interfaces.d.ts +42 -0
package/dist/stores/messages/interfaces.js +18 -0
package/dist/stores/messages/mem0-message-store.d.ts +34 -0
package/dist/stores/messages/mem0-message-store.js +218 -0
package/dist/stores/messages/memory-message-store.d.ts +27 -0
package/dist/stores/messages/memory-message-store.js +183 -0
package/dist/tools/artifact-tools.d.ts +4 -0
package/dist/tools/artifact-tools.js +277 -0
package/dist/tools/client-tool-provider.d.ts +25 -0
package/dist/tools/client-tool-provider.js +139 -0
package/dist/tools/index.d.ts +4 -0
package/dist/tools/index.js +4 -0
package/dist/tools/local-tools.d.ts +13 -0
package/dist/tools/local-tools.js +70 -0
package/dist/tools/mcp-client.d.ts +29 -0
package/dist/tools/mcp-client.js +62 -0
package/dist/tools/mcp-tool-provider.d.ts +22 -0
package/dist/tools/mcp-tool-provider.js +86 -0
package/dist/types/a2a.d.ts +36 -0
package/dist/types/a2a.js +1 -0
package/dist/types/agent.d.ts +14 -0
package/dist/types/agent.js +1 -0
package/dist/types/artifact.d.ts +126 -0
package/dist/types/artifact.js +1 -0
package/dist/types/context.d.ts +13 -0
package/dist/types/context.js +1 -0
package/dist/types/event.d.ts +360 -0
package/dist/types/event.js +30 -0
package/dist/types/index.d.ts +9 -0
package/dist/types/index.js +9 -0
package/dist/types/llm.d.ts +24 -0
package/dist/types/llm.js +1 -0
package/dist/types/message.d.ts +9 -0
package/dist/types/message.js +1 -0
package/dist/types/state.d.ts +86 -0
package/dist/types/state.js +1 -0
package/dist/types/tools.d.ts +57 -0
package/dist/types/tools.js +53 -0
package/dist/utils/error.d.ts +8 -0
package/dist/utils/error.js +23 -0
package/dist/utils/process-signals.d.ts +3 -0
package/dist/utils/process-signals.js +67 -0
package/package.json +54 -0

package/dist/observability/tracing.d.ts ADDED Viewed

@@ -0,0 +1,58 @@
+import { type Tracer } from '@opentelemetry/api';
+export interface TraceContext {
+    traceId: string;
+    spanId: string;
+    traceFlags?: number;
+    traceState?: string;
+}
+export interface TelemetryConfig {
+    serviceName?: string;
+    serviceVersion?: string;
+    environment?: string;
+    otlpEndpoint?: string;
+    enabled?: boolean;
+}
+export declare function initializeTracing(config?: TelemetryConfig): Tracer;
+export declare function getTracer(): Tracer;
+export declare function shutdownTracing(): Promise<void>;
+export declare const SpanAttributes: {
+    readonly SESSION_ID: "session.id";
+    readonly USER_ID: "user.id";
+    readonly AGENT_ID: "agent.id";
+    readonly TASK_ID: "agent.task.id";
+    readonly ITERATION: "agent.iteration";
+    readonly TOOL_NAME: "agent.tool.name";
+    readonly TOOL_CALL_ID: "agent.tool.call_id";
+    readonly LLM_MODEL: "llm.model";
+    readonly LLM_FINISH_REASON: "llm.finish_reason";
+    readonly SUB_AGENT_ID: "agent.sub_agent.id";
+    readonly SUB_AGENT_TASK_ID: "agent.sub_agent.task_id";
+    readonly OUTPUT: "output";
+    readonly LANGFUSE_OBSERVATION_TYPE: "langfuse.observation.type";
+    readonly LANGFUSE_TAGS: "langfuse.tags";
+    readonly LANGFUSE_METADATA: "langfuse.metadata";
+    readonly LANGFUSE_VERSION: "langfuse.version";
+    readonly LANGFUSE_RELEASE: "langfuse.release";
+    readonly GEN_AI_SYSTEM: "gen_ai.system";
+    readonly GEN_AI_REQUEST_MODEL: "gen_ai.request.model";
+    readonly GEN_AI_RESPONSE_MODEL: "gen_ai.response.model";
+    readonly GEN_AI_PROMPT: "gen_ai.prompt";
+    readonly GEN_AI_COMPLETION: "gen_ai.completion";
+    readonly GEN_AI_USAGE_PROMPT_TOKENS: "gen_ai.usage.prompt_tokens";
+    readonly GEN_AI_USAGE_COMPLETION_TOKENS: "gen_ai.usage.completion_tokens";
+    readonly GEN_AI_USAGE_TOTAL_TOKENS: "gen_ai.usage.total_tokens";
+    readonly GEN_AI_USAGE_COMPLETION_TOKENS_DETAILS: "gen_ai.usage.completion_tokens_details";
+    readonly GEN_AI_USAGE_PROMPT_TOKENS_DETAILS: "gen_ai.usage.prompt_tokens_details";
+    readonly GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS: "gen_ai.usage.cache_creation_input_tokens";
+    readonly GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS: "gen_ai.usage.cache_read_input_tokens";
+};
+export declare const SpanNames: {
+    readonly LOOP_START: "loop.start";
+    readonly LOOP_ITERATION: "loop.iteration";
+    readonly LLM_CALL: "llm.call";
+    readonly TOOL_EXECUTE: "tool.execute";
+    readonly TOOL_PROVIDE: "tool.provide";
+    readonly SUB_AGENT_INVOKE: "agent.invoke";
+    readonly CHECKPOINT_SAVE: "checkpoint.save";
+    readonly CHECKPOINT_LOAD: "checkpoint.load";
+};

package/dist/observability/tracing.js ADDED Viewed

@@ -0,0 +1,203 @@
+import { trace } from '@opentelemetry/api';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from '@opentelemetry/semantic-conventions/incubating';
+import { DEFAULT_LOGGER } from '../core/logger';
+let tracerProvider = null;
+let defaultTracer = null;
+function parseOTLPError(error) {
+    const errorDetails = {
+        message: error instanceof Error ? error.message : String(error),
+    };
+    if (!error || typeof error !== 'object') {
+        return errorDetails;
+    }
+    if ('code' in error) {
+        errorDetails.statusCode = error.code;
+    }
+    if ('data' in error && typeof error.data === 'string') {
+        const data = error.data;
+        errorDetails.responsePreview =
+            data.length > 500
+                ? `${data.substring(0, 500)}... (truncated ${data.length - 500} chars)`
+                : data;
+        if (data.includes('<!DOCTYPE html>')) {
+            errorDetails.likelyIssue =
+                'Endpoint returned HTML instead of accepting OTLP - wrong URL or missing/invalid auth';
+        }
+        else if (data.includes('Unauthorized') || data.includes('401')) {
+            errorDetails.likelyIssue = 'Authentication failed - check OTEL_EXPORTER_OTLP_HEADERS';
+        }
+        else if (data.includes('Forbidden') || data.includes('403')) {
+            errorDetails.likelyIssue = 'Access forbidden - check API keys have correct permissions';
+        }
+    }
+    if ('message' in error) {
+        errorDetails.errorMessage = error.message;
+    }
+    return errorDetails;
+}
+function validateAuthHeaders(endpoint) {
+    const headers = process.env.OTEL_EXPORTER_OTLP_HEADERS || '';
+    if (!headers)
+        return;
+    const hasBasicAuth = headers.includes('Authorization=Basic');
+    const hasCustomHeaders = !hasBasicAuth && headers.includes('=');
+    DEFAULT_LOGGER.trace({
+        authType: hasBasicAuth ? 'Basic Auth' : hasCustomHeaders ? 'Custom Headers' : 'Unknown',
+        headerCount: headers.split(',').length,
+    }, 'Authentication headers configured');
+    if (endpoint.includes('langfuse.com') && !hasBasicAuth) {
+        DEFAULT_LOGGER.warn('Langfuse requires Basic Auth format: Authorization=Basic <base64>. Current headers may not work.');
+    }
+}
+function validateOTLPEndpoint(endpoint) {
+    if (endpoint.includes('langfuse.com')) {
+        if (!endpoint.endsWith('/v1/traces')) {
+            DEFAULT_LOGGER.trace({
+                endpoint,
+                correctEndpoint: endpoint.replace(/\/?$/, '/v1/traces'),
+            }, 'Langfuse OTLP endpoint should end with /v1/traces. Exports may fail without this.');
+        }
+    }
+    if (endpoint.includes('/api/public/otel') && !endpoint.includes('/v1/traces')) {
+        DEFAULT_LOGGER.trace({
+            endpoint,
+            suggestion: `${endpoint}/v1/traces`,
+        }, 'OTLP endpoint appears incomplete. Most OTLP collectors require /v1/traces path.');
+    }
+}
+export function initializeTracing(config) {
+    if (!config?.enabled && process.env.OTEL_ENABLED !== 'true') {
+        DEFAULT_LOGGER.trace('OpenTelemetry tracing is disabled');
+        return trace.getTracer('looopy-noop');
+    }
+    const serviceName = config?.serviceName || 'looopy';
+    const serviceVersion = config?.serviceVersion || '1.0.0';
+    const environment = config?.environment || process.env.NODE_ENV || 'development';
+    DEFAULT_LOGGER.trace({
+        serviceName,
+        serviceVersion,
+        environment,
+    }, 'Initializing OpenTelemetry tracing');
+    const resource = resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: serviceName,
+        [ATTR_SERVICE_VERSION]: serviceVersion,
+        'deployment.environment': environment,
+    });
+    const otlpEndpoint = config?.otlpEndpoint ||
+        process.env.OTEL_EXPORTER_OTLP_ENDPOINT ||
+        'http://localhost:4318/v1/traces';
+    const hasAuthHeaders = !!process.env.OTEL_EXPORTER_OTLP_HEADERS;
+    DEFAULT_LOGGER.trace({
+        otlpEndpoint,
+        hasAuthHeaders,
+    }, 'Configuring OTLP exporter');
+    validateOTLPEndpoint(otlpEndpoint);
+    if (hasAuthHeaders) {
+        validateAuthHeaders(otlpEndpoint);
+    }
+    else if (otlpEndpoint.includes('cloud.langfuse.com')) {
+        DEFAULT_LOGGER.trace({
+            otlpEndpoint,
+        }, 'Using Langfuse cloud endpoint without OTEL_EXPORTER_OTLP_HEADERS. Authentication will likely fail.');
+    }
+    const exporter = new OTLPTraceExporter({
+        url: otlpEndpoint,
+    });
+    const originalExport = exporter.export.bind(exporter);
+    exporter.export = (spans, resultCallback) => {
+        DEFAULT_LOGGER.trace({
+            spanCount: spans.length,
+            endpoint: otlpEndpoint,
+        }, 'Exporting spans to OTLP collector');
+        originalExport(spans, (result) => {
+            if (result.code !== 0) {
+                DEFAULT_LOGGER.trace(parseOTLPError(result.error), 'Failed to export spans to OTLP collector');
+            }
+            else {
+                DEFAULT_LOGGER.trace({ spanCount: spans.length }, 'Successfully exported spans');
+            }
+            resultCallback(result);
+        });
+    };
+    const spanProcessor = new BatchSpanProcessor(exporter, {
+        maxQueueSize: 1000,
+        scheduledDelayMillis: 1000,
+        maxExportBatchSize: 512,
+    });
+    tracerProvider = new NodeTracerProvider({
+        resource,
+        spanProcessors: [spanProcessor],
+    });
+    tracerProvider.register();
+    DEFAULT_LOGGER.trace('OpenTelemetry tracing initialized successfully');
+    defaultTracer = tracerProvider.getTracer(serviceName, serviceVersion);
+    return defaultTracer;
+}
+export function getTracer() {
+    if (!defaultTracer) {
+        return initializeTracing();
+    }
+    return defaultTracer;
+}
+export async function shutdownTracing() {
+    if (tracerProvider) {
+        DEFAULT_LOGGER.trace('Shutting down OpenTelemetry tracing');
+        try {
+            await tracerProvider.shutdown();
+            DEFAULT_LOGGER.trace('OpenTelemetry tracing shutdown complete');
+        }
+        catch (error) {
+            const errorDetails = parseOTLPError(error);
+            DEFAULT_LOGGER.error(errorDetails, 'Error during OpenTelemetry shutdown (collector may be unavailable or misconfigured)');
+        }
+        finally {
+            tracerProvider = null;
+            defaultTracer = null;
+        }
+    }
+}
+export const SpanAttributes = {
+    SESSION_ID: 'session.id',
+    USER_ID: 'user.id',
+    AGENT_ID: 'agent.id',
+    TASK_ID: 'agent.task.id',
+    ITERATION: 'agent.iteration',
+    TOOL_NAME: 'agent.tool.name',
+    TOOL_CALL_ID: 'agent.tool.call_id',
+    LLM_MODEL: 'llm.model',
+    LLM_FINISH_REASON: 'llm.finish_reason',
+    SUB_AGENT_ID: 'agent.sub_agent.id',
+    SUB_AGENT_TASK_ID: 'agent.sub_agent.task_id',
+    OUTPUT: 'output',
+    LANGFUSE_OBSERVATION_TYPE: 'langfuse.observation.type',
+    LANGFUSE_TAGS: 'langfuse.tags',
+    LANGFUSE_METADATA: 'langfuse.metadata',
+    LANGFUSE_VERSION: 'langfuse.version',
+    LANGFUSE_RELEASE: 'langfuse.release',
+    GEN_AI_SYSTEM: 'gen_ai.system',
+    GEN_AI_REQUEST_MODEL: 'gen_ai.request.model',
+    GEN_AI_RESPONSE_MODEL: 'gen_ai.response.model',
+    GEN_AI_PROMPT: 'gen_ai.prompt',
+    GEN_AI_COMPLETION: 'gen_ai.completion',
+    GEN_AI_USAGE_PROMPT_TOKENS: 'gen_ai.usage.prompt_tokens',
+    GEN_AI_USAGE_COMPLETION_TOKENS: 'gen_ai.usage.completion_tokens',
+    GEN_AI_USAGE_TOTAL_TOKENS: 'gen_ai.usage.total_tokens',
+    GEN_AI_USAGE_COMPLETION_TOKENS_DETAILS: 'gen_ai.usage.completion_tokens_details',
+    GEN_AI_USAGE_PROMPT_TOKENS_DETAILS: 'gen_ai.usage.prompt_tokens_details',
+    GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS: 'gen_ai.usage.cache_creation_input_tokens',
+    GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS: 'gen_ai.usage.cache_read_input_tokens',
+};
+export const SpanNames = {
+    LOOP_START: 'loop.start',
+    LOOP_ITERATION: 'loop.iteration',
+    LLM_CALL: 'llm.call',
+    TOOL_EXECUTE: 'tool.execute',
+    TOOL_PROVIDE: 'tool.provide',
+    SUB_AGENT_INVOKE: 'agent.invoke',
+    CHECKPOINT_SAVE: 'checkpoint.save',
+    CHECKPOINT_LOAD: 'checkpoint.load',
+};

package/dist/providers/chat-completions/aggregate.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+import { type OperatorFunction } from 'rxjs';
+import type { Choice, LLMUsage } from './types';
+export declare const aggregateChoice: <T extends Choice>() => OperatorFunction<T, T>;
+export declare const aggregateLLMUsage: <T extends LLMUsage>() => OperatorFunction<T, T>;

package/dist/providers/chat-completions/aggregate.js ADDED Viewed

@@ -0,0 +1,152 @@
+import { Observable } from 'rxjs';
+import { InlineXmlParser } from './content';
+const mergeToolCallDelta = (existing, delta) => {
+    if (delta.id) {
+        existing.id = delta.id;
+    }
+    if (delta.function?.name) {
+        existing.function.name = delta.function.name;
+    }
+    if (delta.function?.arguments) {
+        existing.function.arguments += delta.function.arguments;
+    }
+};
+const createToolCallAccumulator = (delta) => ({
+    id: delta.id ?? null,
+    type: 'function',
+    function: {
+        name: delta.function?.name || '',
+        arguments: delta.function?.arguments || '',
+    },
+});
+const processToolCallDeltas = (toolCallsByIndex, deltas) => {
+    for (const toolCallDelta of deltas) {
+        const idx = toolCallDelta.index;
+        const existing = toolCallsByIndex.get(idx);
+        if (!existing) {
+            toolCallsByIndex.set(idx, createToolCallAccumulator(toolCallDelta));
+        }
+        else {
+            mergeToolCallDelta(existing, toolCallDelta);
+        }
+    }
+};
+const finalizeToolCalls = (toolCallsByIndex) => {
+    return Array.from(toolCallsByIndex.entries())
+        .sort(([a], [b]) => a - b)
+        .map(([idx, tc]) => ({
+        index: idx,
+        id: tc.id,
+        type: tc.type,
+        function: tc.function,
+    }));
+};
+const processChoice = (choice, aggregated, toolCallsByIndex, xmlParser) => {
+    if (aggregated.index === undefined) {
+        aggregated.index = choice.index;
+    }
+    if (choice.delta) {
+        if (choice.delta.content) {
+            xmlParser.processChunk(choice.delta.content);
+        }
+        if (choice.delta.tool_calls) {
+            processToolCallDeltas(toolCallsByIndex, choice.delta.tool_calls);
+        }
+    }
+    if (choice.finish_reason) {
+        aggregated.finish_reason = choice.finish_reason;
+    }
+};
+export const aggregateChoice = () => (source) => new Observable((subscriber) => {
+    const aggregated = {};
+    const toolCallsByIndex = new Map();
+    const xmlParser = new InlineXmlParser();
+    const sub = source.subscribe({
+        next: (choice) => {
+            processChoice(choice, aggregated, toolCallsByIndex, xmlParser);
+        },
+        error: (err) => subscriber.error(err),
+        complete: () => {
+            const { content, tags } = xmlParser.finalize();
+            if (content) {
+                aggregated.delta = {
+                    ...aggregated.delta,
+                    content,
+                };
+            }
+            if (tags.length > 0) {
+                aggregated.thoughts = tags;
+            }
+            if (toolCallsByIndex.size > 0) {
+                aggregated.delta = {
+                    ...aggregated.delta,
+                    tool_calls: finalizeToolCalls(toolCallsByIndex),
+                };
+            }
+            subscriber.next(aggregated);
+            subscriber.complete();
+        },
+    });
+    return () => sub.unsubscribe();
+});
+const mergeDetailsObject = (target, source) => {
+    if (!source)
+        return;
+    for (const [key, value] of Object.entries(source)) {
+        if (typeof value === 'number') {
+            target[key] = (target[key] || 0) + value;
+        }
+    }
+};
+const buildAggregatedUsage = (promptTokens, completionTokens, totalTokens, cacheCreationInputTokens, cacheReadInputTokens, completionTokensDetails, promptTokensDetails) => {
+    const aggregated = {};
+    if (promptTokens > 0)
+        aggregated.prompt_tokens = promptTokens;
+    if (completionTokens > 0)
+        aggregated.completion_tokens = completionTokens;
+    if (totalTokens > 0)
+        aggregated.total_tokens = totalTokens;
+    if (cacheCreationInputTokens > 0)
+        aggregated.cache_creation_input_tokens = cacheCreationInputTokens;
+    if (cacheReadInputTokens > 0)
+        aggregated.cache_read_input_tokens = cacheReadInputTokens;
+    if (Object.keys(completionTokensDetails).length > 0) {
+        aggregated.completion_tokens_details = completionTokensDetails;
+    }
+    if (Object.keys(promptTokensDetails).length > 0) {
+        aggregated.prompt_tokens_details = promptTokensDetails;
+    }
+    return aggregated;
+};
+export const aggregateLLMUsage = () => (source) => new Observable((subscriber) => {
+    let promptTokens = 0;
+    let completionTokens = 0;
+    let totalTokens = 0;
+    let cacheCreationInputTokens = 0;
+    let cacheReadInputTokens = 0;
+    const completionTokensDetails = {};
+    const promptTokensDetails = {};
+    const sub = source.subscribe({
+        next: (usage) => {
+            if (usage.prompt_tokens)
+                promptTokens += usage.prompt_tokens;
+            if (usage.completion_tokens)
+                completionTokens += usage.completion_tokens;
+            if (usage.total_tokens)
+                totalTokens += usage.total_tokens;
+            if (usage.cache_creation_input_tokens)
+                cacheCreationInputTokens += usage.cache_creation_input_tokens;
+            if (usage.cache_read_input_tokens)
+                cacheReadInputTokens += usage.cache_read_input_tokens;
+            mergeDetailsObject(completionTokensDetails, usage.completion_tokens_details);
+            mergeDetailsObject(promptTokensDetails, usage.prompt_tokens_details);
+        },
+        error: (err) => subscriber.error(err),
+        complete: () => {
+            const aggregated = buildAggregatedUsage(promptTokens, completionTokens, totalTokens, cacheCreationInputTokens, cacheReadInputTokens, completionTokensDetails, promptTokensDetails);
+            subscriber.next(aggregated);
+            subscriber.complete();
+        },
+    });
+    return () => sub.unsubscribe();
+});

package/dist/providers/chat-completions/content.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import { type Observable } from 'rxjs';
+import type { Choice, InlineXml } from './types';
+type SplitResult = {
+    content: Observable<string>;
+    tags: Observable<InlineXml>;
+};
+export declare const getContent: <T extends Choice>() => import("rxjs").UnaryFunction<Observable<T>, Observable<string>>;
+export declare const splitInlineXml: (source: Observable<string>) => SplitResult;
+export declare const stripInlineXmlTags: (text: string) => string;
+export declare class InlineXmlParser {
+    private buffer;
+    private prevEmittedWasTag;
+    private contentParts;
+    private extractedTags;
+    processChunk(chunk: string): void;
+    finalize(): {
+        content: string;
+        tags: InlineXml[];
+    };
+    private flushParsable;
+    private processTagHead;
+    private processPairedTag;
+    private emitContent;
+}
+export {};

package/dist/providers/chat-completions/content.js ADDED Viewed

@@ -0,0 +1,229 @@
+import { filter, map, pipe, ReplaySubject } from 'rxjs';
+const parseAttributes = (attrsSrc) => {
+    const attrs = {};
+    const re = /([A-Za-z_:][\w:.-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>/]+)))?/g;
+    let m = re.exec(attrsSrc);
+    while (m !== null) {
+        const key = m[1];
+        const val = m[2] ?? m[3] ?? m[4] ?? '';
+        if (key in attrs) {
+            const prev = attrs[key];
+            attrs[key] = Array.isArray(prev) ? [...prev, val] : [prev, val];
+        }
+        else {
+            attrs[key] = val;
+        }
+        m = re.exec(attrsSrc);
+    }
+    return attrs;
+};
+const emitIfNonEmpty = (s, prevWasTag, nextIsTagAhead, push) => {
+    let out = s;
+    if (prevWasTag)
+        out = out.replace(/^\s+/, '');
+    if (nextIsTagAhead)
+        out = out.replace(/\s+$/, '');
+    if (out.length > 0)
+        push(out);
+};
+export const getContent = () => pipe(filter((choice) => !!choice.delta?.content), map((choice) => choice.delta?.content));
+export const splitInlineXml = (source) => {
+    const contentSubj = new ReplaySubject();
+    const tagsSubj = new ReplaySubject();
+    let buffer = '';
+    let prevEmittedWasTag = false;
+    const flushParsable = () => {
+        while (true) {
+            const lt = buffer.indexOf('<');
+            if (lt === -1) {
+                return;
+            }
+            const before = buffer.slice(0, lt);
+            const gt = buffer.indexOf('>', lt + 1);
+            if (gt === -1) {
+                return;
+            }
+            if (before.length) {
+                emitIfNonEmpty(before, prevEmittedWasTag, true, (v) => contentSubj.next(v));
+                prevEmittedWasTag = false;
+            }
+            const tagHead = buffer.slice(lt + 1, gt).trim();
+            buffer = buffer.slice(gt + 1);
+            const selfClose = tagHead.endsWith('/');
+            const isClosing = tagHead.startsWith('/');
+            if (isClosing) {
+                prevEmittedWasTag = true;
+                continue;
+            }
+            const nameMatch = /^([A-Za-z_:][\w:.-]*)([\s\S]*)$/.exec(selfClose ? tagHead.slice(0, -1).trimEnd() : tagHead);
+            if (!nameMatch) {
+                prevEmittedWasTag = true;
+                continue;
+            }
+            const tagName = nameMatch[1];
+            const rawAttrs = nameMatch[2]?.trim() ?? '';
+            const attributes = parseAttributes(rawAttrs);
+            if (selfClose) {
+                tagsSubj.next({ name: tagName, attributes });
+                prevEmittedWasTag = true;
+                continue;
+            }
+            const closeSeq = `</${tagName}>`;
+            const closeIdx = buffer.indexOf(closeSeq);
+            if (closeIdx === -1) {
+                buffer = `<${tagHead}>${buffer}`;
+                return;
+            }
+            const inner = buffer.slice(0, closeIdx);
+            buffer = buffer.slice(closeIdx + closeSeq.length);
+            tagsSubj.next({ name: tagName, content: inner, attributes });
+            prevEmittedWasTag = true;
+        }
+    };
+    const subscription = source.subscribe({
+        next: (chunk) => {
+            buffer += chunk;
+            flushParsable();
+            const nextLt = buffer.indexOf('<');
+            if (nextLt === -1 && buffer.length) {
+                let out = buffer;
+                if (prevEmittedWasTag)
+                    out = out.replace(/^\s+/, '');
+                if (out.length)
+                    contentSubj.next(out);
+                buffer = '';
+                prevEmittedWasTag = false;
+            }
+        },
+        error: (err) => {
+            try {
+                contentSubj.error(err);
+            }
+            finally {
+                tagsSubj.error(err);
+            }
+        },
+        complete: () => {
+            if (buffer.length) {
+                let out = buffer;
+                if (prevEmittedWasTag)
+                    out = out.replace(/^\s+/, '');
+                if (out.length)
+                    contentSubj.next(out);
+                buffer = '';
+            }
+            contentSubj.complete();
+            tagsSubj.complete();
+        },
+    });
+    const finalize = () => subscription.unsubscribe();
+    contentSubj.subscribe({ complete: finalize, error: finalize });
+    tagsSubj.subscribe({ complete: finalize, error: finalize });
+    return { content: contentSubj.asObservable(), tags: tagsSubj.asObservable() };
+};
+export const stripInlineXmlTags = (text) => {
+    let result = text;
+    result = result.replace(/<([A-Za-z_:][\w:.-]*)(?:\s[^>]*)?>([\s\S]*?)<\/\1>/g, ' ');
+    result = result.replace(/<([A-Za-z_:][\w:.-]*)(?:\s[^>]*)?\s*\/>/g, ' ');
+    result = result.replace(/\s+/g, ' ').trim();
+    return result;
+};
+export class InlineXmlParser {
+    buffer = '';
+    prevEmittedWasTag = false;
+    contentParts = [];
+    extractedTags = [];
+    processChunk(chunk) {
+        this.buffer += chunk;
+        this.flushParsable();
+        const nextLt = this.buffer.indexOf('<');
+        if (nextLt === -1 && this.buffer.length) {
+            let out = this.buffer;
+            if (this.prevEmittedWasTag)
+                out = out.replace(/^\s+/, '');
+            if (out.length)
+                this.contentParts.push(out);
+            this.buffer = '';
+            this.prevEmittedWasTag = false;
+        }
+    }
+    finalize() {
+        if (this.buffer.length) {
+            let out = this.buffer;
+            if (this.prevEmittedWasTag)
+                out = out.replace(/^\s+/, '');
+            if (out.length)
+                this.contentParts.push(out);
+            this.buffer = '';
+        }
+        return {
+            content: this.contentParts.join(''),
+            tags: this.extractedTags,
+        };
+    }
+    flushParsable() {
+        while (true) {
+            const lt = this.buffer.indexOf('<');
+            if (lt === -1) {
+                return;
+            }
+            const gt = this.buffer.indexOf('>', lt + 1);
+            if (gt === -1) {
+                return;
+            }
+            if (lt > 0) {
+                this.emitContent(this.buffer.slice(0, lt), true);
+            }
+            const tagHead = this.buffer.slice(lt + 1, gt).trim();
+            this.buffer = this.buffer.slice(gt + 1);
+            if (!this.processTagHead(tagHead)) {
+                return;
+            }
+        }
+    }
+    processTagHead(tagHead) {
+        const selfClose = tagHead.endsWith('/');
+        const isClosing = tagHead.startsWith('/');
+        if (isClosing) {
+            this.prevEmittedWasTag = true;
+            return true;
+        }
+        const nameMatch = /^([A-Za-z_:][\w:.-]*)([\s\S]*)$/.exec(selfClose ? tagHead.slice(0, -1).trimEnd() : tagHead);
+        if (!nameMatch) {
+            this.prevEmittedWasTag = true;
+            return true;
+        }
+        const tagName = nameMatch[1];
+        const attributes = parseAttributes(nameMatch[2]?.trim() ?? '');
+        if (selfClose) {
+            this.extractedTags.push({ name: tagName, attributes });
+            this.prevEmittedWasTag = true;
+            return true;
+        }
+        return this.processPairedTag(tagName, tagHead, attributes);
+    }
+    processPairedTag(tagName, tagHead, attributes) {
+        const closeSeq = `</${tagName}>`;
+        const closeIdx = this.buffer.indexOf(closeSeq);
+        if (closeIdx === -1) {
+            this.buffer = `<${tagHead}>${this.buffer}`;
+            return false;
+        }
+        const inner = this.buffer.slice(0, closeIdx);
+        this.buffer = this.buffer.slice(closeIdx + closeSeq.length);
+        this.extractedTags.push({ name: tagName, content: inner, attributes });
+        this.prevEmittedWasTag = true;
+        return true;
+    }
+    emitContent(s, nextIsTagAhead) {
+        let out = s;
+        if (this.prevEmittedWasTag)
+            out = out.replace(/^\s+/, '');
+        if (nextIsTagAhead)
+            out = out.replace(/\s+$/, '');
+        if (out.length > 0) {
+            this.contentParts.push(out);
+            this.prevEmittedWasTag = false;
+        }
+    }
+}

package/dist/providers/chat-completions/index.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export * from './aggregate';
+export * from './content';
+export * from './streaming';
+export * from './types';

package/dist/providers/chat-completions/index.js ADDED Viewed

@@ -0,0 +1,4 @@
+export * from './aggregate';
+export * from './content';
+export * from './streaming';
+export * from './types';