@zimtsui/brainswitch 0.0.40 → 0.0.42

package/build/native-engines.d/openai-responses/engine.js

@@ -1,376 +1,340 @@
 import { Function } from "../../function.js";
 import { RoleMessage } from "./session.js";
 import { Tool } from "./tool.js";
-import { ResponseInvalid, Engine, UserAbortion, InferenceTimeout } from "../../engine.js";
+import { ResponseInvalid, Engine, USER_ABORTION, InferenceTimeout } from "../../engine.js";
 import {} from "../../inference-context.js";
 import OpenAI from 'openai';
-import assert from 'node:assert';
-import { fetch } from 'undici';
+import * as Undici from 'undici';
 import { OpenAIResponsesEngine } from "../../api-types/openai-responses.js";
+import { Throttle } from "../../throttle.js";
+import {} from "../../telemetry.js";
 export var OpenAIResponsesNativeEngine;
 (function (OpenAIResponsesNativeEngine) {
-    let Base;
-    (function (Base) {
-        class Instance {
-            instance;
-            apiURL;
-            parallel;
-            applyPatch;
-            toolChoice;
-            constructor(instance, options) {
-                this.instance = instance;
-                this.apiURL = new URL(`${this.instance.baseUrl}/responses`);
-                this.parallel = options.parallelToolCall ?? false;
-                this.applyPatch = options.applyPatch ?? false;
-                this.toolChoice = options.toolChoice ?? Function.ToolChoice.AUTO;
+    let OwnProps;
+    (function (OwnProps) {
+        function init(options) {
+            return {
+                apiURL: new URL(`${this.baseUrl}/responses`),
+                toolChoice: options.toolChoice ?? Function.ToolChoice.AUTO,
+                applyPatch: options.applyPatch ?? false,
+            };
+        }
+        OwnProps.init = init;
+    })(OwnProps = OpenAIResponsesNativeEngine.OwnProps || (OpenAIResponsesNativeEngine.OwnProps = {}));
+    async function stateless(wfctx, session) {
+        for (let retry = 0;; retry++) {
+            const signalTimeout = this.timeout ? AbortSignal.timeout(this.timeout) : undefined;
+            const signal = wfctx.signal && signalTimeout ? AbortSignal.any([
+                wfctx.signal,
+                signalTimeout,
+            ]) : wfctx.signal || signalTimeout;
+            try {
+                return await this.fetch(wfctx, session, signal);
             }
-            async stateless(ctx, session) {
-                for (let retry = 0;; retry++) {
-                    const signalTimeout = this.instance.timeout ? AbortSignal.timeout(this.instance.timeout) : undefined;
-                    const signal = ctx.signal && signalTimeout ? AbortSignal.any([
-                        ctx.signal,
-                        signalTimeout,
-                    ]) : ctx.signal || signalTimeout;
-                    try {
-                        return await this.fetch(ctx, session, signal);
-                    }
-                    catch (e) {
-                        if (ctx.signal?.aborted)
-                            throw new UserAbortion(); // 用户中止
-                        else if (signalTimeout?.aborted)
-                            e = new InferenceTimeout(undefined, { cause: e }); // 推理超时
-                        else if (e instanceof ResponseInvalid) { } // 模型抽风
-                        else if (e instanceof TypeError) { } // 网络故障
-                        else
-                            throw e;
-                        if (retry < 3)
-                            ctx.logger.message?.warn(e);
-                        else
-                            throw e;
-                    }
-                }
+            catch (e) {
+                if (wfctx.signal?.aborted)
+                    throw USER_ABORTION; // 用户中止
+                else if (signalTimeout?.aborted)
+                    e = new InferenceTimeout(undefined, { cause: e }); // 推理超时
+                else if (e instanceof ResponseInvalid) { } // 模型抽风
+                else if (e instanceof TypeError) { } // 网络故障
+                else
+                    throw e;
+                if (retry < 3)
+                    this.logger.message?.warn(e);
+                else
+                    throw e;
             }
-            async stateful(ctx, session) {
-                const response = await this.stateless(ctx, session);
-                session.chatMessages.push(response);
-                return response;
+        }
+    }
+    OpenAIResponsesNativeEngine.stateless = stateless;
+    async function stateful(wfctx, session) {
+        const response = await this.stateless(wfctx, session);
+        session.chatMessages.push(response);
+        return response;
+    }
+    OpenAIResponsesNativeEngine.stateful = stateful;
+    function appendUserMessage(session, message) {
+        return {
+            ...session,
+            chatMessages: [...session.chatMessages, message],
+        };
+    }
+    OpenAIResponsesNativeEngine.appendUserMessage = appendUserMessage;
+    function pushUserMessage(session, message) {
+        session.chatMessages.push(message);
+        return session;
+    }
+    OpenAIResponsesNativeEngine.pushUserMessage = pushUserMessage;
+    function convertToAiMessage(output) {
+        const parts = output.flatMap((item) => {
+            if (item.type === 'message') {
+                if (item.content.every(part => part.type === 'output_text')) { }
+                else
+                    throw new Error();
+                return [RoleMessage.Part.Text.create(item.content.map(part => part.text).join(''))];
             }
-            appendUserMessage(session, message) {
+            else if (item.type === 'function_call')
+                return [this.convertToFunctionCall(item)];
+            else if (item.type === 'reasoning')
+                return [];
+            else if (item.type === 'apply_patch_call')
+                return [Tool.ApplyPatch.Call.create(item)];
+            else
+                throw new Error();
+        });
+        return RoleMessage.Ai.create(parts, output);
+    }
+    OpenAIResponsesNativeEngine.convertToAiMessage = convertToAiMessage;
+    function convertFromUserMessage(userMessage) {
+        return userMessage.getParts().map(part => {
+            if (part instanceof RoleMessage.Part.Text.Instance)
                 return {
-                    ...session,
-                    chatMessages: [...session.chatMessages, message],
+                    type: 'message',
+                    role: 'user',
+                    content: part.text,
                 };
-            }
-            pushUserMessage(session, message) {
-                session.chatMessages.push(message);
-                return session;
-            }
-            convertToAiMessage(output) {
-                const parts = output.flatMap((item) => {
-                    if (item.type === 'message') {
-                        assert(item.content.every(part => part.type === 'output_text'));
-                        return [RoleMessage.Part.Text.create(item.content.map(part => part.text).join(''))];
-                    }
-                    else if (item.type === 'function_call')
-                        return [this.instance.convertToFunctionCall(item)];
-                    else if (item.type === 'reasoning')
-                        return [];
-                    else if (item.type === 'apply_patch_call')
-                        return [Tool.ApplyPatch.Call.create(item)];
+            else if (part instanceof Function.Response)
+                return this.convertFromFunctionResponse(part);
+            else if (part instanceof Tool.ApplyPatch.Response)
+                return {
+                    type: 'apply_patch_call_output',
+                    call_id: part.id,
+                    status: part.failure ? 'failed' : 'completed',
+                    output: part.failure || undefined,
+                };
+            else
+                throw new Error();
+        });
+    }
+    OpenAIResponsesNativeEngine.convertFromUserMessage = convertFromUserMessage;
+    function convertFromDeveloperMessage(developerMessage) {
+        return developerMessage.getOnlyText();
+    }
+    OpenAIResponsesNativeEngine.convertFromDeveloperMessage = convertFromDeveloperMessage;
+    function convertFromChatMessage(chatMessage) {
+        if (chatMessage instanceof RoleMessage.User.Instance)
+            return this.convertFromUserMessage(chatMessage);
+        else if (chatMessage instanceof RoleMessage.Ai.Instance)
+            return chatMessage.getRaw();
+        else
+            throw new Error();
+    }
+    OpenAIResponsesNativeEngine.convertFromChatMessage = convertFromChatMessage;
+    function convertFromToolChoice(toolChoice) {
+        if (toolChoice === Function.ToolChoice.NONE)
+            return 'none';
+        else if (toolChoice === Function.ToolChoice.REQUIRED)
+            return 'required';
+        else if (toolChoice === Function.ToolChoice.AUTO)
+            return 'auto';
+        else {
+            return {
+                type: 'allowed_tools',
+                mode: 'required',
+                tools: toolChoice.map(name => {
+                    if (name === Tool.Choice.APPLY_PATCH)
+                        return { type: 'apply_patch' };
                     else
-                        throw new Error();
-                });
-                return RoleMessage.Ai.create(parts, output);
+                        return { type: 'function', name };
+                }),
+            };
+        }
+    }
+    OpenAIResponsesNativeEngine.convertFromToolChoice = convertFromToolChoice;
+    function makeMonolithParams(session) {
+        const fdentries = Object.entries(this.fdm);
+        const tools = fdentries.map(fdentry => this.convertFromFunctionDeclarationEntry(fdentry));
+        if (this.applyPatch)
+            tools.push({ type: 'apply_patch' });
+        return {
+            model: this.model,
+            include: ['reasoning.encrypted_content'],
+            store: false,
+            input: session.chatMessages.flatMap(chatMessage => this.convertFromChatMessage(chatMessage)),
+            instructions: session.developerMessage && this.convertFromDeveloperMessage(session.developerMessage),
+            tools: tools.length ? tools : undefined,
+            tool_choice: tools.length ? this.convertFromToolChoice(this.toolChoice) : undefined,
+            parallel_tool_calls: fdentries.length ? this.parallelToolCall : undefined,
+            max_output_tokens: this.maxTokens,
+            ...this.additionalOptions,
+        };
+    }
+    OpenAIResponsesNativeEngine.makeMonolithParams = makeMonolithParams;
+    function logAiMessage(output) {
+        for (const item of output)
+            if (item.type === 'message') {
+                if (item.content.every(part => part.type === 'output_text')) { }
+                else
+                    throw new Error();
+                this.logger.inference?.debug(item.content.map(part => part.text).join('') + '\n');
             }
-            convertFromUserMessage(userMessage) {
-                return userMessage.getParts().map(part => {
-                    if (part instanceof RoleMessage.Part.Text.Instance)
-                        return {
-                            type: 'message',
-                            role: 'user',
-                            content: part.text,
-                        };
-                    else if (part instanceof Function.Response)
-                        return this.instance.convertFromFunctionResponse(part);
-                    else if (part instanceof Tool.ApplyPatch.Response)
-                        return {
-                            type: 'apply_patch_call_output',
-                            call_id: part.id,
-                            status: part.failure ? 'failed' : 'completed',
-                            output: part.failure || undefined,
-                        };
+            else if (item.type === 'function_call')
+                this.logger.message?.debug(item);
+            else if (item.type === 'apply_patch_call')
+                this.logger.message?.debug(item);
+    }
+    OpenAIResponsesNativeEngine.logAiMessage = logAiMessage;
+    async function fetch(wfctx, session, signal) {
+        return await this.fetchRaw(wfctx, session, signal).catch(e => Promise.reject(e instanceof OpenAI.APIError ? new ResponseInvalid(undefined, { cause: e }) : e));
+    }
+    OpenAIResponsesNativeEngine.fetch = fetch;
+    async function fetchRaw(wfctx, session, signal) {
+        const params = this.makeMonolithParams(session);
+        this.logger.message?.trace(params);
+        await this.throttle.requests(wfctx);
+        const res = await Undici.fetch(this.apiURL, {
+            method: 'POST',
+            headers: new Headers({
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+            }),
+            body: JSON.stringify(params),
+            dispatcher: this.proxyAgent,
+            signal,
+        });
+        if (res.ok) { }
+        else
+            throw new Error(undefined, { cause: res });
+        const response = await res.json();
+        this.logger.message?.trace(response);
+        if (response.status === 'incomplete' && response.incomplete_details?.reason === 'max_output_tokens')
+            throw new ResponseInvalid('Token limit exceeded.', { cause: response });
+        if (response.status === 'completed') { }
+        else
+            throw new ResponseInvalid('Abnormal response status', { cause: response });
+        this.logAiMessage(response.output);
+        if (response.usage) { }
+        else
+            throw new Error();
+        const cost = this.calcCost(response.usage);
+        wfctx.cost?.(cost);
+        this.logger.message?.debug(response.usage);
+        const aiMessage = this.convertToAiMessage(response.output);
+        this.validateToolCallsByToolChoice(aiMessage.getToolCalls());
+        return aiMessage;
+    }
+    OpenAIResponsesNativeEngine.fetchRaw = fetchRaw;
+    function validateToolCallsByToolChoice(toolCalls) {
+        if (this.toolChoice === Function.ToolChoice.REQUIRED)
+            if (toolCalls.length) { }
+            else
+                throw new ResponseInvalid('Invalid function call', { cause: toolCalls });
+        else if (this.toolChoice instanceof Array)
+            for (const tc of toolCalls) {
+                if (tc instanceof Function.Call)
+                    if (this.toolChoice.includes(tc.name)) { }
                     else
-                        throw new Error();
-                });
-            }
-            convertFromDeveloperMessage(developerMessage) {
-                return developerMessage.getOnlyText();
-            }
-            convertFromChatMessage(chatMessage) {
-                if (chatMessage instanceof RoleMessage.User.Instance)
-                    return this.convertFromUserMessage(chatMessage);
-                else if (chatMessage instanceof RoleMessage.Ai.Instance)
-                    return chatMessage.getRaw();
+                        throw new ResponseInvalid('Invalid function call', { cause: toolCalls });
+                else if (tc instanceof Tool.ApplyPatch.Call)
+                    if (this.toolChoice.includes(Tool.Choice.APPLY_PATCH)) { }
+                    else
+                        throw new ResponseInvalid('Invalid function call', { cause: toolCalls });
                 else
                     throw new Error();
             }
-            convertFromToolChoice(toolChoice) {
-                if (toolChoice === Function.ToolChoice.NONE)
-                    return 'none';
-                else if (toolChoice === Function.ToolChoice.REQUIRED)
-                    return 'required';
-                else if (toolChoice === Function.ToolChoice.AUTO)
-                    return 'auto';
-                else {
-                    return {
-                        type: 'allowed_tools',
-                        mode: 'required',
-                        tools: toolChoice.map(name => {
-                            if (name === Tool.Choice.APPLY_PATCH)
-                                return { type: 'apply_patch' };
-                            else
-                                return { type: 'function', name };
-                        }),
-                    };
-                }
-            }
-            makeMonolithParams(session) {
-                const fdentries = Object.entries(this.instance.fdm);
-                const tools = fdentries.map(fdentry => this.instance.convertFromFunctionDeclarationEntry(fdentry));
-                if (this.applyPatch)
-                    tools.push({ type: 'apply_patch' });
-                return {
-                    model: this.instance.model,
-                    include: ['reasoning.encrypted_content'],
-                    store: false,
-                    input: session.chatMessages.flatMap(chatMessage => this.convertFromChatMessage(chatMessage)),
-                    instructions: session.developerMessage && this.convertFromDeveloperMessage(session.developerMessage),
-                    tools: tools.length ? tools : undefined,
-                    tool_choice: tools.length ? this.convertFromToolChoice(this.toolChoice) : undefined,
-                    parallel_tool_calls: fdentries.length ? this.parallel : undefined,
-                    max_output_tokens: this.instance.maxTokens,
-                    ...this.instance.additionalOptions,
-                };
-            }
-            logAiMessage(ctx, output) {
-                for (const item of output)
-                    if (item.type === 'message') {
-                        assert(item.content.every(part => part.type === 'output_text'));
-                        ctx.logger.inference?.debug(item.content.map(part => part.text).join('') + '\n');
-                    }
-                    else if (item.type === 'function_call')
-                        ctx.logger.message?.debug(item);
-                    else if (item.type === 'apply_patch_call')
-                        ctx.logger.message?.debug(item);
-            }
-            async fetch(ctx, session, signal) {
-                return await this.fetchRaw(ctx, session, signal).catch(e => Promise.reject(e instanceof OpenAI.APIError ? new ResponseInvalid(undefined, { cause: e }) : e));
-            }
-            async fetchRaw(ctx, session, signal) {
-                const params = this.makeMonolithParams(session);
-                ctx.logger.message?.trace(params);
-                await this.instance.throttle.requests(ctx);
-                const res = await fetch(this.apiURL, {
-                    method: 'POST',
-                    headers: new Headers({
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${this.instance.apiKey}`,
-                    }),
-                    body: JSON.stringify(params),
-                    dispatcher: this.instance.proxyAgent,
-                    signal,
-                });
-                assert(res.ok, new Error(undefined, { cause: res }));
-                const response = await res.json();
-                ctx.logger.message?.trace(response);
-                if (response.status === 'incomplete' && response.incomplete_details?.reason === 'max_output_tokens')
-                    throw new ResponseInvalid('Token limit exceeded.', { cause: response });
-                assert(response.status === 'completed', new ResponseInvalid('Abnormal response status', { cause: response }));
-                this.logAiMessage(ctx, response.output);
-                assert(response.usage);
-                const cost = this.instance.calcCost(response.usage);
-                ctx.logger.cost?.(cost);
-                ctx.logger.message?.debug(response.usage);
-                const aiMessage = this.convertToAiMessage(response.output);
-                this.validateToolCallsByToolChoice(aiMessage.getToolCalls());
-                return aiMessage;
-            }
-            validateToolCallsByToolChoice(toolCalls) {
-                if (this.toolChoice === Function.ToolChoice.REQUIRED)
-                    assert(toolCalls.length, new ResponseInvalid('Invalid function call', { cause: toolCalls }));
-                else if (this.toolChoice instanceof Array)
-                    for (const tc of toolCalls) {
-                        if (tc instanceof Function.Call)
-                            assert(this.toolChoice.includes(tc.name), new ResponseInvalid('Invalid function call', { cause: toolCalls }));
-                        else if (tc instanceof Tool.ApplyPatch.Call)
-                            assert(this.toolChoice.includes(Tool.Choice.APPLY_PATCH), new ResponseInvalid('Invalid function call', { cause: toolCalls }));
-                        else
-                            throw new Error();
-                    }
-                else if (this.toolChoice === Function.ToolChoice.NONE)
-                    assert(!toolCalls.length, new ResponseInvalid('Invalid function call', { cause: toolCalls }));
-            }
-        }
-        Base.Instance = Instance;
-    })(Base = OpenAIResponsesNativeEngine.Base || (OpenAIResponsesNativeEngine.Base = {}));
+        else if (this.toolChoice === Function.ToolChoice.NONE)
+            if (!toolCalls.length) { }
+            else
+                throw new ResponseInvalid('Invalid function call', { cause: toolCalls });
+    }
+    OpenAIResponsesNativeEngine.validateToolCallsByToolChoice = validateToolCallsByToolChoice;
     class Instance {
-        engineBase;
-        openAIResponsesEngineBase;
-        openAIResponsesNativeEngineBase;
+        baseUrl;
+        apiKey;
+        model;
+        name;
+        inputPrice;
+        outputPrice;
+        cachePrice;
+        fdm;
+        additionalOptions;
+        throttle;
+        timeout;
+        maxTokens;
+        proxyAgent;
+        logger;
+        apiURL;
+        parallelToolCall;
+        applyPatch;
+        toolChoice;
         constructor(options) {
-            this.engineBase = new Engine.Base.Instance(this, options);
-            this.openAIResponsesEngineBase = new OpenAIResponsesEngine.Base.Instance(this);
-            this.openAIResponsesNativeEngineBase = new OpenAIResponsesNativeEngine.Base.Instance(this, options);
-        }
-        get baseUrl() {
-            return this.engineBase.baseUrl;
-        }
-        set baseUrl(value) {
-            this.engineBase.baseUrl = value;
-        }
-        get apiKey() {
-            return this.engineBase.apiKey;
-        }
-        set apiKey(value) {
-            this.engineBase.apiKey = value;
-        }
-        get model() {
-            return this.engineBase.model;
-        }
-        set model(value) {
-            this.engineBase.model = value;
-        }
-        get name() {
-            return this.engineBase.name;
-        }
-        set name(value) {
-            this.engineBase.name = value;
-        }
-        get inputPrice() {
-            return this.engineBase.inputPrice;
-        }
-        set inputPrice(value) {
-            this.engineBase.inputPrice = value;
-        }
-        get outputPrice() {
-            return this.engineBase.outputPrice;
-        }
-        set outputPrice(value) {
-            this.engineBase.outputPrice = value;
-        }
-        get cachedPrice() {
-            return this.engineBase.cachedPrice;
-        }
-        set cachedPrice(value) {
-            this.engineBase.cachedPrice = value;
-        }
-        get fdm() {
-            return this.engineBase.fdm;
-        }
-        set fdm(value) {
-            this.engineBase.fdm = value;
-        }
-        get additionalOptions() {
-            return this.engineBase.additionalOptions;
-        }
-        set additionalOptions(value) {
-            this.engineBase.additionalOptions = value;
-        }
-        get throttle() {
-            return this.engineBase.throttle;
-        }
-        set throttle(value) {
-            this.engineBase.throttle = value;
-        }
-        get timeout() {
-            return this.engineBase.timeout;
-        }
-        set timeout(value) {
-            this.engineBase.timeout = value;
-        }
-        get maxTokens() {
-            return this.engineBase.maxTokens;
-        }
-        set maxTokens(value) {
-            this.engineBase.maxTokens = value;
-        }
-        get proxyAgent() {
-            return this.engineBase.proxyAgent;
-        }
-        set proxyAgent(value) {
-            this.engineBase.proxyAgent = value;
+            ({
+                baseUrl: this.baseUrl,
+                apiKey: this.apiKey,
+                model: this.model,
+                name: this.name,
+                inputPrice: this.inputPrice,
+                outputPrice: this.outputPrice,
+                cachePrice: this.cachePrice,
+                fdm: this.fdm,
+                additionalOptions: this.additionalOptions,
+                throttle: this.throttle,
+                timeout: this.timeout,
+                maxTokens: this.maxTokens,
+                proxyAgent: this.proxyAgent,
+                logger: this.logger,
+            } = (Engine.OwnProps.init).call(this, options));
+            ({ parallelToolCall: this.parallelToolCall } = (OpenAIResponsesEngine.OwnProps.init).call(this, options));
+            ({
+                applyPatch: this.applyPatch,
+                toolChoice: this.toolChoice,
+                apiURL: this.apiURL,
+            } = (OwnProps.init).call(this, options));
         }
         convertFromFunctionResponse(fr) {
-            return this.openAIResponsesEngineBase.convertFromFunctionResponse(fr);
+            return (OpenAIResponsesEngine.convertFromFunctionResponse).call(this, fr);
         }
         calcCost(usage) {
-            return this.openAIResponsesEngineBase.calcCost(usage);
+            return (OpenAIResponsesEngine.calcCost).call(this, usage);
         }
         convertFromFunctionDeclarationEntry(fdentry) {
-            return this.openAIResponsesEngineBase.convertFromFunctionDeclarationEntry(fdentry);
+            return (OpenAIResponsesEngine.convertFromFunctionDeclarationEntry).call(this, fdentry);
         }
         convertToFunctionCall(apifc) {
-            return this.openAIResponsesEngineBase.convertToFunctionCall(apifc);
-        }
-        get toolChoice() {
-            return this.openAIResponsesNativeEngineBase.toolChoice;
-        }
-        set toolChoice(value) {
-            this.openAIResponsesNativeEngineBase.toolChoice = value;
-        }
-        get parallel() {
-            return this.openAIResponsesNativeEngineBase.parallel;
-        }
-        set parallel(value) {
-            this.openAIResponsesNativeEngineBase.parallel = value;
-        }
-        get applyPatch() {
-            return this.openAIResponsesNativeEngineBase.applyPatch;
-        }
-        set applyPatch(value) {
-            this.openAIResponsesNativeEngineBase.applyPatch = value;
+            return (OpenAIResponsesEngine.convertToFunctionCall).call(this, apifc);
         }
-        stateless(ctx, session) {
-            return this.openAIResponsesNativeEngineBase.stateless(ctx, session);
+        stateless(wfctx, session) {
+            return (OpenAIResponsesNativeEngine.stateless).call(this, wfctx, session);
         }
-        stateful(ctx, session) {
-            return this.openAIResponsesNativeEngineBase.stateful(ctx, session);
+        stateful(wfctx, session) {
+            return (OpenAIResponsesNativeEngine.stateful).call(this, wfctx, session);
         }
         appendUserMessage(session, message) {
-            return this.openAIResponsesNativeEngineBase.appendUserMessage(session, message);
+            return (OpenAIResponsesNativeEngine.appendUserMessage).call(this, session, message);
         }
         pushUserMessage(session, message) {
-            return this.openAIResponsesNativeEngineBase.pushUserMessage(session, message);
+            return (OpenAIResponsesNativeEngine.pushUserMessage).call(this, session, message);
         }
-        async fetch(ctx, session, signal) {
-            return this.openAIResponsesNativeEngineBase.fetch(ctx, session, signal);
+        async fetch(wfctx, session, signal) {
+            return (OpenAIResponsesNativeEngine.fetch).call(this, wfctx, session, signal);
         }
-        async fetchRaw(ctx, session, signal) {
-            return this.openAIResponsesNativeEngineBase.fetchRaw(ctx, session, signal);
+        async fetchRaw(wfctx, session, signal) {
+            return (OpenAIResponsesNativeEngine.fetchRaw).call(this, wfctx, session, signal);
         }
         convertToAiMessage(output) {
-            return this.openAIResponsesNativeEngineBase.convertToAiMessage(output);
+            return (OpenAIResponsesNativeEngine.convertToAiMessage).call(this, output);
         }
         convertFromChatMessage(chatMessage) {
-            return this.openAIResponsesNativeEngineBase.convertFromChatMessage(chatMessage);
+            return (OpenAIResponsesNativeEngine.convertFromChatMessage).call(this, chatMessage);
         }
         convertFromUserMessage(userMessage) {
-            return this.openAIResponsesNativeEngineBase.convertFromUserMessage(userMessage);
+            return (OpenAIResponsesNativeEngine.convertFromUserMessage).call(this, userMessage);
         }
         convertFromDeveloperMessage(developerMessage) {
-            return this.openAIResponsesNativeEngineBase.convertFromDeveloperMessage(developerMessage);
+            return (OpenAIResponsesNativeEngine.convertFromDeveloperMessage).call(this, developerMessage);
         }
         convertFromToolChoice(toolChoice) {
-            return this.openAIResponsesNativeEngineBase.convertFromToolChoice(toolChoice);
+            return (OpenAIResponsesNativeEngine.convertFromToolChoice).call(this, toolChoice);
         }
         makeMonolithParams(session) {
-            return this.openAIResponsesNativeEngineBase.makeMonolithParams(session);
+            return (OpenAIResponsesNativeEngine.makeMonolithParams).call(this, session);
         }
-        logAiMessage(ctx, output) {
-            return this.openAIResponsesNativeEngineBase.logAiMessage(ctx, output);
+        logAiMessage(output) {
+            return (OpenAIResponsesNativeEngine.logAiMessage).call(this, output);
         }
         validateToolCallsByToolChoice(toolCalls) {
-            return this.openAIResponsesNativeEngineBase.validateToolCallsByToolChoice(toolCalls);
+            return (OpenAIResponsesNativeEngine.validateToolCallsByToolChoice).call(this, toolCalls);
         }
     }
     OpenAIResponsesNativeEngine.Instance = Instance;