@zimtsui/brainswitch 0.0.40 → 0.0.42

package/build/native-engines.d/google/engine.js

@@ -1,340 +1,310 @@
 import { Function } from "../../function.js";
 import { RoleMessage } from "./session.js";
-import { ResponseInvalid, Engine, UserAbortion, InferenceTimeout } from "../../engine.js";
+import { ResponseInvalid, Engine, USER_ABORTION, InferenceTimeout } from "../../engine.js";
 import {} from "../../inference-context.js";
 import * as Google from '@google/genai';
-import assert from 'node:assert';
-import { fetch } from 'undici';
+import * as Undici from 'undici';
 import { GoogleEngine } from "../../api-types/google.js";
 import { GoogleCompatibleEngine } from "../../compatible-engines.d/google.js";
 import { CompatibleEngine } from "../../compatible-engine.js";
+import { Throttle } from "../../throttle.js";
+import {} from "../../telemetry.js";
 export var GoogleNativeEngine;
 (function (GoogleNativeEngine) {
-    let Base;
-    (function (Base) {
-        class Instance {
-            instance;
-            apiURL;
-            parallel;
-            codeExecution;
-            urlContext;
-            googleSearch;
-            toolChoice;
-            constructor(instance, options) {
-                this.instance = instance;
-                this.apiURL = new URL(`${this.instance.baseUrl}/v1beta/models/${this.instance.model}:generateContent`);
-                this.parallel = options.parallelToolCall ?? false;
-                this.codeExecution = options.codeExecution ?? false;
-                this.urlContext = options.urlContext ?? false;
-                this.googleSearch = options.googleSearch ?? false;
-                this.toolChoice = options.toolChoice ?? Function.ToolChoice.AUTO;
+    let OwnProps;
+    (function (OwnProps) {
+        function init(options) {
+            return {
+                apiURL: new URL(`${this.baseUrl}/v1beta/models/${this.model}:generateContent`),
+                codeExecution: options.codeExecution ?? false,
+                urlContext: options.urlContext ?? false,
+                googleSearch: options.googleSearch ?? false,
+                toolChoice: options.toolChoice ?? Function.ToolChoice.AUTO,
+            };
+        }
+        OwnProps.init = init;
+    })(OwnProps = GoogleNativeEngine.OwnProps || (GoogleNativeEngine.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;
-            }
-            appendUserMessage(session, message) {
-                return {
-                    ...session,
-                    chatMessages: [...session.chatMessages, message],
-                };
-            }
-            pushUserMessage(session, message) {
-                session.chatMessages.push(message);
-                return session;
-            }
-            convertToAiMessage(content) {
-                assert(content.parts);
-                return RoleMessage.Ai.create(content.parts.flatMap(part => {
-                    const parts = [];
-                    let payload = false;
-                    if (part.text) {
-                        payload = true;
-                        parts.push(RoleMessage.Part.Text.create(part.text));
-                    }
-                    if (part.functionCall) {
-                        payload = true;
-                        parts.push(this.instance.convertToFunctionCall(part.functionCall));
-                    }
-                    if (this.instance.codeExecution && part.executableCode) {
-                        payload = true;
-                        assert(part.executableCode.code);
-                        assert(part.executableCode.language);
-                        parts.push(RoleMessage.Ai.Part.ExecutableCode.create(part.executableCode.code, part.executableCode.language));
-                    }
-                    if (this.instance.codeExecution && part.codeExecutionResult) {
-                        payload = true;
-                        assert(part.codeExecutionResult.outcome);
-                        parts.push(RoleMessage.Ai.Part.CodeExecutionResult.create(part.codeExecutionResult.outcome, part.codeExecutionResult.output));
-                    }
-                    assert(payload, new ResponseInvalid('Unknown content part', { cause: content }));
-                    return parts;
-                }), content);
-            }
-            convertFromAiMessage(aiMessage) {
-                return aiMessage.getRaw();
-            }
-            convertFromUserMessage(userMessage) {
-                return GoogleCompatibleEngine.convertFromUserMessage(userMessage);
-            }
-            convertFromDeveloperMessage(developerMessage) {
-                return GoogleCompatibleEngine.convertFromDeveloperMessage(developerMessage);
-            }
-            convertFromChatMessages(chatMessages) {
-                return chatMessages.map(chatMessage => {
-                    if (chatMessage instanceof RoleMessage.User.Instance)
-                        return this.convertFromUserMessage(chatMessage);
-                    else if (chatMessage instanceof RoleMessage.Ai.Instance)
-                        return this.convertFromAiMessage(chatMessage);
-                    else
-                        throw new Error();
-                });
+        }
+    }
+    GoogleNativeEngine.stateless = stateless;
+    async function stateful(wfctx, session) {
+        const response = await this.stateless(wfctx, session);
+        session.chatMessages.push(response);
+        return response;
+    }
+    GoogleNativeEngine.stateful = stateful;
+    function appendUserMessage(session, message) {
+        return {
+            ...session,
+            chatMessages: [...session.chatMessages, message],
+        };
+    }
+    GoogleNativeEngine.appendUserMessage = appendUserMessage;
+    function pushUserMessage(session, message) {
+        session.chatMessages.push(message);
+        return session;
+    }
+    GoogleNativeEngine.pushUserMessage = pushUserMessage;
+    function convertToAiMessage(content) {
+        if (content.parts) { }
+        else
+            throw new Error();
+        return RoleMessage.Ai.create(content.parts.flatMap(part => {
+            const parts = [];
+            let payload = false;
+            if (part.text) {
+                payload = true;
+                parts.push(RoleMessage.Part.Text.create(part.text));
             }
-            convertFromToolChoice(toolChoice) {
-                return GoogleCompatibleEngine.convertFromToolChoice(toolChoice);
+            if (part.functionCall) {
+                payload = true;
+                parts.push(this.convertToFunctionCall(part.functionCall));
             }
-            async fetch(ctx, session, signal) {
-                const systemInstruction = session.developerMessage && this.instance.convertFromDeveloperMessage(session.developerMessage);
-                const contents = this.instance.convertFromChatMessages(session.chatMessages);
-                await this.instance.throttle.requests(ctx);
-                const fdentries = Object.entries(this.instance.fdm);
-                const functionDeclarations = fdentries.map(fdentry => this.instance.convertFromFunctionDeclarationEntry(fdentry));
-                const tools = [];
-                if (functionDeclarations.length)
-                    tools.push({ functionDeclarations });
-                if (this.urlContext)
-                    tools.push({ urlContext: {} });
-                if (this.googleSearch)
-                    tools.push({ googleSearch: {} });
-                if (this.codeExecution)
-                    tools.push({ codeExecution: {} });
-                const reqbody = {
-                    contents,
-                    tools: tools.length ? tools : undefined,
-                    toolConfig: functionDeclarations.length ? {
-                        functionCallingConfig: this.instance.convertFromToolChoice(this.instance.toolChoice),
-                    } : undefined,
-                    systemInstruction,
-                    generationConfig: this.instance.maxTokens || this.instance.additionalOptions ? {
-                        maxOutputTokens: this.instance.maxTokens ?? undefined,
-                        ...this.instance.additionalOptions,
-                    } : undefined,
-                };
-                ctx.logger.message?.trace(reqbody);
-                const res = await fetch(this.apiURL, {
-                    method: 'POST',
-                    headers: new Headers({
-                        'Content-Type': 'application/json',
-                        'x-goog-api-key': this.instance.apiKey,
-                    }),
-                    body: JSON.stringify(reqbody),
-                    dispatcher: this.instance.proxyAgent,
-                    signal,
-                });
-                ctx.logger.message?.trace(res);
-                assert(res.ok, new Error(undefined, { cause: res }));
-                const response = await res.json();
-                assert(response.candidates?.[0]?.content?.parts?.length, new ResponseInvalid('Content missing', { cause: response }));
-                if (response.candidates[0].finishReason === Google.FinishReason.MAX_TOKENS)
-                    throw new ResponseInvalid('Token limit exceeded.', { cause: response });
-                assert(response.candidates[0].finishReason === Google.FinishReason.STOP, new ResponseInvalid('Abnormal finish reason', { cause: response }));
-                for (const part of response.candidates[0].content.parts) {
-                    if (part.text)
-                        ctx.logger.inference?.debug(part.text + '\n');
-                    if (part.functionCall)
-                        ctx.logger.message?.debug(part.functionCall);
-                }
-                assert(response.usageMetadata?.promptTokenCount, new Error('Prompt token count absent', { cause: response }));
-                ctx.logger.message?.debug(response.usageMetadata);
-                const candidatesTokenCount = response.usageMetadata.candidatesTokenCount ?? 0;
-                const cacheHitTokenCount = response.usageMetadata.cachedContentTokenCount ?? 0;
-                const cacheMissTokenCount = response.usageMetadata.promptTokenCount - cacheHitTokenCount;
-                const thinkingTokenCount = response.usageMetadata.thoughtsTokenCount ?? 0;
-                const cost = this.instance.inputPrice * cacheMissTokenCount / 1e6 +
-                    this.instance.cachedPrice * cacheHitTokenCount / 1e6 +
-                    this.instance.outputPrice * candidatesTokenCount / 1e6 +
-                    this.instance.outputPrice * thinkingTokenCount / 1e6;
-                ctx.logger.cost?.(cost);
-                const aiMessage = this.instance.convertToAiMessage(response.candidates[0].content);
-                this.instance.validateToolCallsByToolChoice(aiMessage.getFunctionCalls());
-                return aiMessage;
+            if (this.codeExecution && part.executableCode) {
+                payload = true;
+                if (part.executableCode.code) { }
+                else
+                    throw new Error();
+                if (part.executableCode.language) { }
+                else
+                    throw new Error();
+                parts.push(RoleMessage.Ai.Part.ExecutableCode.create(part.executableCode.code, part.executableCode.language));
             }
-            validateToolCallsByToolChoice(toolCalls) {
-                return CompatibleEngine.validateToolCallsByToolChoice(toolCalls, this.toolChoice);
+            if (this.codeExecution && part.codeExecutionResult) {
+                payload = true;
+                if (part.codeExecutionResult.outcome) { }
+                else
+                    throw new Error();
+                parts.push(RoleMessage.Ai.Part.CodeExecutionResult.create(part.codeExecutionResult.outcome, part.codeExecutionResult.output));
             }
-        }
-        Base.Instance = Instance;
-    })(Base = GoogleNativeEngine.Base || (GoogleNativeEngine.Base = {}));
+            if (payload) { }
+            else
+                throw new ResponseInvalid('Unknown content part', { cause: content });
+            return parts;
+        }), content);
+    }
+    GoogleNativeEngine.convertToAiMessage = convertToAiMessage;
+    function convertFromAiMessage(aiMessage) {
+        return aiMessage.getRaw();
+    }
+    GoogleNativeEngine.convertFromAiMessage = convertFromAiMessage;
+    function convertFromUserMessage(userMessage) {
+        return (GoogleCompatibleEngine.convertFromUserMessage).call(this, userMessage);
+    }
+    GoogleNativeEngine.convertFromUserMessage = convertFromUserMessage;
+    function convertFromDeveloperMessage(developerMessage) {
+        return (GoogleCompatibleEngine.convertFromDeveloperMessage).call(this, developerMessage);
+    }
+    GoogleNativeEngine.convertFromDeveloperMessage = convertFromDeveloperMessage;
+    function convertFromChatMessages(chatMessages) {
+        return chatMessages.map(chatMessage => {
+            if (chatMessage instanceof RoleMessage.User.Instance)
+                return this.convertFromUserMessage(chatMessage);
+            else if (chatMessage instanceof RoleMessage.Ai.Instance)
+                return this.convertFromAiMessage(chatMessage);
+            else
+                throw new Error();
+        });
+    }
+    GoogleNativeEngine.convertFromChatMessages = convertFromChatMessages;
+    function convertFromToolChoice(toolChoice) {
+        return (GoogleCompatibleEngine.convertFromToolChoice).call(this, toolChoice);
+    }
+    GoogleNativeEngine.convertFromToolChoice = convertFromToolChoice;
+    async function fetch(wfctx, session, signal) {
+        const systemInstruction = session.developerMessage && this.convertFromDeveloperMessage(session.developerMessage);
+        const contents = this.convertFromChatMessages(session.chatMessages);
+        await this.throttle.requests(wfctx);
+        const fdentries = Object.entries(this.fdm);
+        const functionDeclarations = fdentries.map(fdentry => this.convertFromFunctionDeclarationEntry(fdentry));
+        const tools = [];
+        if (functionDeclarations.length)
+            tools.push({ functionDeclarations });
+        if (this.urlContext)
+            tools.push({ urlContext: {} });
+        if (this.googleSearch)
+            tools.push({ googleSearch: {} });
+        if (this.codeExecution)
+            tools.push({ codeExecution: {} });
+        const reqbody = {
+            contents,
+            tools: tools.length ? tools : undefined,
+            toolConfig: functionDeclarations.length ? {
+                functionCallingConfig: this.convertFromToolChoice(this.toolChoice),
+            } : undefined,
+            systemInstruction,
+            generationConfig: this.maxTokens || this.additionalOptions ? {
+                maxOutputTokens: this.maxTokens ?? undefined,
+                ...this.additionalOptions,
+            } : undefined,
+        };
+        this.logger.message?.trace(reqbody);
+        const res = await Undici.fetch(this.apiURL, {
+            method: 'POST',
+            headers: new Headers({
+                'Content-Type': 'application/json',
+                'x-goog-api-key': this.apiKey,
+            }),
+            body: JSON.stringify(reqbody),
+            dispatcher: this.proxyAgent,
+            signal,
+        });
+        this.logger.message?.trace(res);
+        if (res.ok) { }
+        else
+            throw new Error(undefined, { cause: res });
+        const response = await res.json();
+        if (response.candidates?.[0]?.content?.parts?.length) { }
+        else
+            throw new ResponseInvalid('Content missing', { cause: response });
+        if (response.candidates[0].finishReason === Google.FinishReason.MAX_TOKENS)
+            throw new ResponseInvalid('Token limit exceeded.', { cause: response });
+        if (response.candidates[0].finishReason === Google.FinishReason.STOP) { }
+        else
+            throw new ResponseInvalid('Abnormal finish reason', { cause: response });
+        for (const part of response.candidates[0].content.parts) {
+            if (part.text)
+                this.logger.inference?.debug(part.text + '\n');
+            if (part.functionCall)
+                this.logger.message?.debug(part.functionCall);
+        }
+        if (response.usageMetadata?.promptTokenCount) { }
+        else
+            throw new Error('Prompt token count absent', { cause: response });
+        this.logger.message?.debug(response.usageMetadata);
+        const candidatesTokenCount = response.usageMetadata.candidatesTokenCount ?? 0;
+        const cacheHitTokenCount = response.usageMetadata.cachedContentTokenCount ?? 0;
+        const cacheMissTokenCount = response.usageMetadata.promptTokenCount - cacheHitTokenCount;
+        const thinkingTokenCount = response.usageMetadata.thoughtsTokenCount ?? 0;
+        const cost = this.inputPrice * cacheMissTokenCount / 1e6 +
+            this.cachePrice * cacheHitTokenCount / 1e6 +
+            this.outputPrice * candidatesTokenCount / 1e6 +
+            this.outputPrice * thinkingTokenCount / 1e6;
+        wfctx.cost?.(cost);
+        const aiMessage = this.convertToAiMessage(response.candidates[0].content);
+        this.validateToolCallsByToolChoice(aiMessage.getFunctionCalls());
+        return aiMessage;
+    }
+    GoogleNativeEngine.fetch = fetch;
+    function validateToolCallsByToolChoice(toolCalls) {
+        Function.Call.validate(toolCalls, this.toolChoice, new ResponseInvalid('Invalid function call', { cause: toolCalls }));
+    }
+    GoogleNativeEngine.validateToolCallsByToolChoice = validateToolCallsByToolChoice;
     class Instance {
-        engineBase;
-        googleEngineBase;
-        googleNativeEngineBase;
+        baseUrl;
+        apiKey;
+        model;
+        name;
+        inputPrice;
+        outputPrice;
+        cachePrice;
+        fdm;
+        additionalOptions;
+        throttle;
+        timeout;
+        maxTokens;
+        proxyAgent;
+        logger;
+        parallelToolCall;
+        apiURL;
+        codeExecution;
+        urlContext;
+        googleSearch;
+        toolChoice;
         constructor(options) {
-            this.engineBase = new Engine.Base.Instance(this, options);
-            this.googleEngineBase = new GoogleEngine.Base.Instance(this, options);
-            this.googleNativeEngineBase = new GoogleNativeEngine.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;
-        }
-        get toolChoice() {
-            return this.googleNativeEngineBase.toolChoice;
-        }
-        set toolChoice(value) {
-            this.googleNativeEngineBase.toolChoice = value;
-        }
-        stateless(ctx, session) {
-            return this.googleNativeEngineBase.stateless(ctx, session);
-        }
-        stateful(ctx, session) {
-            return this.googleNativeEngineBase.stateful(ctx, session);
+            ({
+                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 } = (GoogleEngine.OwnProps.init).call(this, options));
+            ({
+                apiURL: this.apiURL,
+                codeExecution: this.codeExecution,
+                urlContext: this.urlContext,
+                googleSearch: this.googleSearch,
+                toolChoice: this.toolChoice,
+            } = (GoogleNativeEngine.OwnProps.init).call(this, options));
+        }
+        stateless(wfctx, session) {
+            return (GoogleNativeEngine.stateless).call(this, wfctx, session);
+        }
+        stateful(wfctx, session) {
+            return (GoogleNativeEngine.stateful).call(this, wfctx, session);
         }
         appendUserMessage(session, message) {
-            return this.googleNativeEngineBase.appendUserMessage(session, message);
+            return (GoogleNativeEngine.appendUserMessage).call(this, session, message);
         }
         pushUserMessage(session, message) {
-            return this.googleNativeEngineBase.pushUserMessage(session, message);
+            return (GoogleNativeEngine.pushUserMessage).call(this, session, message);
         }
         validateToolCallsByToolChoice(toolCalls) {
-            return this.googleNativeEngineBase.validateToolCallsByToolChoice(toolCalls);
-        }
-        get parallel() {
-            return this.googleEngineBase.parallel;
-        }
-        set parallel(value) {
-            this.googleEngineBase.parallel = value;
+            return (GoogleNativeEngine.validateToolCallsByToolChoice).call(this, toolCalls);
         }
         convertFromFunctionCall(fc) {
-            return this.googleEngineBase.convertFromFunctionCall(fc);
+            return (GoogleEngine.convertFromFunctionCall).call(this, fc);
         }
         convertToFunctionCall(googlefc) {
-            return this.googleEngineBase.convertToFunctionCall(googlefc);
+            return (GoogleEngine.convertToFunctionCall).call(this, googlefc);
         }
         convertFromFunctionDeclarationEntry(fdentry) {
-            return this.googleEngineBase.convertFromFunctionDeclarationEntry(fdentry);
+            return (GoogleEngine.convertFromFunctionDeclarationEntry).call(this, fdentry);
         }
         convertFromUserMessage(userMessage) {
-            return this.googleNativeEngineBase.convertFromUserMessage(userMessage);
+            return (GoogleNativeEngine.convertFromUserMessage).call(this, userMessage);
         }
         convertFromAiMessage(aiMessage) {
-            return this.googleNativeEngineBase.convertFromAiMessage(aiMessage);
+            return (GoogleNativeEngine.convertFromAiMessage).call(this, aiMessage);
         }
         convertFromDeveloperMessage(developerMessage) {
-            return this.googleNativeEngineBase.convertFromDeveloperMessage(developerMessage);
+            return (GoogleNativeEngine.convertFromDeveloperMessage).call(this, developerMessage);
         }
         convertFromChatMessages(chatMessages) {
-            return this.googleNativeEngineBase.convertFromChatMessages(chatMessages);
+            return (GoogleNativeEngine.convertFromChatMessages).call(this, chatMessages);
         }
         convertToAiMessage(content) {
-            return this.googleNativeEngineBase.convertToAiMessage(content);
+            return (GoogleNativeEngine.convertToAiMessage).call(this, content);
         }
         convertFromToolChoice(toolChoice) {
-            return this.googleNativeEngineBase.convertFromToolChoice(toolChoice);
+            return (GoogleNativeEngine.convertFromToolChoice).call(this, toolChoice);
         }
-        fetch(ctx, session, signal) {
-            return this.googleNativeEngineBase.fetch(ctx, session, signal);
+        fetch(wfctx, session, signal) {
+            return (GoogleNativeEngine.fetch).call(this, wfctx, session, signal);
         }
     }
     GoogleNativeEngine.Instance = Instance;