sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Cloudflare/ AI/ LanguageModelRequest.unit.test.ts

import { makeLanguageModel } from "@alchemy.run/cloudflare/AI/LanguageModel";
/// <reference types="@cloudflare/workers-types" />
import { describe, expect, test } from "@alchemy.run/test";
import { RuntimeContext } from "alchemy/RuntimeContext";
import { LanguageModel, Tool, Toolkit } from "effect/ai";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";

const tags = ["unit", "provider:cloudflare", "provider:cloudflare:ai", "local"];

interface WireTool {
  type: "function";
  function: { name: string; description?: string; parameters: Record<string, unknown> };
}
interface WireBody {
  messages: Array<{ role: string; content: unknown }>;
  tools?: WireTool[];
  tool_choice?: string;
  stream?: boolean;
}

// Capture requests at the public adapter boundary, including the real Effect
// prompt/tool preparation. A fresh response is required for every invocation.
const capture = (onRequest?: (body: WireBody, index: number) => void) => {
  const requests: WireBody[] = [];
  const ai = {
    run: async (_model: string, input: unknown) => {
      const body = input as WireBody;
      requests.push(structuredClone(body));
      onRequest?.(body, requests.length - 1);
      return body.stream
        ? new Response('data: {"response":"ok"}\n\ndata: [DONE]\n\n')
        : Response.json({ response: "ok" });
    },
  } as unknown as Ai;
  return {
    requests,
    layer: Layer.effect(
      LanguageModel.LanguageModel,
      makeLanguageModel({
        model: "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
        client: { raw: Effect.succeed(ai) },
      }),
    ).pipe(Layer.provide(RuntimeContext.phantom)),
  };
};

describe("Workers AI request preparation", () => {
  for (const native of [true, false]) {
    test.effect(
      `${native ? "native" : "fallback"} image encoding preserves offsets, all bytes and padding`,
      () => {
        const { requests, layer } = capture();
        return Effect.gen(function* () {
          const storage = new Uint8Array(264).fill(42);
          for (let i = 0; i < 256; i++) storage[i + 4] = i;
          const inputs = [
            new Uint8Array(),
            new Uint8Array([255]),
            new Uint8Array([255, 254]),
            new Uint8Array([255, 254, 253]),
            storage.subarray(4, 260),
          ];
          let nativeCalls = 0;
          for (const data of inputs) {
            // Shadow the capability on this fixture only. Never mutate the shared
            // prototype: unrelated tests may encode bytes concurrently.
            Object.defineProperty(data, "toBase64", {
              value: native
                ? function (this: Uint8Array) {
                    expect(this).toBe(data);
                    nativeCalls++;
                    return btoa(String.fromCharCode(...this));
                  }
                : undefined,
            });
            yield* LanguageModel.generateText({
              prompt: [{ role: "user", content: [{ type: "file", mediaType: "image/png", data }] }],
            });
          }
          expect(requests.map((request) => request.messages[0]?.content)).toEqual(
            inputs.map((data) => [
              {
                type: "image_url",
                image_url: {
                  // Independent web encoder; neither branch requires node:buffer.
                  url: `data:image/png;base64,${btoa(String.fromCharCode(...data))}`,
                },
              },
            ]),
          );
          expect(Array.from(storage.subarray(0, 4))).toEqual([42, 42, 42, 42]);
          expect(Array.from(storage.subarray(260))).toEqual([42, 42, 42, 42]);
          expect(nativeCalls).toBe(native ? inputs.length : 0);
        }).pipe(Effect.provide(layer));
      },
      { tags },
    );
  }

  test.effect(
    "schemas preserve Unicode, transforms and all tool choices",
    () => {
      const primary = Tool.make("primary", {
        description: "Météo 東京 🌦️",
        parameters: Schema.Struct({
          count: Schema.NumberFromString,
          city: Schema.String.annotate({ description: "São Paulo / 東京" }),
        }),
      });
      const secondary = Tool.make("secondary", {
        parameters: Schema.Struct({ yes: Schema.Boolean }),
      });
      const toolkit = Toolkit.make(primary, secondary);
      const handlers = toolkit.toLayer({
        primary: () => Effect.void,
        secondary: () => Effect.void,
      });
      const { requests, layer } = capture();
      return Effect.gen(function* () {
        for (const toolChoice of [
          "auto",
          "none",
          "required",
          { tool: "primary" },
          { oneOf: ["secondary"], mode: "auto" },
          { oneOf: ["primary"], mode: "required" },
        ] as const) {
          yield* LanguageModel.generateText({ prompt: "hi", toolkit, toolChoice });
        }
        // Exercise the same cached preparation through the streaming entrypoint.
        yield* LanguageModel.streamText({ prompt: "hi", toolkit, toolChoice: "auto" }).pipe(
          Stream.runDrain,
        );
        expect(requests.map((r) => r.tool_choice)).toEqual([
          "auto",
          "none",
          "required",
          "required",
          "auto",
          "required",
          "auto",
        ]);
        expect(requests.map((r) => r.tools?.map((t) => t.function.name))).toEqual([
          ["primary", "secondary"],
          ["primary", "secondary"],
          ["primary", "secondary"],
          ["primary"],
          ["secondary"],
          ["primary"],
          ["primary", "secondary"],
        ]);
        for (const request of requests) {
          for (const tool of request.tools ?? []) {
            if (tool.function.name === "primary") {
              expect(tool.function.description).toBe("Météo 東京 🌦️");
              expect(tool.function.parameters).toMatchObject({
                properties: {
                  count: { type: "string" },
                  city: { type: "string", description: "São Paulo / 東京" },
                },
              });
            }
          }
        }
      }).pipe(Effect.provide(handlers), Effect.provide(layer));
    },
    { tags },
  );

  test.effect(
    "schema replacement and metadata updates cannot reuse stale preparation",
    () => {
      const tool = Tool.make("mutable", {
        description: "before",
        parameters: Schema.Struct({ old: Schema.String }),
      });
      const toolkit = Toolkit.make(tool);
      const handlers = toolkit.toLayer({ mutable: () => Effect.void });
      const { requests, layer } = capture();
      return Effect.gen(function* () {
        yield* LanguageModel.generateText({ prompt: "hi", toolkit });
        // JS consumers can replace readonly fields despite the TS contract.
        Object.assign(tool, {
          description: "after",
          parametersSchema: Schema.Struct({ next: Schema.Boolean }),
        });
        yield* LanguageModel.generateText({ prompt: "hi", toolkit });
        expect(requests[0]?.tools?.[0]?.function).toMatchObject({
          description: "before",
          parameters: { properties: { old: { type: "string" } } },
        });
        expect(requests[1]?.tools?.[0]?.function).toMatchObject({
          description: "after",
          parameters: { properties: { next: { type: "boolean" } } },
        });
        expect(requests[1]?.tools?.[0]?.function.parameters.properties).not.toHaveProperty("old");
      }).pipe(Effect.provide(handlers), Effect.provide(layer));
    },
    { tags },
  );

  test.effect(
    "public setParameters clones prepare their new schema",
    () => {
      const first = Tool.make("replace", { parameters: Schema.Struct({ old: Schema.String }) });
      const next = first.setParameters(Schema.Struct({ next: Schema.Boolean }));
      const oldToolkit = Toolkit.make(first);
      const nextToolkit = Toolkit.make(next);
      const { requests, layer } = capture();
      return Effect.gen(function* () {
        yield* LanguageModel.generateText({ prompt: "hi", toolkit: oldToolkit }).pipe(
          Effect.provide(oldToolkit.toLayer({ replace: () => Effect.void })),
        );
        yield* LanguageModel.generateText({ prompt: "hi", toolkit: nextToolkit }).pipe(
          Effect.provide(nextToolkit.toLayer({ replace: () => Effect.void })),
        );
        expect(requests[0]?.tools?.[0]?.function.parameters).toMatchObject({
          properties: { old: { type: "string" } },
        });
        expect(requests[1]?.tools?.[0]?.function.parameters).toMatchObject({
          properties: { next: { type: "boolean" } },
        });
      }).pipe(Effect.provide(layer));
    },
    { tags },
  );

  test.effect(
    "dynamic caller-owned JSON schemas remain live after nested mutation",
    () => {
      const parameters = {
        type: "object" as const,
        properties: { value: { type: "string" as "string" | "number" } },
      };
      const dynamic = Tool.dynamic("dynamic", { parameters });
      const toolkit = Toolkit.make(dynamic);
      const { requests, layer } = capture();
      return Effect.gen(function* () {
        yield* LanguageModel.generateText({ prompt: "hi", toolkit });
        parameters.properties.value.type = "number";
        yield* LanguageModel.generateText({ prompt: "hi", toolkit });
        expect(requests[0]?.tools?.[0]?.function.parameters).toMatchObject({
          properties: { value: { type: "string" } },
        });
        expect(requests[1]?.tools?.[0]?.function.parameters).toMatchObject({
          properties: { value: { type: "number" } },
        });
      }).pipe(
        Effect.provide(toolkit.toLayer({ dynamic: () => Effect.void })),
        Effect.provide(layer),
      );
    },
    { tags },
  );

  test.effect(
    "a runtime client mutating one compiled request cannot poison later requests",
    () => {
      const tool = Tool.make("isolated", { parameters: Schema.Struct({ value: Schema.String }) });
      const toolkit = Toolkit.make(tool);
      const { requests, layer } = capture((request, index) => {
        if (index === 0) {
          const parameters = request.tools?.[0]?.function.parameters;
          if (parameters) {
            parameters.properties = {};
            parameters.description = "poisoned";
          }
        }
      });
      return Effect.gen(function* () {
        yield* LanguageModel.generateText({ prompt: "hi", toolkit });
        yield* LanguageModel.generateText({ prompt: "hi", toolkit });
        expect(requests[0]?.tools?.[0]?.function.parameters).toMatchObject({
          properties: { value: { type: "string" } },
        });
        expect(requests[1]?.tools?.[0]?.function.parameters).toEqual(
          requests[0]?.tools?.[0]?.function.parameters,
        );
      }).pipe(
        Effect.provide(toolkit.toLayer({ isolated: () => Effect.void })),
        Effect.provide(layer),
      );
    },
    { tags },
  );
});