@inkeep/agents-run-api 0.0.0-dev-20250910232631 → 0.0.0-dev-20250910233151

package/dist/utils/stream-helpers.js

@@ -1,603 +0,0 @@
-import { parsePartialJson } from 'ai';
-export class SSEStreamHelper {
-    stream;
-    requestId;
-    timestamp;
-    // Stream queuing for proper event ordering
-    isTextStreaming = false;
-    queuedOperations = [];
-    constructor(stream, requestId, timestamp) {
-        this.stream = stream;
-        this.requestId = requestId;
-        this.timestamp = timestamp;
-    }
-    /**
-     * Write the initial role message
-     */
-    async writeRole(role = 'assistant') {
-        await this.stream.writeSSE({
-            data: JSON.stringify({
-                id: this.requestId,
-                object: 'chat.completion.chunk',
-                created: this.timestamp,
-                choices: [
-                    {
-                        index: 0,
-                        delta: {
-                            role,
-                        },
-                        finish_reason: null,
-                    },
-                ],
-            }),
-        });
-    }
-    /**
-     * Write content chunk
-     */
-    async writeContent(content) {
-        await this.stream.writeSSE({
-            data: JSON.stringify({
-                id: this.requestId,
-                object: 'chat.completion.chunk',
-                created: this.timestamp,
-                choices: [
-                    {
-                        index: 0,
-                        delta: {
-                            content,
-                        },
-                        finish_reason: null,
-                    },
-                ],
-            }),
-        });
-    }
-    /**
-     * Stream text word by word with optional delay
-     */
-    async streamText(text, delayMs = 100) {
-        const words = text.split(' ');
-        // Mark that text streaming is starting
-        this.isTextStreaming = true;
-        try {
-            for (let i = 0; i < words.length; i++) {
-                await this.stream.sleep(delayMs);
-                const content = i === 0 ? words[i] : ` ${words[i]}`;
-                await this.writeContent(content);
-            }
-        }
-        finally {
-            // Mark that text streaming has finished
-            this.isTextStreaming = false;
-            // Flush any queued operations now that text sequence is complete
-            await this.flushQueuedOperations();
-        }
-    }
-    async streamData(data) {
-        await this.writeContent(JSON.stringify(data));
-    }
-    /**
-     * Write error message
-     */
-    async writeError(errorMessage) {
-        await this.writeContent(`\n\n${errorMessage}`);
-    }
-    /**
-     * Write the final completion message
-     */
-    async writeCompletion(finishReason = 'stop') {
-        await this.stream.writeSSE({
-            data: JSON.stringify({
-                id: this.requestId,
-                object: 'chat.completion.chunk',
-                created: this.timestamp,
-                choices: [
-                    {
-                        index: 0,
-                        delta: {},
-                        finish_reason: finishReason,
-                    },
-                ],
-            }),
-        });
-    }
-    /**
-     * Write the final [DONE] message
-     */
-    async writeDone() {
-        await this.stream.writeSSE({
-            data: '[DONE]',
-        });
-    }
-    /**
-     * Complete the stream with finish reason and done message
-     */
-    async complete(finishReason = 'stop') {
-        // Flush any remaining queued operations before completing
-        await this.flushQueuedOperations();
-        await this.writeCompletion(finishReason);
-        await this.writeDone();
-    }
-    async writeData(type, data) {
-        await this.stream.writeSSE({
-            data: JSON.stringify({
-                id: this.requestId,
-                object: 'chat.completion.chunk',
-                created: this.timestamp,
-                choices: [
-                    {
-                        index: 0,
-                        delta: {
-                            content: JSON.stringify({ type, data }),
-                        },
-                        finish_reason: null,
-                    },
-                ],
-            }),
-        });
-    }
-    async writeOperation(operation) {
-        if (operation.type === 'status_update' && operation.ctx.label) {
-            operation = {
-                type: operation.type,
-                label: operation.ctx.label,
-                ctx: operation.ctx.data,
-            };
-        }
-        // Queue operation if text is currently streaming
-        if (this.isTextStreaming) {
-            this.queuedOperations.push(operation);
-            return;
-        }
-        // If not streaming, flush any queued operations first, then send this one
-        await this.flushQueuedOperations();
-        await this.writeData('data-operation', operation);
-    }
-    /**
-     * Flush all queued operations in order after text streaming completes
-     */
-    async flushQueuedOperations() {
-        if (this.queuedOperations.length === 0) {
-            return;
-        }
-        const operationsToFlush = [...this.queuedOperations];
-        this.queuedOperations = []; // Clear the queue
-        for (const operation of operationsToFlush) {
-            await this.writeData('data-operation', operation);
-        }
-    }
-}
-/**
- * Factory function to create SSE stream helper
- */
-export function createSSEStreamHelper(stream, requestId, timestamp) {
-    return new SSEStreamHelper(stream, requestId, timestamp);
-}
-export class VercelDataStreamHelper {
-    writer;
-    textId = null;
-    jsonBuffer = '';
-    sentItems = new Map(); // Track what we've sent for each index
-    completedItems = new Set(); // Track completed items
-    sessionId;
-    // Memory management - focused on connection completion cleanup
-    static MAX_BUFFER_SIZE = 5 * 1024 * 1024; // 5MB limit (more generous during request)
-    isCompleted = false;
-    // Stream queuing for proper event ordering
-    isTextStreaming = false;
-    queuedOperations = [];
-    // Timing tracking for text sequences (text-end to text-start gap)
-    lastTextEndTimestamp = 0;
-    TEXT_GAP_THRESHOLD = 1000; // milliseconds - if gap between text sequences is less than this, queue operations
-    // Connection management and forced cleanup
-    connectionDropTimer;
-    MAX_LIFETIME_MS = 600_000; // 10 minutes max lifetime
-    constructor(writer) {
-        this.writer = writer;
-        // Set maximum lifetime timer to prevent memory leaks from abandoned connections
-        this.connectionDropTimer = setTimeout(() => {
-            this.forceCleanup('Connection lifetime exceeded');
-        }, this.MAX_LIFETIME_MS);
-    }
-    setSessionId(sessionId) {
-        this.sessionId = sessionId;
-    }
-    // This mirrors SSEStreamHelper API but outputs using Vercel AI SDK writer
-    async writeRole(_ = 'assistant') {
-        // noop
-    }
-    async writeContent(content) {
-        if (this.isCompleted) {
-            console.warn('Attempted to write content to completed stream');
-            return;
-        }
-        if (!this.textId)
-            this.textId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        // Only prevent catastrophic buffer growth during request
-        if (this.jsonBuffer.length + content.length > VercelDataStreamHelper.MAX_BUFFER_SIZE) {
-            // JSON-aware truncation to prevent corruption
-            const newBuffer = this.truncateJsonBufferSafely(this.jsonBuffer);
-            // If we couldn't find a safe truncation point, clear the buffer entirely
-            // This is safer than keeping potentially corrupted JSON
-            if (newBuffer.length === this.jsonBuffer.length) {
-                console.warn('VercelDataStreamHelper: Could not find safe JSON truncation point, clearing buffer');
-                this.jsonBuffer = '';
-                // Clear tracking as we're starting fresh
-                this.sentItems.clear();
-            }
-            else {
-                this.jsonBuffer = newBuffer;
-                // Update tracking indices based on the new buffer content
-                this.reindexSentItems();
-            }
-        }
-        this.jsonBuffer += content;
-        const { value, state } = await parsePartialJson(this.jsonBuffer);
-        if (!['repaired-parse', 'successful-parse'].includes(state))
-            return;
-        if (!Array.isArray(value))
-            return;
-        for (let i = 0; i < value.length; i++) {
-            const { type, ...data } = value[i];
-            // TODO: Check for kind data and JSON.stringify
-            // Create a content hash to check if this item has changed
-            const currentContent = JSON.stringify(data);
-            const lastSentContent = this.sentItems.get(i);
-            // Only send if content has changed or is new
-            if (currentContent !== lastSentContent) {
-                const chunk = {
-                    type: 'data-component',
-                    id: `${this.textId}-${i}`,
-                    data: { type, ...data },
-                };
-                this.writer.write(chunk);
-                this.sentItems.set(i, currentContent);
-            }
-        }
-    }
-    async streamText(text, delayMs = 100) {
-        if (this.isCompleted) {
-            console.warn('Attempted to stream text to completed stream');
-            return;
-        }
-        // For plain text, write directly to the stream as text chunks
-        if (!this.textId)
-            this.textId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        // ------------------------------
-        // New Vercel data-stream v2 format
-        // ------------------------------
-        // Emit "text-start" once at the beginning, followed by a single "text-delta"
-        // for the entire text chunk, and finish with "text-end".
-        // Don't artificially split by words - let the agent determine chunk boundaries.
-        const id = this.textId;
-        // Check gap from last text-end to this text-start
-        const startTime = Date.now();
-        const gapFromLastSequence = this.lastTextEndTimestamp > 0
-            ? startTime - this.lastTextEndTimestamp
-            : Number.MAX_SAFE_INTEGER;
-        // If gap is large enough, flush any queued operations before starting new text
-        if (gapFromLastSequence >= this.TEXT_GAP_THRESHOLD) {
-            await this.flushQueuedOperations();
-        }
-        // Mark that text streaming is starting
-        this.isTextStreaming = true;
-        try {
-            this.writer.write({
-                type: 'text-start',
-                id,
-            });
-            // Optional delay before sending the text chunk
-            if (delayMs > 0) {
-                await new Promise((r) => setTimeout(r, delayMs));
-            }
-            // Send the entire text as a single delta
-            this.writer.write({
-                type: 'text-delta',
-                id,
-                delta: text,
-            });
-            // End
-            this.writer.write({
-                type: 'text-end',
-                id,
-            });
-            // Track when this text sequence ended
-            this.lastTextEndTimestamp = Date.now();
-        }
-        finally {
-            // Mark that text streaming has finished
-            this.isTextStreaming = false;
-            // DO NOT flush operations here - wait for gap threshold
-        }
-    }
-    async writeData(type, data) {
-        if (this.isCompleted) {
-            console.warn('Attempted to write data to completed stream');
-            return;
-        }
-        // For data-artifact, check if we should delay it based on text timing
-        if (type === 'data-artifact') {
-            const now = Date.now();
-            const gapFromLastTextEnd = this.lastTextEndTimestamp > 0 ? now - this.lastTextEndTimestamp : Number.MAX_SAFE_INTEGER;
-            // If we're within the gap threshold from last text-end, it means more text might be coming
-            // In this case, write the artifact but don't reset timing - let operations stay queued
-            if (this.isTextStreaming || gapFromLastTextEnd < this.TEXT_GAP_THRESHOLD) {
-                // Artifact arrives during or shortly after text - maintain timing continuity
-                this.writer.write({
-                    type: `${type}`,
-                    data,
-                });
-                return;
-            }
-        }
-        this.writer.write({
-            type: `${type}`,
-            data,
-        });
-    }
-    async writeError(errorMessage) {
-        if (this.isCompleted) {
-            console.warn('Attempted to write error to completed stream');
-            return;
-        }
-        this.writer.write({
-            type: 'error',
-            errorText: errorMessage,
-        });
-    }
-    async streamData(data) {
-        await this.writeContent(JSON.stringify(data));
-    }
-    async mergeStream(stream) {
-        if (this.isCompleted) {
-            console.warn('Attempted to merge stream to completed stream');
-            return;
-        }
-        this.writer.merge(stream);
-    }
-    async writeCompletion(_finishReason = 'stop') {
-        // Completion is handled automatically by Vercel's writer
-    }
-    async writeDone() {
-        // Done is handled automatically by Vercel's writer
-    }
-    /**
-     * Complete the stream and clean up all memory
-     * This is the primary cleanup point to prevent memory leaks between requests
-     */
-    async complete() {
-        if (this.isCompleted)
-            return;
-        // Flush any remaining queued operations before completing
-        await this.flushQueuedOperations();
-        // Mark as completed to prevent further writes
-        this.isCompleted = true;
-        // Clean up all buffers and references
-        this.cleanup();
-    }
-    /**
-     * Clean up all memory allocations
-     * Should be called when the stream helper is no longer needed
-     */
-    cleanup() {
-        // Clear the connection drop timer
-        if (this.connectionDropTimer) {
-            clearTimeout(this.connectionDropTimer);
-            this.connectionDropTimer = undefined;
-        }
-        this.jsonBuffer = '';
-        this.sentItems.clear();
-        this.completedItems.clear();
-        this.textId = null;
-        this.queuedOperations = [];
-        this.isTextStreaming = false;
-    }
-    /**
-     * JSON-aware buffer truncation that preserves complete JSON structures
-     */
-    truncateJsonBufferSafely(buffer) {
-        const keepSize = Math.floor(VercelDataStreamHelper.MAX_BUFFER_SIZE * 0.6); // Be more conservative
-        if (buffer.length <= keepSize)
-            return buffer;
-        // Start from the end and work backwards to find complete JSON structures
-        let depth = 0;
-        let inString = false;
-        let escaping = false;
-        let lastCompleteStructureEnd = -1;
-        // Scan backwards from the target keep size
-        for (let i = Math.min(keepSize + 1000, buffer.length - 1); i >= keepSize; i--) {
-            const char = buffer[i];
-            if (escaping) {
-                escaping = false;
-                continue;
-            }
-            if (char === '\\') {
-                escaping = true;
-                continue;
-            }
-            if (char === '"') {
-                inString = !inString;
-                continue;
-            }
-            if (inString)
-                continue;
-            if (char === '}' || char === ']') {
-                depth++;
-            }
-            else if (char === '{' || char === '[') {
-                depth--;
-                // If we've returned to depth 0, we have a complete structure
-                if (depth === 0) {
-                    lastCompleteStructureEnd = i - 1;
-                    break;
-                }
-            }
-        }
-        // If we found a safe truncation point, use it
-        if (lastCompleteStructureEnd > 0) {
-            return buffer.slice(lastCompleteStructureEnd + 1);
-        }
-        // Fallback: look for newlines between structures
-        for (let i = keepSize; i < Math.min(keepSize + 500, buffer.length); i++) {
-            if (buffer[i] === '\n' && buffer[i + 1] && buffer[i + 1].match(/[{[]]/)) {
-                return buffer.slice(i + 1);
-            }
-        }
-        // Return original buffer if no safe point found (caller will handle clearing)
-        return buffer;
-    }
-    /**
-     * Reindex sent items after buffer truncation
-     */
-    reindexSentItems() {
-        // After truncation, we need to clear sent items as indices are no longer valid
-        this.sentItems.clear();
-        this.completedItems.clear();
-    }
-    /**
-     * Force cleanup on connection drop or timeout
-     */
-    forceCleanup(reason) {
-        console.warn(`VercelDataStreamHelper: Forcing cleanup - ${reason}`);
-        // Mark as completed to prevent further writes
-        this.isCompleted = true;
-        // Clean up all resources
-        this.cleanup();
-        // Try to write an error if the writer is still available
-        try {
-            if (this.writer && !this.isCompleted) {
-                this.writer.write({
-                    type: 'error',
-                    errorText: `Stream terminated: ${reason}`,
-                });
-            }
-        }
-        catch (e) {
-            // Writer may be unavailable, ignore errors
-        }
-    }
-    /**
-     * Check if the stream has been completed and cleaned up
-     */
-    isStreamCompleted() {
-        return this.isCompleted;
-    }
-    /**
-     * Get current memory usage stats (for debugging/monitoring)
-     */
-    getMemoryStats() {
-        return {
-            bufferSize: this.jsonBuffer.length,
-            sentItemsCount: this.sentItems.size,
-            completedItemsCount: this.completedItems.size,
-            isCompleted: this.isCompleted,
-        };
-    }
-    async writeOperation(operation) {
-        if (this.isCompleted) {
-            console.warn('Attempted to write operation to completed stream');
-            return;
-        }
-        if (operation.type === 'status_update' && operation.ctx.label) {
-            operation = {
-                type: operation.type,
-                label: operation.ctx.label, // Preserve the label for the UI
-                ctx: operation.ctx.data,
-            };
-        }
-        // Check timing gap from last text-end
-        const now = Date.now();
-        const gapFromLastTextEnd = this.lastTextEndTimestamp > 0 ? now - this.lastTextEndTimestamp : Number.MAX_SAFE_INTEGER;
-        // ALWAYS queue operation if:
-        // 1. Text is currently streaming, OR
-        // 2. We're within the gap threshold from last text-end (more text might be coming)
-        if (this.isTextStreaming || gapFromLastTextEnd < this.TEXT_GAP_THRESHOLD) {
-            this.queuedOperations.push(operation);
-            return;
-        }
-        // If not streaming and gap is large enough, flush any queued operations first, then send this one
-        await this.flushQueuedOperations();
-        this.writer.write({
-            id: 'id' in operation ? operation.id : undefined,
-            type: 'data-operation',
-            data: operation,
-        });
-    }
-    /**
-     * Flush all queued operations in order after text streaming completes
-     */
-    async flushQueuedOperations() {
-        if (this.queuedOperations.length === 0) {
-            return;
-        }
-        const operationsToFlush = [...this.queuedOperations];
-        this.queuedOperations = []; // Clear the queue
-        for (const operation of operationsToFlush) {
-            this.writer.write({
-                id: 'id' in operation ? operation.id : undefined,
-                type: 'data-operation',
-                data: operation,
-            });
-        }
-    }
-}
-export function createVercelStreamHelper(writer) {
-    return new VercelDataStreamHelper(writer);
-}
-/**
- * MCP Stream Helper that captures content instead of streaming
- * Used for MCP tool responses which require a single response message
- */
-export class MCPStreamHelper {
-    capturedText = '';
-    capturedData = [];
-    capturedOperations = [];
-    hasError = false;
-    errorMessage = '';
-    sessionId;
-    setSessionId(sessionId) {
-        this.sessionId = sessionId;
-    }
-    async writeRole(_role) {
-        // No-op for MCP
-    }
-    async writeContent(content) {
-        this.capturedText += content;
-    }
-    async streamText(text, _delayMs) {
-        // Capture text without streaming delay
-        this.capturedText += text;
-    }
-    async streamData(data) {
-        this.capturedData.push(data);
-    }
-    async writeData(_type, data) {
-        this.capturedData.push(data);
-    }
-    async writeError(errorMessage) {
-        this.hasError = true;
-        this.errorMessage = errorMessage;
-    }
-    async complete() {
-        // No-op for MCP
-    }
-    async writeOperation(operation) {
-        this.capturedOperations.push(operation);
-    }
-    /**
-     * Get the captured response for MCP tool result
-     */
-    getCapturedResponse() {
-        return {
-            text: this.capturedText,
-            data: this.capturedData,
-            operations: this.capturedOperations,
-            hasError: this.hasError,
-            errorMessage: this.errorMessage,
-        };
-    }
-}
-export function createMCPStreamHelper() {
-    return new MCPStreamHelper();
-}

package/dist/utils/stream-registry.d.ts

@@ -1,18 +0,0 @@
-import type { StreamHelper } from './stream-helpers';
-/**
- * Register a StreamHelper for a specific request ID
- */
-export declare function registerStreamHelper(requestId: string, streamHelper: StreamHelper): void;
-/**
- * Get a StreamHelper by request ID
- */
-export declare function getStreamHelper(requestId: string): StreamHelper | undefined;
-/**
- * Unregister a StreamHelper for a specific request ID
- */
-export declare function unregisterStreamHelper(requestId: string): void;
-/**
- * Get registry size (for debugging)
- */
-export declare function getRegistrySize(): number;
-//# sourceMappingURL=stream-registry.d.ts.map

package/dist/utils/stream-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-registry.d.ts","sourceRoot":"","sources":["../../src/utils/stream-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAQrD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI,CAOxF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAE3E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAE9D;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAExC"}

package/dist/utils/stream-registry.js

@@ -1,33 +0,0 @@
-/**
- * Global registry for StreamHelper instances
- * Allows agents to access streamHelper via requestId across A2A boundaries
- */
-const streamHelperRegistry = new Map();
-/**
- * Register a StreamHelper for a specific request ID
- */
-export function registerStreamHelper(requestId, streamHelper) {
-    streamHelperRegistry.set(requestId, streamHelper);
-    // Set sessionId for stream helpers that support it
-    if ('setSessionId' in streamHelper && typeof streamHelper.setSessionId === 'function') {
-        streamHelper.setSessionId(requestId);
-    }
-}
-/**
- * Get a StreamHelper by request ID
- */
-export function getStreamHelper(requestId) {
-    return streamHelperRegistry.get(requestId);
-}
-/**
- * Unregister a StreamHelper for a specific request ID
- */
-export function unregisterStreamHelper(requestId) {
-    streamHelperRegistry.delete(requestId);
-}
-/**
- * Get registry size (for debugging)
- */
-export function getRegistrySize() {
-    return streamHelperRegistry.size;
-}