@olane/o-node 0.7.12-alpha.4 → 0.7.12-alpha.41

package/dist/o-core/src/router/o-request-preparation.d.ts

@@ -0,0 +1,37 @@
+import { oObject } from '../core/o-object.js';
+import { oAddress } from './o-address.js';
+import { oRouterRequest } from './o-request.router.js';
+/**
+ * Handles request transformation and preparation for routing.
+ * Manages payload wrapping/unwrapping, parameter merging, and request envelope handling.
+ */
+export declare class oRequestPreparation extends oObject {
+    /**
+     * Prepares a routing request by applying overrides and updating addresses.
+     * @param originalRequest The original router request
+     * @param requestOverride Optional request override from resolvers
+     * @param targetAddress The final target address
+     * @returns The prepared routing request
+     */
+    prepareRequest(originalRequest: oRouterRequest, requestOverride: oRouterRequest | undefined, targetAddress: oAddress): oRouterRequest;
+    /**
+     * Applies handshake-specific transformations to a request.
+     * @param request The routing request to modify
+     * @param requestOverride The request override from resolvers
+     */
+    applyHandshakeTransform(request: oRouterRequest, requestOverride: oRouterRequest | undefined): oRouterRequest;
+    /**
+     * Merges parameters from original payload and resolver overrides.
+     * @param request The routing request to modify
+     * @param originalPayload The original request payload
+     */
+    applyParameterMerge(request: oRouterRequest, originalPayload: any): oRouterRequest;
+    /**
+     * Checks if the request is a handshake request.
+     * @param method The method to check
+     * @param handshakeMethod The handshake method constant
+     * @returns True if this is a handshake request
+     */
+    isHandshakeRequest(method: string, handshakeMethod: string): boolean;
+}
+//# sourceMappingURL=o-request-preparation.d.ts.map

package/dist/o-core/src/router/o-request-preparation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-request-preparation.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/router/o-request-preparation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGvD;;;GAGG;AACH,qBAAa,mBAAoB,SAAQ,OAAO;IAC9C;;;;;;OAMG;IACH,cAAc,CACZ,eAAe,EAAE,cAAc,EAC/B,eAAe,EAAE,cAAc,GAAG,SAAS,EAC3C,aAAa,EAAE,QAAQ,GACtB,cAAc;IAkBjB;;;;OAIG;IACH,uBAAuB,CACrB,OAAO,EAAE,cAAc,EACvB,eAAe,EAAE,cAAc,GAAG,SAAS,GAC1C,cAAc;IAmBjB;;;;OAIG;IACH,mBAAmB,CACjB,OAAO,EAAE,cAAc,EACvB,eAAe,EAAE,GAAG,GACnB,cAAc;IAUjB;;;;;OAKG;IACH,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,OAAO;CAGrE"}

package/dist/o-core/src/router/o-request-preparation.js

@@ -0,0 +1,75 @@
+import { oObject } from '../core/o-object.js';
+import { oRouterRequest } from './o-request.router.js';
+import { JSONRPC_VERSION, oProtocolMethods } from '@olane/o-protocol';
+/**
+ * Handles request transformation and preparation for routing.
+ * Manages payload wrapping/unwrapping, parameter merging, and request envelope handling.
+ */
+export class oRequestPreparation extends oObject {
+    /**
+     * Prepares a routing request by applying overrides and updating addresses.
+     * @param originalRequest The original router request
+     * @param requestOverride Optional request override from resolvers
+     * @param targetAddress The final target address
+     * @returns The prepared routing request
+     */
+    prepareRequest(originalRequest, requestOverride, targetAddress) {
+        const finalRequest = requestOverride || originalRequest;
+        const req = new oRouterRequest({
+            method: finalRequest.method,
+            params: finalRequest.params,
+            id: finalRequest.id,
+            jsonrpc: JSONRPC_VERSION,
+            stream: originalRequest.stream,
+        });
+        // Update target address in request
+        if (finalRequest && targetAddress) {
+            finalRequest.params.address = targetAddress.toString();
+        }
+        return req;
+    }
+    /**
+     * Applies handshake-specific transformations to a request.
+     * @param request The routing request to modify
+     * @param requestOverride The request override from resolvers
+     */
+    applyHandshakeTransform(request, requestOverride) {
+        const params = request.params.payload.params;
+        const { method } = request.params.payload;
+        try {
+            if (requestOverride) {
+                // This is likely a method resolver, so we need to override the method
+                // Let's specify the method in the request params to optimize on context window
+                params.tool = request.params?.payload?.method;
+            }
+        }
+        catch (e) {
+            this.logger.error('Error assigning tool to handshake: ', e);
+        }
+        // Update the method to be the handshake
+        request.params.payload.method = oProtocolMethods.HANDSHAKE;
+        return request;
+    }
+    /**
+     * Merges parameters from original payload and resolver overrides.
+     * @param request The routing request to modify
+     * @param originalPayload The original request payload
+     */
+    applyParameterMerge(request, originalPayload) {
+        const params = request.params.payload.params;
+        request.params.payload.params = {
+            ...originalPayload.params, // initial params
+            ...params, // overloaded params
+        };
+        return request;
+    }
+    /**
+     * Checks if the request is a handshake request.
+     * @param method The method to check
+     * @param handshakeMethod The handshake method constant
+     * @returns True if this is a handshake request
+     */
+    isHandshakeRequest(method, handshakeMethod) {
+        return method === handshakeMethod;
+    }
+}

package/dist/o-core/src/router/o-request.router.d.ts

@@ -0,0 +1,18 @@
+import { oProtocolMethods, RequestId, oRouterRequestInterface, RequestParams, JSONRPC_VERSION } from '@olane/o-protocol';
+import { Stream } from '@olane/o-config';
+import { oRequest } from '../connection/o-request.js';
+export declare class oRouterRequest extends oRequest implements oRouterRequestInterface {
+    jsonrpc: typeof JSONRPC_VERSION;
+    method: oProtocolMethods.ROUTE;
+    stream?: Stream | undefined;
+    params: RequestParams & {
+        address: string;
+        payload: {
+            [key: string]: unknown;
+        };
+    };
+    constructor(config: oRouterRequestInterface & {
+        id: RequestId;
+    });
+}
+//# sourceMappingURL=o-request.router.d.ts.map

package/dist/o-core/src/router/o-request.router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-request.router.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/router/o-request.router.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,SAAS,EACT,uBAAuB,EACvB,aAAa,EACb,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAEtD,qBAAa,cACX,SAAQ,QACR,YAAW,uBAAuB;IAElC,OAAO,EAAE,OAAO,eAAe,CAAC;IAChC,MAAM,EAAE,gBAAgB,CAAC,KAAK,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,MAAM,EAAE,aAAa,GAAG;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE;YACP,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;SACxB,CAAC;KACH,CAAC;gBACU,MAAM,EAAE,uBAAuB,GAAG;QAAE,EAAE,EAAE,SAAS,CAAA;KAAE;CAQhE"}

package/dist/o-core/src/router/o-request.router.js

@@ -0,0 +1,12 @@
+import { JSONRPC_VERSION, } from '@olane/o-protocol';
+import { oRequest } from '../connection/o-request.js';
+export class oRouterRequest extends oRequest {
+    constructor(config) {
+        super(config);
+        this.jsonrpc = JSONRPC_VERSION;
+        this.method = config.method;
+        this.params = config.params;
+        this.stream = config.stream;
+        this.id = config.id;
+    }
+}

package/dist/o-core/src/router/o-resolver-chain.d.ts

@@ -0,0 +1,32 @@
+import { oAddress } from './o-address.js';
+import { oAddressResolver } from './o-address-resolver.js';
+import { oObject } from '../core/o-object.js';
+import { RouteResponse } from './interfaces/route.response.js';
+import { ResolveRequest } from './interfaces/resolve.request.js';
+/**
+ * Manages a chain of address resolvers using the Chain of Responsibility pattern.
+ * Sequentially executes registered resolvers to transform addresses and routing requests.
+ */
+export declare class oResolverChain extends oObject {
+    private readonly resolvers;
+    /**
+     * Registers a resolver in the chain.
+     * @param resolver The resolver to add
+     * @param isPriority If true, adds to the front of the chain; otherwise appends to the end
+     */
+    addResolver(resolver: oAddressResolver, isPriority?: boolean): void;
+    /**
+     * Checks if any resolver in the chain supports the given address.
+     * @param address The address to check
+     * @returns True if at least one resolver supports this address
+     */
+    supportsAddress(address: oAddress): boolean;
+    /**
+     * Executes the resolver chain to transform an address and request.
+     * Each resolver in sequence can modify the nextHopAddress, targetAddress, and request.
+     * @param request The resolve request containing address, node, and optional request override
+     * @returns The final route response after all resolvers have executed
+     */
+    resolve(request: ResolveRequest): Promise<RouteResponse>;
+}
+//# sourceMappingURL=o-resolver-chain.d.ts.map

package/dist/o-core/src/router/o-resolver-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-resolver-chain.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/router/o-resolver-chain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAG3D,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAGjE;;;GAGG;AACH,qBAAa,cAAe,SAAQ,OAAO;IACzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IAEpD;;;;OAIG;IACH,WAAW,CAAC,QAAQ,EAAE,gBAAgB,EAAE,UAAU,GAAE,OAAe;IAQnE;;;;OAIG;IACH,eAAe,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IAQ3C;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CA+B/D"}

package/dist/o-core/src/router/o-resolver-chain.js

@@ -0,0 +1,62 @@
+import { oAddress } from './o-address.js';
+import { oObject } from '../core/o-object.js';
+/**
+ * Manages a chain of address resolvers using the Chain of Responsibility pattern.
+ * Sequentially executes registered resolvers to transform addresses and routing requests.
+ */
+export class oResolverChain extends oObject {
+    constructor() {
+        super(...arguments);
+        this.resolvers = [];
+    }
+    /**
+     * Registers a resolver in the chain.
+     * @param resolver The resolver to add
+     * @param isPriority If true, adds to the front of the chain; otherwise appends to the end
+     */
+    addResolver(resolver, isPriority = false) {
+        if (isPriority) {
+            this.resolvers.unshift(resolver);
+        }
+        else {
+            this.resolvers.push(resolver);
+        }
+    }
+    /**
+     * Checks if any resolver in the chain supports the given address.
+     * @param address The address to check
+     * @returns True if at least one resolver supports this address
+     */
+    supportsAddress(address) {
+        return this.resolvers.some((r) => address.transports.some((t) => {
+            return r.transportTypes.some((r) => r === t.type);
+        }));
+    }
+    /**
+     * Executes the resolver chain to transform an address and request.
+     * Each resolver in sequence can modify the nextHopAddress, targetAddress, and request.
+     * @param request The resolve request containing address, node, and optional request override
+     * @returns The final route response after all resolvers have executed
+     */
+    async resolve(request) {
+        let resolvedAddress = new oAddress(request.address.toString(), request.address.transports);
+        let targetAddress = resolvedAddress;
+        let requestOverride = request.request;
+        for (const resolver of this.resolvers) {
+            const { nextHopAddress, targetAddress: resolverTargetAddress, requestOverride: resolverRequestOverride, } = await resolver.resolve({
+                address: resolvedAddress,
+                targetAddress: targetAddress,
+                node: request.node,
+                request: requestOverride,
+            });
+            requestOverride = resolverRequestOverride || requestOverride;
+            targetAddress = resolverTargetAddress || targetAddress;
+            resolvedAddress = nextHopAddress;
+        }
+        return {
+            nextHopAddress: resolvedAddress,
+            targetAddress: targetAddress,
+            requestOverride: requestOverride,
+        };
+    }
+}

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

@@ -0,0 +1,19 @@
+import { oAddress } from './o-address.js';
+import { oObject } from '../core/o-object.js';
+import { oResolverChain } from './o-resolver-chain.js';
+import { oAddressResolver } from './o-address-resolver.js';
+import { oRequest } from '../connection/o-request.js';
+import type { oCore } from '../core/o-core.js';
+import { RouteResponse } from './interfaces/route.response.js';
+import { oRouterRequest } from './o-request.router.js';
+export declare abstract class oRouter extends oObject {
+    addressResolution: oResolverChain;
+    constructor();
+    abstract translate(addressWithLeaderTransports: oAddress, node: oCore): Promise<RouteResponse>;
+    abstract isInternal(addressWithLeaderTransports: oAddress, node: oCore): boolean;
+    abstract route(request: oRouterRequest, node: oCore): Promise<RouteResponse>;
+    protected abstract forward(address: oAddress, request: oRequest | oRouterRequest, node: oCore): Promise<any>;
+    addResolver(resolver: oAddressResolver, isPriority?: boolean): void;
+    supportsAddress(address: oAddress): boolean;
+}
+//# sourceMappingURL=o-router.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-router.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/router/o-router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,8BAAsB,OAAQ,SAAQ,OAAO;IACpC,iBAAiB,EAAG,cAAc,CAAC;;IAQ1C,QAAQ,CAAC,SAAS,CAChB,2BAA2B,EAAE,QAAQ,EACrC,IAAI,EAAE,KAAK,GACV,OAAO,CAAC,aAAa,CAAC;IAGzB,QAAQ,CAAC,UAAU,CACjB,2BAA2B,EAAE,QAAQ,EACrC,IAAI,EAAE,KAAK,GACV,OAAO;IAKV,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IAG5E,SAAS,CAAC,QAAQ,CAAC,OAAO,CACxB,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,QAAQ,GAAG,cAAc,EAClC,IAAI,EAAE,KAAK,GACV,OAAO,CAAC,GAAG,CAAC;IAEf,WAAW,CAAC,QAAQ,EAAE,gBAAgB,EAAE,UAAU,GAAE,OAAe,GAAG,IAAI;IAI1E,eAAe,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;CAG5C"}

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

@@ -0,0 +1,14 @@
+import { oObject } from '../core/o-object.js';
+import { oResolverChain } from './o-resolver-chain.js';
+export class oRouter extends oObject {
+    constructor() {
+        super();
+        this.addressResolution = new oResolverChain();
+    }
+    addResolver(resolver, isPriority = false) {
+        this.addressResolution.addResolver(resolver, isPriority);
+    }
+    supportsAddress(address) {
+        return this.addressResolution.supportsAddress(address);
+    }
+}

package/dist/o-core/src/router/o-routing-policy.d.ts

@@ -0,0 +1,36 @@
+import { oAddress } from './o-address.js';
+import { oObject } from '../core/o-object.js';
+import type { oCore } from '../core/o-core.js';
+import { RouteResponse } from './interfaces/route.response.js';
+/**
+ * Provides routing policy decisions based on network topology and address characteristics.
+ * Determines whether addresses are internal/external, when to route to leaders, etc.
+ *
+ * This layer separates network topology awareness from address resolution logic,
+ * making routing decisions testable without network calls.
+ */
+export declare abstract class oRoutingPolicy extends oObject {
+    /**
+     * Determines if an address is internal to the current network/hierarchy.
+     * @param address The address to check
+     * @param node The current node context
+     * @returns True if the address is internal, false if external
+     */
+    abstract isInternalAddress(address: oAddress, node: oCore): boolean;
+    /**
+     * Determines if the given address points to the node itself.
+     * @param address The address to check
+     * @param node The current node context
+     * @returns True if this is a self-reference
+     */
+    isSelfAddress(address: oAddress, node: oCore): boolean;
+    /**
+     * Checks if an address should be routed to a leader node.
+     * Returns a RouteResponse if leader routing is required, null otherwise.
+     * @param address The address to evaluate
+     * @param node The current node context
+     * @returns RouteResponse for leader routing, or null if not applicable
+     */
+    abstract getExternalRoutingStrategy(address: oAddress, node: oCore): RouteResponse | null;
+}
+//# sourceMappingURL=o-routing-policy.d.ts.map

package/dist/o-core/src/router/o-routing-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-routing-policy.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/router/o-routing-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D;;;;;;GAMG;AACH,8BAAsB,cAAe,SAAQ,OAAO;IAClD;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IAEnE;;;;;OAKG;IACH,aAAa,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IAItD;;;;;;OAMG;IACH,QAAQ,CAAC,0BAA0B,CACjC,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,KAAK,GACV,aAAa,GAAG,IAAI;CACxB"}

package/dist/o-core/src/router/o-routing-policy.js

@@ -0,0 +1,19 @@
+import { oObject } from '../core/o-object.js';
+/**
+ * Provides routing policy decisions based on network topology and address characteristics.
+ * Determines whether addresses are internal/external, when to route to leaders, etc.
+ *
+ * This layer separates network topology awareness from address resolution logic,
+ * making routing decisions testable without network calls.
+ */
+export class oRoutingPolicy extends oObject {
+    /**
+     * Determines if the given address points to the node itself.
+     * @param address The address to check
+     * @param node The current node context
+     * @returns True if this is a self-reference
+     */
+    isSelfAddress(address, node) {
+        return node.address.equals(address);
+    }
+}

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,
+    };
+}