@olane/o-node 0.7.12-alpha.21 → 0.7.12-alpha.23

package/dist/o-core/src/connection/o-response.d.ts

@@ -0,0 +1,26 @@
+import { JSONRPC_VERSION, RequestId, oResponse as Response, Result } from '@olane/o-protocol';
+export declare class oResponse implements Response {
+    jsonrpc: typeof JSONRPC_VERSION;
+    id: RequestId;
+    result: Result;
+    isStreaming?: boolean;
+    streamChunks?: unknown[];
+    constructor(config: Result & {
+        id: RequestId;
+    });
+    /**
+     * Check if a result is a streaming result
+     */
+    private isStreamingResult;
+    /**
+     * Add a chunk to a streaming response
+     */
+    addChunk(chunk: unknown): void;
+    /**
+     * Get all accumulated chunks for a streaming response
+     */
+    getChunks(): unknown[];
+    toJSON(): any;
+    toString(): string;
+}
+//# sourceMappingURL=o-response.d.ts.map

package/dist/o-core/src/connection/o-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-response.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/connection/o-response.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,SAAS,EACT,SAAS,IAAI,QAAQ,EACrB,MAAM,EAEP,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,SAAU,YAAW,QAAQ;IACxC,OAAO,EAAE,OAAO,eAAe,CAAC;IAChC,EAAE,EAAE,SAAS,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IAGf,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,EAAE,CAAC;gBAEb,MAAM,EAAE,MAAM,GAAG;QAAE,EAAE,EAAE,SAAS,CAAA;KAAE;IAY9C;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAQ9B;;OAEG;IACH,SAAS,IAAI,OAAO,EAAE;IAItB,MAAM,IAAI,GAAG;IAQb,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/o-core/src/connection/o-response.js

@@ -0,0 +1,45 @@
+import { JSONRPC_VERSION, } from '@olane/o-protocol';
+export class oResponse {
+    constructor(config) {
+        this.jsonrpc = JSONRPC_VERSION;
+        this.id = config.id;
+        this.result = config;
+        // Check if this is a streaming result
+        if (this.isStreamingResult(config)) {
+            this.isStreaming = true;
+            this.streamChunks = [config._data];
+        }
+    }
+    /**
+     * Check if a result is a streaming result
+     */
+    isStreamingResult(result) {
+        return '_streaming' in result && result._streaming === true;
+    }
+    /**
+     * Add a chunk to a streaming response
+     */
+    addChunk(chunk) {
+        if (!this.isStreaming) {
+            this.isStreaming = true;
+            this.streamChunks = [];
+        }
+        this.streamChunks.push(chunk);
+    }
+    /**
+     * Get all accumulated chunks for a streaming response
+     */
+    getChunks() {
+        return this.streamChunks || [];
+    }
+    toJSON() {
+        return {
+            jsonrpc: this.jsonrpc,
+            id: this.id,
+            result: this.result,
+        };
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
+}

package/dist/o-core/src/error/enums/codes.error.d.ts

@@ -0,0 +1,20 @@
+export declare enum oErrorCodes {
+    UNKNOWN = 1001,
+    NOT_FOUND = 1002,
+    NOT_IMPLEMENTED = 1003,
+    NOT_CONFIGURED = 1004,
+    NOT_AUTHORIZED = 1005,
+    MISSING_PARAMETERS = 1006,
+    INVALID_PARAMETERS = 1007,
+    INVALID_RESPONSE = 1008,
+    INVALID_REQUEST = 1009,
+    INVALID_STATE = 1010,
+    INVALID_ACTION = 1011,
+    INVALID_CREDENTIALS = 1012,
+    TRANSPORT_NOT_SUPPORTED = 1013,
+    FAILED_TO_DIAL_TARGET = 1014,
+    INVALID_CAPABILITY = 1015,
+    CONNECTION_LIMIT_REACHED = 1016,
+    TIMEOUT = 1017
+}
+//# sourceMappingURL=codes.error.d.ts.map

package/dist/o-core/src/error/enums/codes.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codes.error.d.ts","sourceRoot":"","sources":["../../../../../../o-core/src/error/enums/codes.error.ts"],"names":[],"mappings":"AAAA,oBAAY,WAAW;IACrB,OAAO,OAAO;IACd,SAAS,OAAO;IAChB,eAAe,OAAO;IACtB,cAAc,OAAO;IACrB,cAAc,OAAO;IACrB,kBAAkB,OAAO;IACzB,kBAAkB,OAAO;IACzB,gBAAgB,OAAO;IACvB,eAAe,OAAO;IACtB,aAAa,OAAO;IACpB,cAAc,OAAO;IACrB,mBAAmB,OAAO;IAC1B,uBAAuB,OAAO;IAC9B,qBAAqB,OAAO;IAC5B,kBAAkB,OAAO;IACzB,wBAAwB,OAAO;IAC/B,OAAO,OAAO;CACf"}

package/dist/o-core/src/error/enums/codes.error.js

@@ -0,0 +1,20 @@
+export var oErrorCodes;
+(function (oErrorCodes) {
+    oErrorCodes[oErrorCodes["UNKNOWN"] = 1001] = "UNKNOWN";
+    oErrorCodes[oErrorCodes["NOT_FOUND"] = 1002] = "NOT_FOUND";
+    oErrorCodes[oErrorCodes["NOT_IMPLEMENTED"] = 1003] = "NOT_IMPLEMENTED";
+    oErrorCodes[oErrorCodes["NOT_CONFIGURED"] = 1004] = "NOT_CONFIGURED";
+    oErrorCodes[oErrorCodes["NOT_AUTHORIZED"] = 1005] = "NOT_AUTHORIZED";
+    oErrorCodes[oErrorCodes["MISSING_PARAMETERS"] = 1006] = "MISSING_PARAMETERS";
+    oErrorCodes[oErrorCodes["INVALID_PARAMETERS"] = 1007] = "INVALID_PARAMETERS";
+    oErrorCodes[oErrorCodes["INVALID_RESPONSE"] = 1008] = "INVALID_RESPONSE";
+    oErrorCodes[oErrorCodes["INVALID_REQUEST"] = 1009] = "INVALID_REQUEST";
+    oErrorCodes[oErrorCodes["INVALID_STATE"] = 1010] = "INVALID_STATE";
+    oErrorCodes[oErrorCodes["INVALID_ACTION"] = 1011] = "INVALID_ACTION";
+    oErrorCodes[oErrorCodes["INVALID_CREDENTIALS"] = 1012] = "INVALID_CREDENTIALS";
+    oErrorCodes[oErrorCodes["TRANSPORT_NOT_SUPPORTED"] = 1013] = "TRANSPORT_NOT_SUPPORTED";
+    oErrorCodes[oErrorCodes["FAILED_TO_DIAL_TARGET"] = 1014] = "FAILED_TO_DIAL_TARGET";
+    oErrorCodes[oErrorCodes["INVALID_CAPABILITY"] = 1015] = "INVALID_CAPABILITY";
+    oErrorCodes[oErrorCodes["CONNECTION_LIMIT_REACHED"] = 1016] = "CONNECTION_LIMIT_REACHED";
+    oErrorCodes[oErrorCodes["TIMEOUT"] = 1017] = "TIMEOUT";
+})(oErrorCodes || (oErrorCodes = {}));

package/dist/o-core/src/error/interfaces/o-error.interface.d.ts

@@ -0,0 +1,6 @@
+export interface oErrorInterface {
+    code: number;
+    message: string;
+    details?: any;
+}
+//# sourceMappingURL=o-error.interface.d.ts.map

package/dist/o-core/src/error/interfaces/o-error.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-error.interface.d.ts","sourceRoot":"","sources":["../../../../../../o-core/src/error/interfaces/o-error.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,GAAG,CAAC;CACf"}

package/dist/o-core/src/error/interfaces/o-error.interface.js

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

package/dist/o-core/src/error/o-error.d.ts

@@ -0,0 +1,15 @@
+import { oErrorInterface } from './interfaces/o-error.interface.js';
+export declare class oError extends Error implements oErrorInterface {
+    code: number;
+    details?: any;
+    message: string;
+    constructor(code: number, message: string, details?: any);
+    toJSON(): {
+        code: number;
+        message: string;
+        details: any;
+    };
+    static fromJSON(json: any): oError;
+    toString(): string;
+}
+//# sourceMappingURL=o-error.d.ts.map

package/dist/o-core/src/error/o-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-error.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/error/o-error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEpE,qBAAa,MAAO,SAAQ,KAAM,YAAW,eAAe;IAC1D,IAAI,EAAE,MAAM,CAAK;IACjB,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,OAAO,EAAE,MAAM,CAAM;gBAET,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG;IAOxD,MAAM;;;;;IAQN,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG;IAOzB,QAAQ;CAGT"}

package/dist/o-core/src/error/o-error.js

@@ -0,0 +1,27 @@
+import { oErrorCodes } from './enums/codes.error.js';
+export class oError extends Error {
+    constructor(code, message, details) {
+        super(message);
+        this.code = 0;
+        this.message = '';
+        this.code = code;
+        this.message = message;
+        this.details = details;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.message,
+            details: this.details,
+        };
+    }
+    static fromJSON(json) {
+        if (json?.code && json?.message) {
+            return new oError(json.code, json.message, json.details);
+        }
+        return new oError(oErrorCodes.UNKNOWN, json, json?.details);
+    }
+    toString() {
+        return `OLANE ERROR CODE: ${this.code}\nMESSAGE: ${this.message}\n-----\nDETAILS: ${this.details}`;
+    }
+}

package/dist/o-core/src/streaming/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Streaming functionality for o-core
+ *
+ * This module provides transport-agnostic abstractions for streaming operations
+ * that can be used by o-node, o-client, o-browser, and other implementations.
+ */
+export { IStreamTransport, StreamStatus, StreamTransportConfig, } from './stream-transport.interface.js';
+export { StreamConfig, DEFAULT_STREAM_CONFIG, mergeStreamConfig, } from './stream-config.js';
+export { ProtocolBuilder, ParsedStreamChunk, } from './protocol-builder.js';
+export { StreamHandlerBase, StreamHandlerState, StreamHandlerOptions, } from './stream-handler.base.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/o-core/src/streaming/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/streaming/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,qBAAqB,GACtB,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,eAAe,EACf,iBAAiB,GAClB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,0BAA0B,CAAC"}

package/dist/o-core/src/streaming/index.js

@@ -0,0 +1,14 @@
+/**
+ * Streaming functionality for o-core
+ *
+ * This module provides transport-agnostic abstractions for streaming operations
+ * that can be used by o-node, o-client, o-browser, and other implementations.
+ */
+// Stream transport interface and types
+export { StreamStatus, } from './stream-transport.interface.js';
+// Stream configuration
+export { DEFAULT_STREAM_CONFIG, mergeStreamConfig, } from './stream-config.js';
+// Protocol builder for JSON-RPC streaming messages
+export { ProtocolBuilder, } from './protocol-builder.js';
+// Base stream handler class
+export { StreamHandlerBase, StreamHandlerState, } from './stream-handler.base.js';

package/dist/o-core/src/streaming/protocol-builder.d.ts

@@ -0,0 +1,62 @@
+import { JSONRPCStreamChunk, RequestId, ConnectionId, oRequest } from '@olane/o-protocol';
+/**
+ * Parsed streaming chunk data
+ */
+export interface ParsedStreamChunk {
+    data: unknown;
+    sequence: number;
+    isLast: boolean;
+    connectionId: ConnectionId;
+    requestMethod: string;
+}
+/**
+ * Builder class for constructing and parsing JSON-RPC streaming protocol messages.
+ * Provides type-safe message construction and parsing for streaming responses.
+ */
+export declare class ProtocolBuilder {
+    /**
+     * Build a JSON-RPC streaming chunk message
+     * @param data - The data payload for this chunk
+     * @param sequence - The sequence number of this chunk (starts at 1)
+     * @param isLast - Whether this is the final chunk in the stream
+     * @param requestId - The JSON-RPC request ID this chunk is responding to
+     * @param connectionId - The connection ID from the original request
+     * @param requestMethod - The method name from the original request
+     * @returns A complete JSON-RPC streaming chunk message
+     */
+    static buildStreamChunk(data: unknown, sequence: number, isLast: boolean, requestId: RequestId, connectionId: ConnectionId, requestMethod: string): JSONRPCStreamChunk;
+    /**
+     * Build a streaming chunk from an oRequest object
+     * @param data - The data payload for this chunk
+     * @param sequence - The sequence number of this chunk
+     * @param isLast - Whether this is the final chunk
+     * @param request - The original oRequest
+     * @returns A complete JSON-RPC streaming chunk message
+     */
+    static buildStreamChunkFromRequest(data: unknown, sequence: number, isLast: boolean, request: oRequest): JSONRPCStreamChunk;
+    /**
+     * Parse a JSON-RPC response to extract streaming chunk data
+     * @param message - The parsed JSON-RPC message
+     * @returns Parsed chunk data if this is a streaming response, null otherwise
+     */
+    static parseStreamChunk(message: any): ParsedStreamChunk | null;
+    /**
+     * Check if a message is a streaming response
+     * @param message - The message to check
+     * @returns true if the message is a streaming response
+     */
+    static isStreamingResponse(message: any): boolean;
+    /**
+     * Encode a message to UTF-8 bytes for transmission
+     * @param message - The message to encode
+     * @returns UTF-8 encoded bytes
+     */
+    static encodeMessage(message: JSONRPCStreamChunk): Uint8Array;
+    /**
+     * Decode UTF-8 bytes to a JSON message
+     * @param data - The UTF-8 encoded data
+     * @returns Parsed JSON message
+     */
+    static decodeMessage(data: Uint8Array): any;
+}
+//# sourceMappingURL=protocol-builder.d.ts.map

package/dist/o-core/src/streaming/protocol-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-builder.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/streaming/protocol-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAElB,SAAS,EACT,YAAY,EAEZ,QAAQ,EACT,MAAM,mBAAmB,CAAC;AAE3B;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,YAAY,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,qBAAa,eAAe;IAC1B;;;;;;;;;OASG;WACW,gBAAgB,CAC5B,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,EACf,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,MAAM,GACpB,kBAAkB;IAiBrB;;;;;;;OAOG;WACW,2BAA2B,CACvC,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,QAAQ,GAChB,kBAAkB;IAWrB;;;;OAIG;WACW,gBAAgB,CAAC,OAAO,EAAE,GAAG,GAAG,iBAAiB,GAAG,IAAI;IAgBtE;;;;OAIG;WACW,mBAAmB,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO;IAaxD;;;;OAIG;WACW,aAAa,CAAC,OAAO,EAAE,kBAAkB,GAAG,UAAU;IAIpE;;;;OAIG;WACW,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,GAAG;CAInD"}

package/dist/o-core/src/streaming/protocol-builder.js

@@ -0,0 +1,93 @@
+import { JSONRPC_VERSION, } from '@olane/o-protocol';
+/**
+ * Builder class for constructing and parsing JSON-RPC streaming protocol messages.
+ * Provides type-safe message construction and parsing for streaming responses.
+ */
+export class ProtocolBuilder {
+    /**
+     * Build a JSON-RPC streaming chunk message
+     * @param data - The data payload for this chunk
+     * @param sequence - The sequence number of this chunk (starts at 1)
+     * @param isLast - Whether this is the final chunk in the stream
+     * @param requestId - The JSON-RPC request ID this chunk is responding to
+     * @param connectionId - The connection ID from the original request
+     * @param requestMethod - The method name from the original request
+     * @returns A complete JSON-RPC streaming chunk message
+     */
+    static buildStreamChunk(data, sequence, isLast, requestId, connectionId, requestMethod) {
+        const result = {
+            _connectionId: connectionId,
+            _requestMethod: requestMethod,
+            _streaming: true,
+            _sequence: sequence,
+            _isLast: isLast,
+            _data: data,
+        };
+        return {
+            jsonrpc: JSONRPC_VERSION,
+            id: requestId,
+            result,
+        };
+    }
+    /**
+     * Build a streaming chunk from an oRequest object
+     * @param data - The data payload for this chunk
+     * @param sequence - The sequence number of this chunk
+     * @param isLast - Whether this is the final chunk
+     * @param request - The original oRequest
+     * @returns A complete JSON-RPC streaming chunk message
+     */
+    static buildStreamChunkFromRequest(data, sequence, isLast, request) {
+        return this.buildStreamChunk(data, sequence, isLast, request.id, request.params._connectionId, request.method);
+    }
+    /**
+     * Parse a JSON-RPC response to extract streaming chunk data
+     * @param message - The parsed JSON-RPC message
+     * @returns Parsed chunk data if this is a streaming response, null otherwise
+     */
+    static parseStreamChunk(message) {
+        if (!this.isStreamingResponse(message)) {
+            return null;
+        }
+        const result = message.result;
+        return {
+            data: result._data,
+            sequence: result._sequence,
+            isLast: result._isLast,
+            connectionId: result._connectionId,
+            requestMethod: result._requestMethod,
+        };
+    }
+    /**
+     * Check if a message is a streaming response
+     * @param message - The message to check
+     * @returns true if the message is a streaming response
+     */
+    static isStreamingResponse(message) {
+        return (message &&
+            typeof message === 'object' &&
+            message.result &&
+            typeof message.result === 'object' &&
+            message.result._streaming === true &&
+            typeof message.result._sequence === 'number' &&
+            typeof message.result._isLast === 'boolean' &&
+            '_data' in message.result);
+    }
+    /**
+     * Encode a message to UTF-8 bytes for transmission
+     * @param message - The message to encode
+     * @returns UTF-8 encoded bytes
+     */
+    static encodeMessage(message) {
+        return new TextEncoder().encode(JSON.stringify(message));
+    }
+    /**
+     * Decode UTF-8 bytes to a JSON message
+     * @param data - The UTF-8 encoded data
+     * @returns Parsed JSON message
+     */
+    static decodeMessage(data) {
+        const text = new TextDecoder().decode(data);
+        return JSON.parse(text);
+    }
+}

package/dist/o-core/src/streaming/stream-config.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Configuration options for streaming operations
+ */
+export interface StreamConfig {
+    /**
+     * Timeout in milliseconds for waiting to read the first chunk
+     * @default 120000 (2 minutes)
+     */
+    readTimeoutMs: number;
+    /**
+     * Timeout in milliseconds for drain operations when handling backpressure
+     * @default 30000 (30 seconds)
+     */
+    drainTimeoutMs: number;
+    /**
+     * Maximum size of a single chunk in bytes (optional)
+     * If not set, chunks can be any size
+     */
+    maxChunkSize?: number;
+    /**
+     * Enable metrics tracking for streaming operations
+     * @default true
+     */
+    enableMetrics?: boolean;
+}
+/**
+ * Default configuration for streaming operations
+ */
+export declare const DEFAULT_STREAM_CONFIG: StreamConfig;
+/**
+ * Merge user config with defaults
+ * @param userConfig - Partial user configuration
+ * @returns Complete configuration with defaults applied
+ */
+export declare function mergeStreamConfig(userConfig?: Partial<StreamConfig>): StreamConfig;
+//# sourceMappingURL=stream-config.d.ts.map

package/dist/o-core/src/streaming/stream-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-config.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/streaming/stream-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,YAInC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GACjC,YAAY,CAKd"}

package/dist/o-core/src/streaming/stream-config.js

@@ -0,0 +1,19 @@
+/**
+ * Default configuration for streaming operations
+ */
+export const DEFAULT_STREAM_CONFIG = {
+    readTimeoutMs: 120000, // 2 minutes
+    drainTimeoutMs: 30000, // 30 seconds
+    enableMetrics: true,
+};
+/**
+ * Merge user config with defaults
+ * @param userConfig - Partial user configuration
+ * @returns Complete configuration with defaults applied
+ */
+export function mergeStreamConfig(userConfig) {
+    return {
+        ...DEFAULT_STREAM_CONFIG,
+        ...userConfig,
+    };
+}

package/dist/o-core/src/streaming/stream-handler.base.d.ts

@@ -0,0 +1,85 @@
+import { oError } from '../error/o-error.js';
+import { oRequest } from '@olane/o-protocol';
+/**
+ * State machine states for streaming operations
+ */
+export declare enum StreamHandlerState {
+    IDLE = "idle",
+    STREAMING = "streaming",
+    COMPLETED = "completed",
+    ERROR = "error"
+}
+/**
+ * Options for stream handler operations
+ */
+export interface StreamHandlerOptions {
+    /**
+     * Enable metrics tracking
+     */
+    enableMetrics?: boolean;
+}
+/**
+ * Abstract base class for handling streaming operations.
+ * Provides transport-agnostic AsyncGenerator iteration, chunk sequencing,
+ * error handling, and state management.
+ *
+ * Implementations must provide the sendChunk method for transport-specific
+ * chunk transmission.
+ */
+export declare abstract class StreamHandlerBase {
+    protected state: StreamHandlerState;
+    protected currentSequence: number;
+    protected options: StreamHandlerOptions;
+    constructor(options?: StreamHandlerOptions);
+    /**
+     * Get the current state of the stream handler
+     */
+    getState(): StreamHandlerState;
+    /**
+     * Get the current sequence number
+     */
+    getCurrentSequence(): number;
+    /**
+     * Abstract method that implementations must provide to send a chunk.
+     * This method should handle the actual transmission using the specific transport.
+     *
+     * @param chunk - The data chunk to send
+     * @param sequence - The sequence number of this chunk
+     * @param isLast - Whether this is the final chunk
+     * @param request - The original request
+     */
+    protected abstract sendChunk(chunk: unknown, sequence: number, isLast: boolean, request: oRequest): Promise<void>;
+    /**
+     * Optional hook called when streaming starts
+     */
+    protected onStreamStart?(request: oRequest): void;
+    /**
+     * Optional hook called when streaming completes successfully
+     */
+    protected onStreamComplete?(request: oRequest, totalChunks: number): void;
+    /**
+     * Optional hook called when streaming encounters an error
+     */
+    protected onStreamError?(request: oRequest, error: oError): void;
+    /**
+     * Handle streaming of an AsyncGenerator.
+     * Iterates through the generator, sends each chunk with proper sequencing,
+     * and handles errors appropriately.
+     *
+     * @param generator - The AsyncGenerator to stream
+     * @param request - The original request
+     * @returns Promise that resolves when streaming is complete
+     */
+    handleStream(generator: AsyncGenerator<any>, request: oRequest): Promise<void>;
+    /**
+     * Convert any error to an oError instance
+     * @param error - The error to convert
+     * @returns An oError instance
+     */
+    protected convertToOError(error: unknown): oError;
+    /**
+     * Reset the handler state for reuse
+     */
+    reset(): void;
+}
+//# sourceMappingURL=stream-handler.base.d.ts.map

package/dist/o-core/src/streaming/stream-handler.base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-handler.base.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/streaming/stream-handler.base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,SAAS,cAAc;IACvB,KAAK,UAAU;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,8BAAsB,iBAAiB;IACrC,SAAS,CAAC,KAAK,EAAE,kBAAkB,CAA2B;IAC9D,SAAS,CAAC,eAAe,EAAE,MAAM,CAAK;IACtC,SAAS,CAAC,OAAO,EAAE,oBAAoB,CAAC;gBAE5B,OAAO,GAAE,oBAAyB;IAO9C;;OAEG;IACI,QAAQ,IAAI,kBAAkB;IAIrC;;OAEG;IACI,kBAAkB,IAAI,MAAM;IAInC;;;;;;;;OAQG;IACH,SAAS,CAAC,QAAQ,CAAC,SAAS,CAC1B,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,IAAI,CAAC;IAEhB;;OAEG;IACH,SAAS,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI;IAEjD;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAEzE;;OAEG;IACH,SAAS,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAEhE;;;;;;;;OAQG;IACU,YAAY,CACvB,SAAS,EAAE,cAAc,CAAC,GAAG,CAAC,EAC9B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,IAAI,CAAC;IAqDhB;;;;OAIG;IACH,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;IAoBjD;;OAEG;IACI,KAAK,IAAI,IAAI;CAIrB"}

package/dist/o-core/src/streaming/stream-handler.base.js

@@ -0,0 +1,112 @@
+import { oError } from '../error/o-error.js';
+import { oErrorCodes } from '../error/enums/codes.error.js';
+/**
+ * State machine states for streaming operations
+ */
+export var StreamHandlerState;
+(function (StreamHandlerState) {
+    StreamHandlerState["IDLE"] = "idle";
+    StreamHandlerState["STREAMING"] = "streaming";
+    StreamHandlerState["COMPLETED"] = "completed";
+    StreamHandlerState["ERROR"] = "error";
+})(StreamHandlerState || (StreamHandlerState = {}));
+/**
+ * Abstract base class for handling streaming operations.
+ * Provides transport-agnostic AsyncGenerator iteration, chunk sequencing,
+ * error handling, and state management.
+ *
+ * Implementations must provide the sendChunk method for transport-specific
+ * chunk transmission.
+ */
+export class StreamHandlerBase {
+    constructor(options = {}) {
+        this.state = StreamHandlerState.IDLE;
+        this.currentSequence = 0;
+        this.options = {
+            enableMetrics: true,
+            ...options,
+        };
+    }
+    /**
+     * Get the current state of the stream handler
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Get the current sequence number
+     */
+    getCurrentSequence() {
+        return this.currentSequence;
+    }
+    /**
+     * Handle streaming of an AsyncGenerator.
+     * Iterates through the generator, sends each chunk with proper sequencing,
+     * and handles errors appropriately.
+     *
+     * @param generator - The AsyncGenerator to stream
+     * @param request - The original request
+     * @returns Promise that resolves when streaming is complete
+     */
+    async handleStream(generator, request) {
+        this.state = StreamHandlerState.STREAMING;
+        this.currentSequence = 0;
+        // Call optional hook
+        if (this.onStreamStart) {
+            this.onStreamStart(request);
+        }
+        try {
+            // Iterate through the generator and send each chunk
+            for await (const chunk of generator) {
+                this.currentSequence++;
+                await this.sendChunk(chunk, this.currentSequence, false, request);
+            }
+            // Send final empty chunk to signal completion
+            await this.sendChunk(null, this.currentSequence, true, request);
+            this.state = StreamHandlerState.COMPLETED;
+            // Call optional hook
+            if (this.onStreamComplete) {
+                this.onStreamComplete(request, this.currentSequence);
+            }
+        }
+        catch (error) {
+            this.state = StreamHandlerState.ERROR;
+            // Convert error to oError if needed
+            const oErrorInstance = this.convertToOError(error);
+            // Call optional hook
+            if (this.onStreamError) {
+                this.onStreamError(request, oErrorInstance);
+            }
+            // Send error as final chunk
+            try {
+                await this.sendChunk(oErrorInstance.toJSON(), this.currentSequence, true, request);
+            }
+            catch (sendError) {
+                console.error('Failed to send error chunk:', sendError);
+                throw oErrorInstance;
+            }
+            throw oErrorInstance;
+        }
+    }
+    /**
+     * Convert any error to an oError instance
+     * @param error - The error to convert
+     * @returns An oError instance
+     */
+    convertToOError(error) {
+        if (error instanceof oError) {
+            return error;
+        }
+        if (error instanceof Error) {
+            return new oError(oErrorCodes.UNKNOWN, error.message, { stack: error.stack });
+        }
+        return new oError(oErrorCodes.UNKNOWN, String(error), { originalError: error });
+    }
+    /**
+     * Reset the handler state for reuse
+     */
+    reset() {
+        this.state = StreamHandlerState.IDLE;
+        this.currentSequence = 0;
+    }
+}