@zimtsui/brainswitch 0.0.40 → 0.0.42

package/build/compatible-engines.d/google.d.ts

@@ -3,38 +3,36 @@ import { Engine } from '../engine.ts';
 import { RoleMessage, type Session, type ChatMessage } from '../session.ts';
 import { Function } from '../function.ts';
 import * as Google from '@google/genai';
+import * as Undici from 'undici';
 import { type InferenceContext } from '../inference-context.ts';
 import { GoogleEngine } from '../api-types/google.ts';
+import { Throttle } from '../throttle.ts';
+import { type Logger } from '../telemetry.ts';
 export declare namespace GoogleCompatibleEngine {
-    interface Base<in out fdm extends Function.Declaration.Map> {
+    interface Options<in out fdm extends Function.Declaration.Map> extends CompatibleEngine.Options<fdm>, GoogleEngine.Options<fdm> {
+    }
+    interface OwnProps<in out fdm extends Function.Declaration.Map> {
+        apiURL: URL;
+    }
+    namespace OwnProps {
+        function init<fdm extends Function.Declaration.Map>(this: Engine.Underhood<fdm>, options: Options<fdm>): OwnProps<fdm>;
+    }
+    interface Underhood<in out fdm extends Function.Declaration.Map> extends GoogleEngine.Underhood<fdm>, CompatibleEngine.Underhood<fdm>, OwnProps<fdm> {
         convertFromUserMessage(userMessage: RoleMessage.User<Function.Declaration.From<fdm>>): Google.Content;
         convertFromAiMessage(aiMessage: RoleMessage.Ai<Function.Declaration.From<fdm>>): Google.Content;
         convertFromDeveloperMessage(developerMessage: RoleMessage.Developer): Google.Content;
         convertFromChatMessages(chatMessages: ChatMessage<Function.Declaration.From<fdm>>[]): Google.Content[];
         convertToAiMessage(content: Google.Content): GoogleCompatibleEngine.Message.Ai<Function.Declaration.From<fdm>>;
         convertFromToolChoice(toolChoice: Function.ToolChoice<fdm>): Google.FunctionCallingConfig;
-        fetch(ctx: InferenceContext, session: Session<Function.Declaration.From<fdm>>, signal?: AbortSignal): Promise<RoleMessage.Ai<Function.Declaration.From<fdm>>>;
-    }
-    interface Instance<in out fdm extends Function.Declaration.Map> extends GoogleEngine.Instance<fdm>, CompatibleEngine.Instance<fdm>, GoogleCompatibleEngine.Base<fdm> {
-    }
-    namespace Base {
-        class Instance<in out fdm extends Function.Declaration.Map> implements GoogleCompatibleEngine.Base<fdm> {
-            protected instance: GoogleCompatibleEngine.Instance<fdm>;
-            protected apiURL: URL;
-            constructor(instance: GoogleCompatibleEngine.Instance<fdm>);
-            convertFromUserMessage(userMessage: RoleMessage.User<Function.Declaration.From<fdm>>): Google.Content;
-            convertFromAiMessage(aiMessage: RoleMessage.Ai<Function.Declaration.From<fdm>>): Google.Content;
-            convertFromDeveloperMessage(developerMessage: RoleMessage.Developer): Google.Content;
-            convertFromChatMessages(chatMessages: ChatMessage<Function.Declaration.From<fdm>>[]): Google.Content[];
-            convertToAiMessage(content: Google.Content): GoogleCompatibleEngine.Message.Ai<Function.Declaration.From<fdm>>;
-            convertFromToolChoice(toolChoice: Function.ToolChoice<fdm>): Google.FunctionCallingConfig;
-            fetch(ctx: InferenceContext, session: Session<Function.Declaration.From<fdm>>, signal?: AbortSignal): Promise<RoleMessage.Ai<Function.Declaration.From<fdm>>>;
-        }
+        fetch(wfctx: InferenceContext, session: Session<Function.Declaration.From<fdm>>, signal?: AbortSignal): Promise<RoleMessage.Ai<Function.Declaration.From<fdm>>>;
     }
+    function convertFromAiMessage<fdm extends Function.Declaration.Map>(this: GoogleCompatibleEngine.Underhood<fdm>, aiMessage: RoleMessage.Ai<Function.Declaration.From<fdm>>): Google.Content;
+    function convertFromChatMessages<fdm extends Function.Declaration.Map>(this: GoogleCompatibleEngine.Underhood<fdm>, chatMessages: ChatMessage<Function.Declaration.From<fdm>>[]): Google.Content[];
+    function fetch<fdm extends Function.Declaration.Map>(this: GoogleCompatibleEngine.Underhood<fdm>, wfctx: InferenceContext, session: Session<Function.Declaration.From<fdm>>, signal?: AbortSignal): Promise<RoleMessage.Ai<Function.Declaration.From<fdm>>>;
     function convertFromUserMessage<fdm extends Function.Declaration.Map>(userMessage: RoleMessage.User<Function.Declaration.From<fdm>>): Google.Content;
     function convertFromDeveloperMessage(developerMessage: RoleMessage.Developer): Google.Content;
     function convertFromToolChoice<fdm extends Function.Declaration.Map>(toolChoice: Function.ToolChoice<fdm>): Google.FunctionCallingConfig;
-    function convertToAiMessage<fdm extends Function.Declaration.Map>(content: Google.Content, fdm: fdm): GoogleCompatibleEngine.Message.Ai<Function.Declaration.From<fdm>>;
+    function convertToAiMessage<fdm extends Function.Declaration.Map>(this: GoogleCompatibleEngine.Underhood<fdm>, content: Google.Content): GoogleCompatibleEngine.Message.Ai<Function.Declaration.From<fdm>>;
     namespace Message {
         type Ai<fdu extends Function.Declaration> = Ai.Instance<fdu>;
         namespace Ai {
@@ -48,47 +46,30 @@ export declare namespace GoogleCompatibleEngine {
             }
         }
     }
-    class Instance<in out fdm extends Function.Declaration.Map> implements GoogleCompatibleEngine.Instance<fdm> {
-        protected engineBase: Engine.Base<fdm>;
-        protected compatibleEngineBase: CompatibleEngine.Base<fdm>;
-        protected googleEngineBase: GoogleEngine.Base<fdm>;
-        protected googleCompatibleEngineBase: GoogleCompatibleEngine.Base<fdm>;
+    class Instance<in out fdm extends Function.Declaration.Map> implements GoogleCompatibleEngine.Underhood<fdm> {
+        baseUrl: string;
+        apiKey: string;
+        model: string;
+        name: string;
+        inputPrice: number;
+        outputPrice: number;
+        cachePrice: number;
+        fdm: fdm;
+        additionalOptions?: Record<string, unknown>;
+        throttle: Throttle;
+        timeout?: number;
+        maxTokens?: number;
+        proxyAgent?: Undici.ProxyAgent;
+        logger: Logger;
+        toolChoice: Function.ToolChoice<fdm>;
+        parallelToolCall: boolean;
+        apiURL: URL;
         constructor(options: GoogleCompatibleEngine.Options<fdm>);
-        get baseUrl(): string;
-        set baseUrl(value: string);
-        get apiKey(): string;
-        set apiKey(value: string);
-        get model(): string;
-        set model(value: string);
-        get name(): string;
-        set name(value: string);
-        get inputPrice(): number;
-        set inputPrice(value: number);
-        get outputPrice(): number;
-        set outputPrice(value: number);
-        get cachedPrice(): number;
-        set cachedPrice(value: number);
-        get fdm(): fdm;
-        set fdm(value: fdm);
-        get additionalOptions(): Record<string, unknown> | undefined;
-        set additionalOptions(value: Record<string, unknown> | undefined);
-        get throttle(): import("../throttle.ts").Throttle;
-        set throttle(value: import("../throttle.ts").Throttle);
-        get timeout(): number | undefined;
-        set timeout(value: number | undefined);
-        get maxTokens(): number | undefined;
-        set maxTokens(value: number | undefined);
-        get proxyAgent(): import("undici").ProxyAgent | undefined;
-        set proxyAgent(value: import("undici").ProxyAgent | undefined);
-        get toolChoice(): Function.ToolChoice<fdm>;
-        set toolChoice(value: Function.ToolChoice<fdm>);
-        stateless(ctx: InferenceContext, session: Session<Function.Declaration.From<fdm>>): Promise<RoleMessage.Ai<Function.Declaration.From<fdm, Extract<keyof fdm, string>>>>;
-        stateful(ctx: InferenceContext, session: Session<Function.Declaration.From<fdm>>): Promise<RoleMessage.Ai<Function.Declaration.From<fdm, Extract<keyof fdm, string>>>>;
+        stateless(wfctx: InferenceContext, session: Session<Function.Declaration.From<fdm>>): Promise<RoleMessage.Ai<Function.Declaration.From<fdm, Extract<keyof fdm, string>>>>;
+        stateful(wfctx: InferenceContext, session: Session<Function.Declaration.From<fdm>>): Promise<RoleMessage.Ai<Function.Declaration.From<fdm, Extract<keyof fdm, string>>>>;
         appendUserMessage(session: Session<Function.Declaration.From<fdm>>, message: RoleMessage.User<Function.Declaration.From<fdm>>): Session<Function.Declaration.From<fdm, Extract<keyof fdm, string>>>;
         pushUserMessage(session: Session<Function.Declaration.From<fdm>>, message: RoleMessage.User<Function.Declaration.From<fdm>>): Session<Function.Declaration.From<fdm, Extract<keyof fdm, string>>>;
         validateToolCallsByToolChoice(toolCalls: Function.Call.Distributive<Function.Declaration.From<fdm>>[]): void;
-        get parallel(): boolean;
-        set parallel(value: boolean);
         convertFromFunctionCall(fc: Function.Call.Distributive<Function.Declaration.From<fdm>>): Google.FunctionCall;
         convertToFunctionCall(googlefc: Google.FunctionCall): Function.Call.Distributive<Function.Declaration.From<fdm>>;
         convertFromFunctionDeclarationEntry(fdentry: Function.Declaration.Entry.From<fdm>): Google.FunctionDeclaration;
@@ -98,9 +79,7 @@ export declare namespace GoogleCompatibleEngine {
         convertFromChatMessages(chatMessages: ChatMessage<Function.Declaration.From<fdm>>[]): Google.Content[];
         convertToAiMessage(content: Google.Content): GoogleCompatibleEngine.Message.Ai<Function.Declaration.From<fdm>>;
         convertFromToolChoice(toolChoice: Function.ToolChoice<fdm>): Google.FunctionCallingConfig;
-        fetch(ctx: InferenceContext, session: Session<Function.Declaration.From<fdm>>, signal?: AbortSignal): Promise<RoleMessage.Ai<Function.Declaration.From<fdm>>>;
-    }
-    interface Options<in out fdm extends Function.Declaration.Map> extends CompatibleEngine.Options<fdm> {
+        fetch(wfctx: InferenceContext, session: Session<Function.Declaration.From<fdm>>, signal?: AbortSignal): Promise<RoleMessage.Ai<Function.Declaration.From<fdm>>>;
     }
     function create<fdm extends Function.Declaration.Map>(options: CompatibleEngine.Options<fdm>): CompatibleEngine<fdm>;
 }

package/build/compatible-engines.d/google.js

@@ -1,124 +1,123 @@
 import { CompatibleEngine } from "../compatible-engine.js";
-import { ResponseInvalid, Engine } from "../engine.js";
+import { Engine, ResponseInvalid } from "../engine.js";
 import { RoleMessage } from "../session.js";
 import { Function } from "../function.js";
 import * as Google from '@google/genai';
-import assert from 'node:assert';
-import { fetch } from 'undici';
+import * as Undici from 'undici';
 import {} from "../inference-context.js";
 import { GoogleEngine } from "../api-types/google.js";
+import { Throttle } from "../throttle.js";
+import {} from "../telemetry.js";
 export var GoogleCompatibleEngine;
 (function (GoogleCompatibleEngine) {
-    let Base;
-    (function (Base) {
-        class Instance {
-            instance;
-            apiURL;
-            constructor(instance) {
-                this.instance = instance;
-                this.apiURL = new URL(`${this.instance.baseUrl}/v1beta/models/${this.instance.model}:generateContent`);
-            }
-            convertFromUserMessage(userMessage) {
-                return GoogleCompatibleEngine.convertFromUserMessage(userMessage);
-            }
-            convertFromAiMessage(aiMessage) {
-                if (aiMessage instanceof GoogleCompatibleEngine.Message.Ai.Instance)
-                    return aiMessage.getRaw();
-                else {
-                    const parts = aiMessage.getParts().map(part => {
-                        if (part instanceof RoleMessage.Part.Text.Instance)
-                            return Google.createPartFromText(part.text);
-                        else if (part instanceof Function.Call) {
-                            assert(part.args instanceof Object);
-                            return Google.createPartFromFunctionCall(part.name, part.args);
-                        }
-                        else
-                            throw new Error();
-                    });
-                    return Google.createModelContent(parts);
-                }
-            }
-            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);
+    let OwnProps;
+    (function (OwnProps) {
+        function init(options) {
+            return {
+                apiURL: new URL(`${this.baseUrl}/v1beta/models/${this.model}:generateContent`),
+            };
+        }
+        OwnProps.init = init;
+    })(OwnProps = GoogleCompatibleEngine.OwnProps || (GoogleCompatibleEngine.OwnProps = {}));
+    function convertFromAiMessage(aiMessage) {
+        if (aiMessage instanceof GoogleCompatibleEngine.Message.Ai.Instance)
+            return aiMessage.getRaw();
+        else {
+            const parts = aiMessage.getParts().map(part => {
+                if (part instanceof RoleMessage.Part.Text.Instance)
+                    return Google.createPartFromText(part.text);
+                else if (part instanceof Function.Call) {
+                    if (part.args instanceof Object) { }
                     else
                         throw new Error();
-                });
-            }
-            convertToAiMessage(content) {
-                return GoogleCompatibleEngine.convertToAiMessage(content, this.instance.fdm);
-            }
-            convertFromToolChoice(toolChoice) {
-                return GoogleCompatibleEngine.convertFromToolChoice(toolChoice);
-            }
-            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 tools = fdentries.map(fdentry => this.instance.convertFromFunctionDeclarationEntry(fdentry));
-                const reqbody = {
-                    contents,
-                    tools: tools.length ? [{
-                            functionDeclarations: tools,
-                        }] : undefined,
-                    toolConfig: tools.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);
+                    return Google.createPartFromFunctionCall(part.name, part.args);
                 }
-                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;
-            }
+                else
+                    throw new Error();
+            });
+            return Google.createModelContent(parts);
         }
-        Base.Instance = Instance;
-    })(Base = GoogleCompatibleEngine.Base || (GoogleCompatibleEngine.Base = {}));
+    }
+    GoogleCompatibleEngine.convertFromAiMessage = convertFromAiMessage;
+    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();
+        });
+    }
+    GoogleCompatibleEngine.convertFromChatMessages = convertFromChatMessages;
+    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 tools = fdentries.map(fdentry => this.convertFromFunctionDeclarationEntry(fdentry));
+        const reqbody = {
+            contents,
+            tools: tools.length ? [{
+                    functionDeclarations: tools,
+                }] : undefined,
+            toolConfig: tools.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;
+    }
+    GoogleCompatibleEngine.fetch = fetch;
     function convertFromUserMessage(userMessage) {
         const parts = userMessage.getParts().map(part => {
             if (part instanceof RoleMessage.Part.Text.Instance)
@@ -149,15 +148,19 @@ export var GoogleCompatibleEngine;
             return { mode: Google.FunctionCallingConfigMode.ANY, allowedFunctionNames: [...toolChoice] };
     }
     GoogleCompatibleEngine.convertFromToolChoice = convertFromToolChoice;
-    function convertToAiMessage(content, fdm) {
-        assert(content.parts);
+    function convertToAiMessage(content) {
+        if (content.parts) { }
+        else
+            throw new Error();
         return GoogleCompatibleEngine.Message.Ai.create(content.parts.flatMap(part => {
             const parts = [];
-            assert(part.functionCall || part.text, new ResponseInvalid('Unknown content part', { cause: content }));
+            if (part.functionCall || part.text) { }
+            else
+                throw new ResponseInvalid('Unknown content part', { cause: content });
             if (part.text)
                 parts.push(RoleMessage.Part.Text.create(part.text));
             if (part.functionCall)
-                parts.push(GoogleEngine.convertToFunctionCall(part.functionCall, fdm));
+                parts.push(this.convertToFunctionCall(part.functionCall));
             return parts;
         }), content);
     }
@@ -185,150 +188,88 @@ export var GoogleCompatibleEngine;
         })(Ai = Message.Ai || (Message.Ai = {}));
     })(Message = GoogleCompatibleEngine.Message || (GoogleCompatibleEngine.Message = {}));
     class Instance {
-        engineBase;
-        compatibleEngineBase;
-        googleEngineBase;
-        googleCompatibleEngineBase;
+        baseUrl;
+        apiKey;
+        model;
+        name;
+        inputPrice;
+        outputPrice;
+        cachePrice;
+        fdm;
+        additionalOptions;
+        throttle;
+        timeout;
+        maxTokens;
+        proxyAgent;
+        logger;
+        toolChoice;
+        parallelToolCall;
+        apiURL;
         constructor(options) {
-            this.engineBase = new Engine.Base.Instance(this, options);
-            this.compatibleEngineBase = new CompatibleEngine.Base.Instance(this, options);
-            this.googleEngineBase = new GoogleEngine.Base.Instance(this, options);
-            this.googleCompatibleEngineBase = new GoogleCompatibleEngine.Base.Instance(this);
-        }
-        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.compatibleEngineBase.toolChoice;
-        }
-        set toolChoice(value) {
-            this.compatibleEngineBase.toolChoice = value;
-        }
-        stateless(ctx, session) {
-            return this.compatibleEngineBase.stateless(ctx, session);
-        }
-        stateful(ctx, session) {
-            return this.compatibleEngineBase.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));
+            ({ toolChoice: this.toolChoice } = (CompatibleEngine.OwnProps.init).call(this, options));
+            ({ parallelToolCall: this.parallelToolCall } = (GoogleEngine.OwnProps.init).call(this, options));
+            ({ apiURL: this.apiURL } = (GoogleCompatibleEngine.OwnProps.init).call(this, options));
+        }
+        stateless(wfctx, session) {
+            return (CompatibleEngine.stateless).call(this, wfctx, session);
+        }
+        stateful(wfctx, session) {
+            return (CompatibleEngine.stateful).call(this, wfctx, session);
         }
         appendUserMessage(session, message) {
-            return this.compatibleEngineBase.appendUserMessage(session, message);
+            return (CompatibleEngine.appendUserMessage).call(this, session, message);
         }
         pushUserMessage(session, message) {
-            return this.compatibleEngineBase.pushUserMessage(session, message);
+            return (CompatibleEngine.pushUserMessage).call(this, session, message);
         }
         validateToolCallsByToolChoice(toolCalls) {
-            return this.compatibleEngineBase.validateToolCallsByToolChoice(toolCalls);
-        }
-        get parallel() {
-            return this.googleEngineBase.parallel;
-        }
-        set parallel(value) {
-            this.googleEngineBase.parallel = value;
+            return (CompatibleEngine.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.googleCompatibleEngineBase.convertFromUserMessage(userMessage);
+            return (GoogleCompatibleEngine.convertFromUserMessage).call(this, userMessage);
         }
         convertFromAiMessage(aiMessage) {
-            return this.googleCompatibleEngineBase.convertFromAiMessage(aiMessage);
+            return (GoogleCompatibleEngine.convertFromAiMessage).call(this, aiMessage);
         }
         convertFromDeveloperMessage(developerMessage) {
-            return this.googleCompatibleEngineBase.convertFromDeveloperMessage(developerMessage);
+            return (GoogleCompatibleEngine.convertFromDeveloperMessage).call(this, developerMessage);
         }
         convertFromChatMessages(chatMessages) {
-            return this.googleCompatibleEngineBase.convertFromChatMessages(chatMessages);
+            return (GoogleCompatibleEngine.convertFromChatMessages).call(this, chatMessages);
         }
         convertToAiMessage(content) {
-            return this.googleCompatibleEngineBase.convertToAiMessage(content);
+            return (GoogleCompatibleEngine.convertToAiMessage).call(this, content);
         }
         convertFromToolChoice(toolChoice) {
-            return this.googleCompatibleEngineBase.convertFromToolChoice(toolChoice);
+            return (GoogleCompatibleEngine.convertFromToolChoice).call(this, toolChoice);
         }
-        fetch(ctx, session, signal) {
-            return this.googleCompatibleEngineBase.fetch(ctx, session, signal);
+        fetch(wfctx, session, signal) {
+            return (GoogleCompatibleEngine.fetch).call(this, wfctx, session, signal);
         }
     }
     GoogleCompatibleEngine.Instance = Instance;