@recombine-ai/engine 0.11.3 → 1.0.0-beta-1

package/build/lib/llm-adapters/mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../../src/lib/llm-adapters/mock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;AAEvC,wBAAgB,iBAAiB,IAAI,UAAU,CAU9C"}

package/build/lib/llm-adapters/mock.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockAdapter = createMockAdapter;
+function createMockAdapter() {
+    return {
+        getOptions: () => ({ model: 'mock' }),
+        async generateResponse(_systemPrompt, _messages, schema) {
+            if (schema) {
+                return JSON.stringify({ message: 'canned response', reasons: [] });
+            }
+            return 'canned response';
+        },
+    };
+}

package/build/lib/llm-adapters/openai-stream.d.ts

@@ -0,0 +1,6 @@
+import { OpenAI } from 'openai';
+import { ChatCompletionCreateParamsBase } from 'openai/resources/chat/completions';
+import { LlmStreamAdapter } from '../stream/interfaces';
+export type OpenAIChatOptions = Omit<ChatCompletionCreateParamsBase, 'messages' | 'response_format' | 'stream'>;
+export declare function createOpenAIStreamAdapter(options: OpenAIChatOptions, client?: OpenAI): LlmStreamAdapter;
+//# sourceMappingURL=openai-stream.d.ts.map

package/build/lib/llm-adapters/openai-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-stream.d.ts","sourceRoot":"","sources":["../../../src/lib/llm-adapters/openai-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAA;AAElF,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAEvD,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAChC,8BAA8B,EAC9B,UAAU,GAAG,iBAAiB,GAAG,QAAQ,CAC5C,CAAA;AAED,wBAAgB,yBAAyB,CACrC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,SAAe,GACtB,gBAAgB,CA4BlB"}

package/build/lib/llm-adapters/openai-stream.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAIStreamAdapter = createOpenAIStreamAdapter;
+const openai_1 = require("openai");
+function createOpenAIStreamAdapter(options, client = new openai_1.OpenAI()) {
+    return {
+        getOptions: () => options,
+        async generateStream(systemPrompt, messages) {
+            const stream = await client.chat.completions.create({
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: messages },
+                ],
+                ...options,
+                stream: true,
+                response_format: { type: 'text' },
+            });
+            return new ReadableStream({
+                async start(controller) {
+                    for await (const chunk of stream) {
+                        const content = chunk.choices?.[0]?.delta?.content;
+                        if (content)
+                            controller.enqueue(content);
+                    }
+                    controller.close();
+                },
+            });
+        },
+    };
+}

package/build/lib/llm-adapters/openai.d.ts

@@ -1,10 +1,8 @@
+import { OpenAI } from 'openai';
 import { ChatCompletionCreateParamsBase } from 'openai/resources/chat/completions';
 import type { LlmAdapter } from '../ai';
-export type OpenAIChatOptions = Omit<ChatCompletionCreateParamsBase, 'messages' | 'stream'>;
-export type OpenAIAdapterAuth = {
-    tokenStorage: {
-        getToken: () => Promise<string | null>;
-    };
-};
-export declare function createOpenAIAdapter(options: OpenAIChatOptions, auth: OpenAIAdapterAuth): LlmAdapter;
+type OpenaiOptionsToSend = Omit<ChatCompletionCreateParamsBase, 'messages' | 'stream'>;
+export type OpenAIChatOptions = Omit<OpenaiOptionsToSend, 'response_format'>;
+export declare function createOpenAIAdapter(options: OpenAIChatOptions, client?: OpenAI): LlmAdapter;
+export {};
 //# sourceMappingURL=openai.d.ts.map

package/build/lib/llm-adapters/openai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/lib/llm-adapters/openai.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAA;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;AAIvC,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,8BAA8B,EAAE,UAAU,GAAG,QAAQ,CAAC,CAAA;AAE3F,MAAM,MAAM,iBAAiB,GAAG;IAC5B,YAAY,EAAE;QAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;KAAE,CAAA;CAC3D,CAAA;AAID,wBAAgB,mBAAmB,CAC/B,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,iBAAiB,GACxB,UAAU,CA+CZ"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/lib/llm-adapters/openai.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAA;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;AAGvC,KAAK,mBAAmB,GAAG,IAAI,CAAC,8BAA8B,EAAE,UAAU,GAAG,QAAQ,CAAC,CAAA;AACtF,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,mBAAmB,EAAE,iBAAiB,CAAC,CAAA;AAE5E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAe,GAAG,UAAU,CAmCjG"}

package/build/lib/llm-adapters/openai.js

@@ -1,13 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenAIAdapter = createOpenAIAdapter;
 const openai_1 = require("openai");
-const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
-const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-function createOpenAIAdapter(options, auth) {
+const zod_1 = require("zod");
+function createOpenAIAdapter(options, client = new openai_1.OpenAI()) {
     return {
         getOptions: () => options,
         async generateResponse(systemPrompt, messages, schema) {
@@ -17,23 +13,11 @@ function createOpenAIAdapter(options, auth) {
                     type: 'json_schema',
                     json_schema: {
                         name: 'detector_response',
-                        schema: (0, zod_to_json_schema_1.default)(schema),
+                        schema: (0, zod_1.toJSONSchema)(schema),
                         strict: true,
                     },
                 };
             }
-            const apiKey = await auth.tokenStorage.getToken();
-            if (!apiKey) {
-                throw new Error('OpenAI API key is not set');
-            }
-            if (apiKey === '__TESTING__') {
-                await delay(100);
-                if (options.response_format && 'json_schema' in options.response_format) {
-                    return JSON.stringify({ message: 'canned response', reasons: [] });
-                }
-                return 'canned response';
-            }
-            const client = new openai_1.OpenAI({ apiKey });
             const response = await client.chat.completions.create({
                 messages: [
                     { role: 'system', content: systemPrompt },

package/build/lib/stream/ai.d.ts

@@ -0,0 +1,3 @@
+import { AIStreamEngine, StreamingEngineConfig } from './interfaces';
+export declare function createAIStreamEngine(cfg: StreamingEngineConfig): AIStreamEngine;
+//# sourceMappingURL=ai.d.ts.map

package/build/lib/stream/ai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../../../src/lib/stream/ai.ts"],"names":[],"mappings":"AAOA,OAAO,EACH,cAAc,EAGd,qBAAqB,EAGxB,MAAM,cAAc,CAAA;AAIrB,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,qBAAqB,GAAG,cAAc,CA6N/E"}

package/build/lib/stream/ai.js

@@ -0,0 +1,245 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAIStreamEngine = createAIStreamEngine;
+// cspell:words TTFT lstrip
+const nunjucks_1 = __importDefault(require("nunjucks"));
+const bosun_1 = require("../bosun");
+const filter_1 = require("./filter");
+const step_registry_1 = require("../bosun/step-registry");
+function createAIStreamEngine(cfg) {
+    function createWorkflow({ name, prompt, model, filter = filter_1.defaultFilter, onError, }) {
+        const logger = cfg.logger || console;
+        logger.debug('streamAiEngine.createWorkflow');
+        const stepTracer = cfg.stepTracer || (0, bosun_1.createStubStepTracer)(logger);
+        cfg.stepRegistry?.addStep({
+            type: 'streaming-response',
+            name,
+            prompt: (0, step_registry_1.stdPrompt)(prompt),
+        });
+        async function run(messages, ctx) {
+            let streamCancelled = false;
+            return new ReadableStream({
+                cancel: (reason) => {
+                    logger.debug(`streamingWorkflow.run cancelled: ${reason}`);
+                    streamCancelled = true;
+                },
+                start: async (controller) => {
+                    try {
+                        const stream = await generateResponseStream(messages, ctx);
+                        for await (const chunk of stream) {
+                            if (streamCancelled)
+                                return;
+                            controller.enqueue(chunk);
+                        }
+                        if (streamCancelled)
+                            return;
+                        controller.close();
+                    }
+                    catch (e) {
+                        if (streamCancelled) {
+                            logger.debug('streamingWorkflow.run will not propagate error due to stream cancellation', e);
+                            return;
+                        }
+                        controller.error(e);
+                        await onError(e, ctx);
+                    }
+                },
+            });
+        }
+        async function generateResponseStream(messages, ctx) {
+            const runId = crypto.randomUUID();
+            logger.debug(`streamingWorkflow.run runId: ${runId}`);
+            const startTime = performance.now();
+            const transcript = createTranscript(logger, messages);
+            let currentFilter = null;
+            let filteredTokens = [];
+            // Create step trace for telescope
+            const mainStepTrace = {
+                workflowId: name,
+                workflowRunId: runId,
+                name: name,
+                model: String(model.getOptions()),
+                createdAt: Date.now(),
+                response: '',
+            };
+            const renderedPrompt = await renderPrompt(prompt, ctx);
+            const stringifiedConversation = transcript.toString();
+            mainStepTrace.renderedPrompt = renderedPrompt;
+            mainStepTrace.stringifiedConversation = stringifiedConversation;
+            let mainStepStream;
+            try {
+                mainStepStream = await model.generateStream(renderedPrompt, stringifiedConversation);
+            }
+            catch (error) {
+                logger.error('AI Engine Stream: LLM error', { error });
+                if (mainStepTrace) {
+                    mainStepTrace.error = error instanceof Error ? error : new Error(String(error));
+                    cfg.stepTracer?.addStepTrace(mainStepTrace);
+                    await cfg.stepTracer?.flush();
+                }
+                throw error;
+            }
+            logger.debug(`[MARK] stream created: ${(performance.now() - startTime).toFixed(2)}ms`);
+            let measureTtft = true;
+            let streamCancelled = false;
+            return new ReadableStream({
+                cancel: (reason) => {
+                    logger.debug(`streamingWorkflow.generateResponseStream cancelled: ${reason}`);
+                    streamCancelled = true;
+                },
+                async start(controller) {
+                    logger.debug('streamingWorkflow.run: starting main stream');
+                    for await (const chunk of mainStepStream) {
+                        if (measureTtft) {
+                            logger.debug(`[MARK] TTFT: ${(performance.now() - startTime).toFixed(2)}ms`);
+                            measureTtft = false;
+                        }
+                        const delta = chunk;
+                        if (!delta) {
+                            continue;
+                        }
+                        let tokensToRelease = [];
+                        if (currentFilter) {
+                            filteredTokens.push(delta);
+                            const filterResult = currentFilter.onNewToken(transcript, filteredTokens);
+                            if (filterResult.action === 'RELEASE_TOKENS') {
+                                logger.debug('streamingWorkflow.run: programmatic filter releasing tokens: ', JSON.stringify(filterResult.tokens));
+                                tokensToRelease = filterResult.tokens;
+                                currentFilter = null;
+                                filteredTokens = [];
+                            }
+                        }
+                        else if (filter?.shouldStartFiltering(transcript, delta)) {
+                            filteredTokens = [delta];
+                            currentFilter = filter;
+                            logger.debug('streamingWorkflow.run: programmatic filter is applied on token: ', delta);
+                        }
+                        else {
+                            tokensToRelease = [delta];
+                        }
+                        releaseMainStreamTokens(tokensToRelease);
+                    }
+                    if (currentFilter) {
+                        // stream has ended, but the filter still has some tokens to release
+                        releaseMainStreamTokens(currentFilter.onStreamEnd(transcript, filteredTokens).tokensToRelease);
+                        currentFilter = null;
+                        filteredTokens = [];
+                    }
+                    function releaseMainStreamTokens(tokens) {
+                        for (const token of tokens) {
+                            if (streamCancelled) {
+                                break;
+                            }
+                            transcript.responseChunks.push({ role: 'agent', delta: token });
+                            controller.enqueue({ role: 'agent', delta: token });
+                        }
+                    }
+                    logger.debug('streamingWorkflow.run: markMainResponseFinished', {
+                        elapsedMs: (performance.now() - startTime).toFixed(2),
+                    });
+                    transcript.markMainResponseFinished();
+                    // Add step trace and flush to telescope
+                    cfg.stepTracer?.addStepTrace(mainStepTrace);
+                    await cfg.stepTracer?.flush();
+                    if (cfg.conversationalTracer) {
+                        try {
+                            const ctxWithState = ctx;
+                            const rawConversationId = ctxWithState?.state?.callId ?? ctxWithState?.callId;
+                            const conversationId = typeof rawConversationId === 'string' && rawConversationId !== ''
+                                ? rawConversationId
+                                : undefined;
+                            cfg.conversationalTracer.addConversationalTrace({
+                                conversationId,
+                                eventName: 'finished-main-streaming-step',
+                                role: 'agent',
+                                medium: 'phone',
+                                content: transcript.currentResponse,
+                                createdAt: Date.now(),
+                            });
+                            await cfg.conversationalTracer.flush();
+                        }
+                        catch (err) {
+                            logger.error('Failed to write conversational trace', { err });
+                        }
+                    }
+                    if (!streamCancelled) {
+                        controller.close();
+                    }
+                    await stepTracer.flush();
+                },
+            });
+        }
+        async function renderPrompt(prompt, context) {
+            logger.debug('Streaming AI, CONTEXT:', context);
+            const template = typeof prompt === 'string' ? prompt : await prompt.content();
+            if (context) {
+                logger.debug('Loaded context: ', context);
+                nunjucks_1.default.configure({
+                    autoescape: true,
+                    trimBlocks: true,
+                    lstripBlocks: true,
+                });
+                return nunjucks_1.default.renderString(template, context);
+            }
+            return template;
+        }
+        return {
+            run,
+        };
+    }
+    return {
+        createWorkflow,
+    };
+}
+function createTranscript(logger, initialMessages) {
+    let finished = false;
+    const messages = [...initialMessages];
+    const directivesFormatter = (msg) => `${msg.sender}: ${msg.text}`;
+    const currentResponseFormatter = (partial) => `Current response: ${partial}`;
+    const responseTokens = [];
+    const names = {
+        agent: 'Agent',
+        user: 'User',
+        system: 'System',
+    };
+    return {
+        responseChunks: responseTokens,
+        get currentResponse() {
+            return responseTokens
+                .filter((token) => token.role === 'agent')
+                .map((token) => token?.delta)
+                .join('');
+        },
+        get mainResponseFinished() {
+            return finished;
+        },
+        get messages() {
+            return initialMessages;
+        },
+        markMainResponseFinished() {
+            logger.debug('Conversation, markMainResponseFinished');
+            finished = true;
+        },
+        toString(ignoreDirectives = false) {
+            const serializedMessages = messages
+                .map((msg) => {
+                if (msg.sender === 'system') {
+                    return ignoreDirectives ? null : directivesFormatter(msg);
+                }
+                return `${names[msg.sender]}: ${msg.text}`;
+            })
+                .filter((line) => line !== null)
+                .join('\n');
+            if (responseTokens.length === 0) {
+                return serializedMessages;
+            }
+            return serializedMessages + '\n' + currentResponseFormatter(this.currentResponse);
+        },
+        getConversation() {
+            return messages;
+        },
+    };
+}

package/build/lib/stream/filter.d.ts

@@ -0,0 +1,6 @@
+import { ProgrammaticFilter } from './interfaces';
+/**
+ * filter out 'Agent:' at the beginning of the llm response
+ */
+export declare const defaultFilter: ProgrammaticFilter;
+//# sourceMappingURL=filter.d.ts.map

package/build/lib/stream/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../src/lib/stream/filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEjD;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,kBAc3B,CAAA"}

package/build/lib/stream/filter.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFilter = void 0;
+/**
+ * filter out 'Agent:' at the beginning of the llm response
+ */
+exports.defaultFilter = {
+    shouldStartFiltering(state, newToken) {
+        return state.currentResponse.trim().length === 0 && newToken.toLowerCase() === 'agent';
+    },
+    onNewToken(_state, filteredTokens) {
+        if (filteredTokens.length >= 2 && filteredTokens[1] === ':') {
+            return { action: 'RELEASE_TOKENS', tokens: filteredTokens.slice(2) };
+        }
+        return { action: 'RELEASE_TOKENS', tokens: filteredTokens };
+    },
+    onStreamEnd(_state, filteredTokens) {
+        return { tokensToRelease: filteredTokens };
+    },
+};

package/build/lib/stream/get-client.d.ts

@@ -0,0 +1,15 @@
+import OpenAI, { AzureOpenAI } from 'openai';
+import { Logger } from '../interfaces';
+interface AzureConfig {
+    endpoint: string;
+    apiVersion: string;
+    deployment: string;
+    apiKey: string;
+}
+interface OpenAiConfig {
+    apiKey: string;
+}
+export declare function getAzureClient(logger: Logger, config: AzureConfig): AzureOpenAI;
+export declare function getOpenAiClient(logger: Logger, config: OpenAiConfig): OpenAI;
+export {};
+//# sourceMappingURL=get-client.d.ts.map

package/build/lib/stream/get-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-client.d.ts","sourceRoot":"","sources":["../../../src/lib/stream/get-client.ts"],"names":[],"mappings":"AACA,OAAO,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAE5C,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAEtC,UAAU,WAAW;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,YAAY;IAClB,MAAM,EAAE,MAAM,CAAA;CACjB;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,eASjE;AACD,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,UAMnE"}

package/build/lib/stream/get-client.js

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAzureClient = getAzureClient;
+exports.getOpenAiClient = getOpenAiClient;
+// cspell:words Nagle's
+const openai_1 = __importStar(require("openai"));
+const undici_1 = require("undici");
+function getAzureClient(logger, config) {
+    logger.debug(`getting azure client: ${config.endpoint}, v: ${config.apiVersion}`);
+    return new openai_1.AzureOpenAI({
+        apiKey: config.apiKey,
+        apiVersion: config.apiVersion,
+        endpoint: config.endpoint,
+        deployment: config.deployment,
+        fetch: getOptimizedFetch(logger, new URL(config.endpoint).origin),
+    });
+}
+function getOpenAiClient(logger, config) {
+    logger.debug(`getting OpenAi client.`);
+    return new openai_1.default({
+        apiKey: config.apiKey,
+        fetch: getOptimizedFetch(logger, 'https://api.openai.com'),
+    });
+}
+function getOptimizedFetch(logger, url) {
+    const defaultHeaders = {
+        'content-type': 'application/json',
+        accept: 'application/json',
+        connection: 'keep-alive',
+    };
+    const httpClient = new undici_1.Client(url, {
+        // Keep connections alive for reuse
+        keepAliveTimeout: 120_000,
+        keepAliveMaxTimeout: 300_000,
+        // HTTP/1.1 pipelining for multiple requests
+        pipelining: 10,
+        // TCP socket optimizations
+        connect: {
+            // Disable Nagle's algorithm for lower latency
+            noDelay: true,
+            // Keep socket alive
+            keepAlive: true,
+            // Skip SSL verification for trusted API endpoints
+            rejectUnauthorized: false,
+        },
+        // DNS caching
+        maxCachedSessions: 100,
+        // Timeout optimizations
+        headersTimeout: 30000,
+        bodyTimeout: 60000,
+    });
+    process.on('SIGTERM', () => {
+        void httpClient.close();
+    });
+    process.on('SIGINT', () => {
+        void httpClient.close();
+    });
+    async function customFetch(url, options = {}) {
+        const requestUrl = url instanceof Request ? url.url : url.toString();
+        const method = options.method || 'GET';
+        logger.debug('Optimized Fetch', { method, url });
+        const originalHeaders = options.headers instanceof Headers
+            ? Object.fromEntries(options.headers.entries())
+            : options.headers;
+        const headers = {
+            ...defaultHeaders,
+            ...(originalHeaders || {}),
+        };
+        const response = await httpClient.request({
+            path: new URL(requestUrl).pathname + new URL(requestUrl).search,
+            method,
+            headers,
+            body: options.body,
+            origin: new URL(requestUrl).origin,
+        });
+        // Convert undici headers to standard Headers
+        const responseHeaders = new Headers();
+        Object.entries(response.headers).forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+                value.forEach((v) => responseHeaders.append(key, v));
+            }
+            else if (value !== undefined) {
+                responseHeaders.append(key, value);
+            }
+        });
+        if (response.statusCode === 429) {
+            console.warn('Quota limit exceeded.');
+        }
+        // Create a proper Response with streaming support
+        let canceled = false;
+        return new Response(new ReadableStream({
+            cancel() {
+                canceled = true;
+            },
+            start(controller) {
+                response.body.on('data', (chunk) => {
+                    if (canceled)
+                        return;
+                    try {
+                        controller.enqueue(chunk);
+                    }
+                    catch (e) {
+                        logger.error(e);
+                    }
+                });
+                response.body.on('end', () => {
+                    if (canceled)
+                        return;
+                    try {
+                        controller.close();
+                    }
+                    catch (e) {
+                        logger.error(e);
+                    }
+                });
+                response.body.on('error', (err) => {
+                    if (canceled)
+                        return;
+                    try {
+                        controller.error(err);
+                    }
+                    catch (e) {
+                        logger.error(e);
+                    }
+                });
+            },
+        }), {
+            status: response.statusCode,
+            headers: responseHeaders,
+        });
+    }
+    return customFetch;
+}

package/build/lib/stream/index.d.ts

@@ -0,0 +1,4 @@
+export { createAIStreamEngine } from './ai';
+export { AIStreamEngine, ProgrammaticFilter, LlmStreamAdapter, ResponseChunk, Transcript, StreamingEngineConfig, WorkflowConfig as StreamingWorkflowConfig, } from './interfaces';
+export { getAzureClient, getOpenAiClient } from './get-client';
+//# sourceMappingURL=index.d.ts.map

package/build/lib/stream/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/stream/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,MAAM,CAAA;AAE3C,OAAO,EACH,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,aAAa,EACb,UAAU,EACV,qBAAqB,EACrB,cAAc,IAAI,uBAAuB,GAC5C,MAAM,cAAc,CAAA;AAErB,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA"}

package/build/lib/stream/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOpenAiClient = exports.getAzureClient = exports.createAIStreamEngine = void 0;
+var ai_1 = require("./ai");
+Object.defineProperty(exports, "createAIStreamEngine", { enumerable: true, get: function () { return ai_1.createAIStreamEngine; } });
+var get_client_1 = require("./get-client");
+Object.defineProperty(exports, "getAzureClient", { enumerable: true, get: function () { return get_client_1.getAzureClient; } });
+Object.defineProperty(exports, "getOpenAiClient", { enumerable: true, get: function () { return get_client_1.getOpenAiClient; } });