@zimtsui/brainswitch 0.0.56 → 0.0.59

package/test/src/test-codecs.ts

@@ -1,256 +0,0 @@
-import test from 'ava';
-import { Function } from '#@/function.ts';
-import { ResponseInvalid } from '#@/engine.ts';
-import { ToolCallValidator } from '#@/compatible/tool-call-validator.ts';
-import { GoogleToolCodec } from '#@/api-types/google/tool-codec.ts';
-import { GoogleCompatibleMessageCodec } from '#@/compatible.d/google/message-codec.ts';
-import { GoogleNativeMessageCodec } from '#@/native-engines.d/google/message-codec.ts';
-import { OpenAIResponsesToolCodec } from '#@/api-types/openai-responses/tool-codec.ts';
-import { OpenAIResponsesCompatibleMessageCodec } from '#@/compatible.d/openai-responses/message-codec.ts';
-import { OpenAIResponsesNativeMessageCodec } from '#@/native-engines.d/openai-responses/message-codec.ts';
-import { OpenAIResponsesNativeToolCallValidator } from '#@/native-engines.d/openai-responses/tool-call-validator.ts';
-import { Tool } from '#@/native-engines.d/openai-responses/tool.ts';
-import { GoogleBilling } from '#@/api-types/google/billing.ts';
-import { OpenAIResponsesBilling } from '#@/api-types/openai-responses/billing.ts';
-import { AnthropicBilling } from '#@/api-types/anthropic/billing.ts';
-import { RoleMessage } from '#@/compatible/session.ts';
-import * as Google from '@google/genai';
-import * as OpenAIResponsesNative from '#@/native-engines.d/openai-responses/session.ts';
-import { fdm } from './test-helpers.ts';
-
-
-function makeFooCall() {
-    return Function.Call.create<fdm>({
-        id: 'fc-1',
-        name: 'foo',
-        args: { x: 1 },
-    });
-}
-
-function makeBarCall() {
-    return Function.Call.create<fdm>({
-        id: 'fc-2',
-        name: 'bar',
-        args: { y: 'x' },
-    });
-}
-
-
-test('ToolCallValidator enforces REQUIRED / allowlist / NONE', t => {
-    const validator = new ToolCallValidator<fdm>({ toolChoice: Function.ToolChoice.REQUIRED });
-    const fooCall = makeFooCall();
-    const barCall = makeBarCall();
-
-    t.throws(() => validator.validate([]), { instanceOf: ResponseInvalid });
-    t.notThrows(() => validator.validate([fooCall]));
-
-    validator['ctx'].toolChoice = ['foo'];
-    t.notThrows(() => validator.validate([fooCall]));
-    t.throws(() => validator.validate([barCall]), { instanceOf: ResponseInvalid });
-
-    validator['ctx'].toolChoice = Function.ToolChoice.NONE;
-    t.notThrows(() => validator.validate([]));
-    t.throws(() => validator.validate([fooCall]), { instanceOf: ResponseInvalid });
-});
-
-test('OpenAIResponsesNativeToolCallValidator enforces apply_patch allowlist', t => {
-    const fooCall = makeFooCall();
-    const applyPatchCall = Tool.ApplyPatch.Call.create({
-        id: 'patch-1',
-        call_id: 'call-1',
-        operation: {
-            type: 'update_file',
-            path: 'a.ts',
-            diff: 'diff',
-        },
-        status: 'completed',
-        type: 'apply_patch_call',
-    });
-
-    const validator = new OpenAIResponsesNativeToolCallValidator<fdm>({
-        toolChoice: ['foo', Tool.Choice.APPLY_PATCH],
-    });
-    t.notThrows(() => validator.validate([fooCall, applyPatchCall]));
-
-    const validatorWithoutPatch = new OpenAIResponsesNativeToolCallValidator<fdm>({
-        toolChoice: ['foo'],
-    });
-    t.throws(() => validatorWithoutPatch.validate([applyPatchCall]), { instanceOf: ResponseInvalid });
-});
-
-test('GoogleCompatibleMessageCodec converts user and ai messages', t => {
-    const toolCodec = new GoogleToolCodec({ fdm });
-    const codec = new GoogleCompatibleMessageCodec({ toolCodec });
-
-    const userMessage = RoleMessage.User.create<fdm>([
-        RoleMessage.Part.Text.create('hello'),
-        Function.Response.create<fdm>({
-            id: 'fc-1',
-            name: 'foo',
-            text: '{"ok":true}',
-        }),
-    ]);
-    const userContent = codec.convertFromUserMessage(userMessage);
-    t.is(userContent.role, 'user');
-    t.is(userContent.parts?.[0]?.text, 'hello');
-    t.truthy(userContent.parts?.[1]?.functionResponse);
-
-    const aiContent = {
-        role: 'model',
-        parts: [
-            { text: 'hi' },
-            { functionCall: { id: 'fc-1', name: 'foo', args: { x: 1 } } },
-        ],
-    };
-    const aiMessage = codec.convertToAiMessage(aiContent);
-    t.is(aiMessage.getText(), 'hi');
-    t.is(aiMessage.getFunctionCalls()[0]?.name, 'foo');
-});
-
-test('GoogleNativeMessageCodec reuses compatible message codec and decodes code execution parts', t => {
-    const toolCodec = new GoogleToolCodec({ fdm });
-    const compatibleMessageCodec = new GoogleCompatibleMessageCodec({ toolCodec });
-    const codec = new GoogleNativeMessageCodec({
-        toolCodec,
-        compatibleMessageCodec,
-        codeExecution: true,
-    });
-
-    const userContent = codec.convertFromUserMessage(RoleMessage.User.create<fdm>([
-        RoleMessage.Part.Text.create('hello'),
-    ]));
-    t.is(userContent.role, 'user');
-
-    const aiMessage = codec.convertToAiMessage({
-        role: 'model',
-        parts: [
-            { text: 'hi' },
-            { functionCall: { id: 'fc-1', name: 'foo', args: { x: 1 } } },
-            { executableCode: { code: 'print(1)', language: Google.Language.PYTHON } },
-            { codeExecutionResult: { outcome: Google.Outcome.OUTCOME_OK, output: '1' } },
-        ],
-    });
-    t.is(aiMessage.getText(), 'hi');
-    t.is(aiMessage.getFunctionCalls()[0]?.name, 'foo');
-    t.is(aiMessage.getParts().length, 4);
-});
-
-test('OpenAIResponsesCompatibleMessageCodec converts user and ai messages', t => {
-    const toolCodec = new OpenAIResponsesToolCodec({ fdm });
-    const codec = new OpenAIResponsesCompatibleMessageCodec({ toolCodec });
-
-    const userMessage = RoleMessage.User.create<fdm>([
-        RoleMessage.Part.Text.create('hello'),
-        Function.Response.create<fdm>({
-            id: 'fc-1',
-            name: 'foo',
-            text: '{"ok":true}',
-        }),
-    ]);
-    const input = codec.convertFromUserMessage(userMessage);
-    t.is(input[0]?.type, 'message');
-    t.is(input[1]?.type, 'function_call_output');
-
-    const aiMessage = codec.convertToAiMessage([
-        {
-            id: 'msg_1',
-            type: 'message',
-            role: 'assistant',
-            status: 'completed',
-            content: [{ type: 'output_text', text: 'hi', annotations: [] }],
-        },
-        {
-            id: 'fc_1',
-            type: 'function_call',
-            call_id: 'call_1',
-            name: 'foo',
-            arguments: '{"x":1}',
-            status: 'completed',
-        },
-    ]);
-    t.is(aiMessage.getText(), 'hi');
-    t.is(aiMessage.getFunctionCalls()[0]?.name, 'foo');
-});
-
-test('OpenAIResponsesNativeMessageCodec converts apply_patch response', t => {
-    const toolCodec = new OpenAIResponsesToolCodec({ fdm });
-    const compatibleMessageCodec = new OpenAIResponsesCompatibleMessageCodec({ toolCodec });
-    const codec = new OpenAIResponsesNativeMessageCodec({
-        toolCodec,
-        compatibleMessageCodec,
-    });
-
-    const input = codec.convertFromUserMessage(OpenAIResponsesNative.RoleMessage.User.create<
-        fdm
-    >([
-        OpenAIResponsesNative.RoleMessage.Part.Text.create('hello'),
-        Function.Response.create<fdm>({
-            id: 'fc-1',
-            name: 'foo',
-            text: '{"ok":true}',
-        }),
-        Tool.ApplyPatch.Response.create({
-            id: 'patch-1',
-            failure: 'failure',
-        }),
-    ]));
-    t.is(input[0]?.type, 'message');
-    t.is(input[1]?.type, 'function_call_output');
-    t.is(input[2]?.type, 'apply_patch_call_output');
-});
-
-test('GoogleBilling calculates cache hit / miss / thinking cost', t => {
-    const billing = new GoogleBilling({
-        pricing: {
-            inputPrice: 1,
-            cachePrice: 2,
-            outputPrice: 3,
-        },
-    });
-    const charge = billing.charge({
-        promptTokenCount: 100,
-        cachedContentTokenCount: 25,
-        candidatesTokenCount: 10,
-        thoughtsTokenCount: 5,
-    });
-    t.is(charge, (75 + 50 + 30 + 15) / 1e6);
-});
-
-test('OpenAIResponsesBilling calculates cache hit / miss cost', t => {
-    const billing = new OpenAIResponsesBilling({
-        pricing: {
-            inputPrice: 1,
-            cachePrice: 2,
-            outputPrice: 3,
-        },
-    });
-    const charge = billing.charge({
-        input_tokens: 100,
-        input_tokens_details: { cached_tokens: 20 },
-        output_tokens: 10,
-        output_tokens_details: { reasoning_tokens: 0 },
-        total_tokens: 110,
-    });
-    t.true(Math.abs(charge - (80 + 40 + 30) / 1e6) < 1e-12);
-});
-
-test('AnthropicBilling calculates cache hit / miss cost', t => {
-    const billing = new AnthropicBilling({
-        pricing: {
-            inputPrice: 1,
-            cachePrice: 2,
-            outputPrice: 3,
-        },
-    });
-    const charge = billing.charge({
-        input_tokens: 100,
-        output_tokens: 10,
-        cache_read_input_tokens: 20,
-        cache_creation_input_tokens: 0,
-        cache_creation: { ephemeral_5m_input_tokens: 0, ephemeral_1h_input_tokens: 0 },
-        inference_geo: 'unknown',
-        server_tool_use: { web_fetch_requests: 0, web_search_requests: 0 },
-        service_tier: 'standard',
-    });
-    t.true(Math.abs(charge - (80 + 40 + 30) / 1e6) < 1e-12);
-});

package/test/src/test-compatible-engine.ts

@@ -1,45 +0,0 @@
-import test from 'ava';
-import { CompatibleEngine } from '#@/compatible/engine.ts';
-import { RoleMessage, type Session } from '#@/compatible/session.ts';
-import { Function } from '#@/function.ts';
-import { type InferenceContext } from '#@/inference-context.ts';
-import {
-    fdm,
-    makeAiMessage,
-    makeBaseOptions,
-} from './test-helpers.ts';
-
-
-class StubCompatibleEngine extends CompatibleEngine<fdm> {
-    protected override parallelToolCall = false;
-    public responder: (
-        wfctx: InferenceContext,
-        session: Session<fdm>,
-        signal?: AbortSignal,
-    ) => Promise<RoleMessage.Ai<fdm>> = async () => makeAiMessage();
-
-    public getToolChoice(): Function.ToolChoice<fdm> {
-        return this.toolChoice;
-    }
-
-    public setToolChoice(toolChoice: Function.ToolChoice<fdm>): void {
-        this.toolChoice = toolChoice;
-    }
-
-    public override infer(
-        wfctx: InferenceContext,
-        session: Session<fdm>,
-        signal?: AbortSignal,
-    ): Promise<RoleMessage.Ai<fdm>> {
-        return this.responder(wfctx, session, signal);
-    }
-}
-
-
-test('CompatibleEngine stores default tool choice', t => {
-    const engine = new StubCompatibleEngine({
-        ...makeBaseOptions(),
-        apiType: 'google',
-    });
-    t.is(engine.getToolChoice(), Function.ToolChoice.AUTO);
-});

package/test/src/test-compatible-engines.ts

@@ -1,129 +0,0 @@
-import test from 'ava';
-import { Adaptor } from '#@/adaptor.ts';
-import { Function } from '#@/function.ts';
-import { OpenAIResponsesCompatibleEngine } from '#@/compatible/engine.d/openai-responses.ts';
-import { GoogleCompatibleEngine } from '#@/compatible/engine.d/google.ts';
-import { AnthropicCompatibleEngine } from '#@/compatible/engine.d/anthropic.ts';
-import { AliyunEngine } from '#@/compatible/engine.d/aliyun.ts';
-import { fdm, makeBaseOptions } from './test-helpers.ts';
-
-
-class OpenAIResponsesCompatibleEngineProbe extends OpenAIResponsesCompatibleEngine<fdm> {
-    public getToolChoice(): Function.ToolChoice<fdm> {
-        return this.toolChoice;
-    }
-
-    public getParallelToolCall(): boolean {
-        return this.parallelToolCall;
-    }
-}
-
-class GoogleCompatibleEngineProbe extends GoogleCompatibleEngine<fdm> {
-    public getToolChoice(): Function.ToolChoice<fdm> {
-        return this.toolChoice;
-    }
-
-    public getParallelToolCall(): boolean {
-        return this.parallelToolCall;
-    }
-}
-
-class AnthropicCompatibleEngineProbe extends AnthropicCompatibleEngine<fdm> {
-    public getToolChoice(): Function.ToolChoice<fdm> {
-        return this.toolChoice;
-    }
-
-    public getParallelToolCall(): boolean {
-        return this.parallelToolCall;
-    }
-}
-
-class AliyunEngineProbe extends AliyunEngine<fdm> {
-    public getToolChoice(): Function.ToolChoice<fdm> {
-        return this.toolChoice;
-    }
-
-    public getParallelToolCall(): boolean {
-        return this.parallelToolCall;
-    }
-}
-
-
-test('compatible engines preserve aggregated defaults', t => {
-    const openaiEngine = new OpenAIResponsesCompatibleEngineProbe({
-        ...makeBaseOptions(),
-        apiType: 'openai-responses',
-    });
-    const googleEngine = new GoogleCompatibleEngineProbe({
-        ...makeBaseOptions(),
-        apiType: 'google',
-    });
-    const anthropicEngine = new AnthropicCompatibleEngineProbe({
-        ...makeBaseOptions(),
-        apiType: 'anthropic',
-    });
-    const aliyunEngine = new AliyunEngineProbe({
-        ...makeBaseOptions(),
-        apiType: 'aliyun',
-    });
-
-    t.is(openaiEngine.fdm, fdm);
-    t.is(openaiEngine.getToolChoice(), Function.ToolChoice.AUTO);
-    t.false(openaiEngine.getParallelToolCall());
-
-    t.is(googleEngine.getToolChoice(), Function.ToolChoice.AUTO);
-    t.true(googleEngine.getParallelToolCall());
-
-    t.is(anthropicEngine.getToolChoice(), Function.ToolChoice.AUTO);
-    t.false(anthropicEngine.getParallelToolCall());
-
-    t.is(aliyunEngine.getToolChoice(), Function.ToolChoice.AUTO);
-    t.false(aliyunEngine.getParallelToolCall());
-});
-
-test('Adaptor.makeEngine returns each compatible implementation', t => {
-    const adaptor = Adaptor.create({
-        brainswitch: {
-            endpoints: {
-                oa: {
-                    baseUrl: 'https://example.com/v1',
-                    apiKey: 'k',
-                    model: 'm',
-                    name: 'oa',
-                    apiType: 'openai-responses',
-                },
-                gg: {
-                    baseUrl: 'https://generativelanguage.googleapis.com',
-                    apiKey: 'k',
-                    model: 'gemini-test',
-                    name: 'gg',
-                    apiType: 'google',
-                },
-                an: {
-                    baseUrl: 'https://api.anthropic.com',
-                    apiKey: 'k',
-                    model: 'claude-test',
-                    name: 'an',
-                    apiType: 'anthropic',
-                },
-                al: {
-                    baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
-                    apiKey: 'k',
-                    model: 'qwen-test',
-                    name: 'al',
-                    apiType: 'aliyun',
-                },
-            },
-        },
-    });
-
-    const openaiEngine = adaptor.makeEngine('oa', fdm);
-    const googleEngine = adaptor.makeEngine('gg', fdm);
-    const anthropicEngine = adaptor.makeEngine('an', fdm);
-    const aliyunEngine = adaptor.makeEngine('al', fdm);
-
-    t.true(openaiEngine instanceof OpenAIResponsesCompatibleEngine);
-    t.true(googleEngine instanceof GoogleCompatibleEngine);
-    t.true(anthropicEngine instanceof AnthropicCompatibleEngine);
-    t.true(aliyunEngine instanceof AliyunEngine);
-});

package/test/src/test-engine.ts

@@ -1,144 +0,0 @@
-import test from 'ava';
-import { Engine, InferenceTimeout, ResponseInvalid, UserAbortion } from '#@/engine.ts';
-import { type GenericSession } from '#@/session.ts';
-import { type InferenceContext } from '#@/inference-context.ts';
-import { type RoleMessage } from '#@/compatible/session.ts';
-import {
-    fdm,
-    makeBaseOptions,
-    makeInferenceContext,
-    makeUserMessage,
-} from './test-helpers.ts';
-
-type StubSession = GenericSession<RoleMessage.User<fdm>, string, never>;
-
-class StubEngine extends Engine<
-    fdm,
-    RoleMessage.User<fdm>,
-    string,
-    never,
-    StubSession
-> {
-    protected override parallelToolCall = false;
-    public responder: (
-        wfctx: InferenceContext,
-        session: StubSession,
-        signal?: AbortSignal,
-    ) => Promise<string> = async () => 'ok';
-
-    protected override infer(
-        wfctx: InferenceContext,
-        session: StubSession,
-        signal?: AbortSignal,
-    ): Promise<string> {
-        return this.responder(wfctx, session, signal);
-    }
-
-    public override appendUserMessage(
-        session: StubSession,
-        message: RoleMessage.User<fdm>,
-    ): StubSession {
-        return {
-            ...session,
-            chatMessages: [...session.chatMessages, message],
-        };
-    }
-
-    public override pushUserMessage(
-        session: StubSession,
-        message: RoleMessage.User<fdm>,
-    ): StubSession {
-        session.chatMessages.push(message);
-        return session;
-    }
-}
-
-function makeStringSession(): StubSession {
-    return { chatMessages: [] };
-}
-
-
-test('Engine stores function declaration map', t => {
-    const engine = new StubEngine({
-        ...makeBaseOptions(),
-        apiType: 'google',
-    });
-    t.is(engine.fdm, fdm);
-});
-
-test('Engine.stateless retries ResponseInvalid and succeeds', async t => {
-    const engine = new StubEngine({
-        ...makeBaseOptions(),
-        apiType: 'google',
-    });
-
-    let attempts = 0;
-    engine.responder = async () => {
-        attempts += 1;
-        if (attempts < 3) throw new ResponseInvalid('temporary');
-        return 'retry-ok';
-    };
-
-    const response = await engine.stateless(makeInferenceContext(), makeStringSession());
-
-    t.is(attempts, 3);
-    t.is(response, 'retry-ok');
-});
-
-test('Engine.stateless converts aborted workflow signal to UserAbortion', async t => {
-    const engine = new StubEngine({
-        ...makeBaseOptions(),
-        apiType: 'google',
-    });
-    const controller = new AbortController();
-
-    engine.responder = async () => {
-        controller.abort();
-        throw new TypeError('aborted');
-    };
-
-    const e = await engine.stateless(makeInferenceContext(controller.signal), makeStringSession()).catch((e: unknown) => e);
-    t.true(e instanceof UserAbortion);
-});
-
-test('Engine.stateless converts timeout abort to InferenceTimeout', async t => {
-    const engine = new StubEngine({
-        ...makeBaseOptions(),
-        apiType: 'google',
-        timeout: 1,
-    });
-
-    engine.responder = async (_wfctx: InferenceContext, _session: StubSession, signal?: AbortSignal) => {
-        await new Promise(resolve => setTimeout(resolve, 10));
-        if (signal?.aborted) throw new TypeError('timed out');
-        return 'late';
-    };
-
-    const e = await t.throwsAsync(
-        engine.stateless(makeInferenceContext(), makeStringSession()),
-    );
-    t.true(e instanceof InferenceTimeout);
-});
-
-test('Engine stateful/append/push message semantics are correct', async t => {
-    const engine = new StubEngine({
-        ...makeBaseOptions(),
-        apiType: 'google',
-    });
-    engine.responder = async () => 'stateful-ok';
-
-    const session = makeStringSession();
-    const response = await engine.stateful(makeInferenceContext(), session);
-    t.is(response, 'stateful-ok');
-    t.deepEqual(session.chatMessages, ['stateful-ok']);
-
-    const user = makeUserMessage();
-    const appended = engine.appendUserMessage(session, user);
-    t.not(appended, session);
-    t.deepEqual(appended.chatMessages, ['stateful-ok', user]);
-    t.deepEqual(session.chatMessages, ['stateful-ok']);
-
-    const pushed = engine.pushUserMessage(session, user);
-    t.is(pushed, session);
-    t.deepEqual(session.chatMessages, ['stateful-ok', user]);
-});

package/test/src/test-helpers.ts

@@ -1,53 +0,0 @@
-import { Type } from '@sinclair/typebox';
-import { Function } from '#@/function.ts';
-import { type InferenceContext } from '#@/inference-context.ts';
-import { RoleMessage, type Session } from '#@/compatible/session.ts';
-import { Throttle } from '#@/throttle.ts';
-
-
-export const fdm = {
-    foo: {
-        description: 'foo tool',
-        paraschema: Type.Object({ x: Type.Number() }),
-    },
-    bar: {
-        description: 'bar tool',
-        paraschema: Type.Object({ y: Type.String() }),
-    },
-} satisfies Function.Declaration.Map;
-
-export type fdm = typeof fdm;
-
-export function makeBaseOptions() {
-    return {
-        baseUrl: 'https://example.com/v1',
-        apiKey: 'test-key',
-        model: 'test-model',
-        name: 'Test Endpoint',
-        functionDeclarationMap: fdm,
-        throttle: new Throttle(60),
-        inputPrice: 1,
-        outputPrice: 2,
-        cachePrice: 3,
-    };
-}
-
-export function makeSession(): Session<fdm> {
-    return { chatMessages: [] };
-}
-
-export function makeUserMessage(): RoleMessage.User<fdm> {
-    return RoleMessage.User.create<fdm>([RoleMessage.Part.Text.create('hello')]);
-}
-
-export function makeAiMessage(text = 'ok'): RoleMessage.Ai<fdm> {
-    return RoleMessage.Ai.create<fdm>([RoleMessage.Part.Text.create(text)]);
-}
-
-export function makeInferenceContext(signal: AbortSignal | null = null): InferenceContext {
-    return {
-        busy: null,
-        signal,
-        cost() {},
-    };
-}