Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

15.1 KB
Raw Blame
import { randomUUID } from "node:crypto";
import { z } from "zod";

// Google's OpenAI endpoint accepts API keys, not the desktop's user OAuth token.
// Keep the local agents' Chat Completions contract while using the native API.
const toolCall = z.object({
  id: z.string(),
  function: z.object({ name: z.string(), arguments: z.string() }),
});
const chat = z.object({
  model: z.string().regex(/^(?:models\/)?[a-zA-Z0-9._-]+$/),
  messages: z.array(
    z.object({
      role: z.enum(["system", "developer", "user", "assistant", "tool"]),
      content: z.unknown().optional(),
      tool_calls: z.array(toolCall).optional(),
      tool_call_id: z.string().optional(),
    }),
  ),
  tools: z
    .array(
      z.object({
        type: z.literal("function"),
        function: z.object({
          name: z.string(),
          description: z.string().optional(),
          parameters: z.record(z.string(), z.unknown()).optional(),
        }),
      }),
    )
    .optional(),
  tool_choice: z
    .union([
      z.enum(["auto", "none", "required"]),
      z.object({
        type: z.literal("function"),
        function: z.object({ name: z.string() }),
      }),
    ])
    .optional(),
  stream: z.boolean().optional(),
  stream_options: z
    .object({ include_usage: z.boolean().optional() })
    .optional(),
  temperature: z.number().optional(),
  top_p: z.number().optional(),
  max_tokens: z.number().optional(),
  max_completion_tokens: z.number().optional(),
  stop: z
    .union([z.string(), z.array(z.string())])
    .nullable()
    .optional(),
  response_format: z
    .object({
      type: z.string(),
      json_schema: z
        .object({ schema: z.record(z.string(), z.unknown()) })
        .optional(),
    })
    .optional(),
});
const partSchema = z
  .object({
    text: z.string().optional(),
    thought: z.boolean().optional(),
    thoughtSignature: z.string().optional(),
    functionCall: z
      .object({
        name: z.string(),
        args: z.record(z.string(), z.unknown()).optional(),
        id: z.string().optional(),
      })
      .optional(),
  })
  .passthrough();
type Part = z.infer<typeof partSchema>;
type Content = { role: "user" | "model"; parts: Part[] };
const nativeResponse = z.object({
  candidates: z
    .array(
      z.object({
        index: z.number().optional(),
        content: z.object({ parts: z.array(partSchema).optional() }).optional(),
        finishReason: z.string().optional(),
      }),
    )
    .optional(),
  usageMetadata: z
    .object({
      promptTokenCount: z.number().optional(),
      candidatesTokenCount: z.number().optional(),
      thoughtsTokenCount: z.number().optional(),
      totalTokenCount: z.number().optional(),
    })
    .optional(),
  promptFeedback: z.object({ blockReason: z.string().optional() }).optional(),
});
type NativeResponse = z.infer<typeof nativeResponse>;

function parseNative(value: unknown): NativeResponse {
  if (value && typeof value === "object" && "error" in value)
    throw new Error("The Google model stream failed.");
  return nativeResponse.parse(value);
}

function contentParts(value: unknown): Part[] {
  if (value == null) return [];
  if (typeof value === "string") return value ? [{ text: value }] : [];
  return z
    .array(
      z.object({
        type: z.string(),
        text: z.string().optional(),
        image_url: z.object({ url: z.string() }).optional(),
      }),
    )
    .parse(value)
    .map((part) => {
      if (part.type === "text" && part.text !== undefined)
        return { text: part.text };
      if (part.type === "image_url" && part.image_url) {
        const data =
          /^data:(image\/[a-zA-Z0-9.+-]+);base64,([A-Za-z0-9+/=\s]+)$/.exec(
            part.image_url.url,
          );
        if (data) return { inlineData: { mimeType: data[1], data: data[2] } };
        const url = new URL(part.image_url.url);
        if (url.protocol !== "https:") throw new Error("Unsupported image URL");
        return { fileData: { fileUri: url.href } };
      }
      throw new Error("Unsupported model content");
    });
}

// Match LiteLLM's maintained OpenAI-client compatibility technique: only the
// opaque signature travels in the ID, never model text or tool arguments.
// https://github.com/BerriAI/litellm/blob/main/litellm/litellm_core_utils/prompt_templates/factory.py
const signatureSeparator = "__thought__";

export function googleRequest(input: unknown) {
  const request = chat.parse(input);
  const contents: Content[] = [];
  const system: Part[] = [];
  const calls = new Map<string, { name: string; id?: string }>();
  for (const message of request.messages) {
    let parts = contentParts(message.content);
    if (message.role === "system" || message.role === "developer") {
      if (parts.some((part) => part.text === undefined))
        throw new Error("System instructions must be text");
      system.push(...parts);
      continue;
    }
    if (message.role === "assistant" && message.tool_calls?.length) {
      const generated = message.tool_calls.map((call) => {
        const args = z
          .record(z.string(), z.unknown())
          .parse(JSON.parse(call.function.arguments));
        const separator = call.id.indexOf(signatureSeparator);
        const cleanId = separator < 0 ? call.id : call.id.slice(0, separator);
        const signature =
          separator < 0
            ? undefined
            : call.id.slice(separator + signatureSeparator.length);
        const id = /^(?:models\/)?gemini-3/.test(request.model)
          ? cleanId
          : undefined;
        calls.set(call.id, { name: call.function.name, id });
        return {
          functionCall: {
            name: call.function.name,
            args,
            ...(id ? { id } : {}),
          },
          ...(signature ? { thoughtSignature: signature } : {}),
        };
      });
      parts.push(...generated);
    }
    if (message.role === "tool") {
      const call = calls.get(message.tool_call_id ?? "");
      if (!call) throw new Error("Tool result has no matching call");
      const text = parts
        .flatMap((part) => (part.text === undefined ? [] : [part.text]))
        .join("\n");
      const images = parts.filter((part) => part.inlineData !== undefined);
      if (parts.some((part) => part.fileData !== undefined))
        throw new Error("Tool images must use inline data");
      let result: unknown = text;
      try {
        result = JSON.parse(text);
      } catch {
        /* Plain text tool output is valid. */
      }
      parts = [
        {
          functionResponse: {
            ...call,
            response: { result },
            ...(images.length ? { parts: images } : {}),
          },
        },
      ];
    }
    if (!parts.length) continue;
    const role = message.role === "assistant" ? "model" : "user";
    const previous = contents.at(-1);
    if (previous?.role === role) previous.parts.push(...parts);
    else contents.push({ role, parts });
  }
  const generationConfig: Record<string, unknown> = {};
  if (request.temperature !== undefined)
    generationConfig.temperature = request.temperature;
  if (request.top_p !== undefined) generationConfig.topP = request.top_p;
  if (
    request.max_completion_tokens !== undefined ||
    request.max_tokens !== undefined
  )
    generationConfig.maxOutputTokens =
      request.max_completion_tokens ?? request.max_tokens;
  if (request.stop)
    generationConfig.stopSequences =
      typeof request.stop === "string" ? [request.stop] : request.stop;
  if (
    request.response_format?.type === "json_object" ||
    request.response_format?.type === "json_schema"
  ) {
    generationConfig.responseMimeType = "application/json";
    if (request.response_format.json_schema)
      generationConfig.responseJsonSchema =
        request.response_format.json_schema.schema;
  }
  const choice = request.tool_choice;
  const model = request.model.replace(/^models\//, "");
  return {
    model,
    stream: request.stream === true,
    includeUsage: request.stream_options?.include_usage === true,
    url: `https://generativelanguage.googleapis.com/v1beta/models/${model}:${request.stream ? "streamGenerateContent?alt=sse" : "generateContent"}`,
    body: {
      contents,
      ...(system.length ? { systemInstruction: { parts: system } } : {}),
      ...(Object.keys(generationConfig).length ? { generationConfig } : {}),
      ...(request.tools?.length
        ? {
            tools: [
              {
                functionDeclarations: request.tools.map(({ function: fn }) => ({
                  name: fn.name,
                  ...(fn.description ? { description: fn.description } : {}),
                  ...(fn.parameters
                    ? { parametersJsonSchema: fn.parameters }
                    : {}),
                })),
              },
            ],
          }
        : {}),
      ...(choice
        ? {
            toolConfig: {
              functionCallingConfig:
                typeof choice === "object"
                  ? {
                      mode: "ANY",
                      allowedFunctionNames: [choice.function.name],
                    }
                  : {
                      mode: { auto: "AUTO", none: "NONE", required: "ANY" }[
                        choice
                      ],
                    },
            },
          }
        : {}),
    },
  };
}

function usage(metadata: NativeResponse["usageMetadata"]) {
  if (!metadata) return undefined;
  const prompt = metadata.promptTokenCount ?? 0;
  const completion =
    (metadata.candidatesTokenCount ?? 0) + (metadata.thoughtsTokenCount ?? 0);
  return {
    prompt_tokens: prompt,
    completion_tokens: completion,
    total_tokens: metadata.totalTokenCount ?? prompt + completion,
    completion_tokens_details: {
      reasoning_tokens: metadata.thoughtsTokenCount ?? 0,
    },
  };
}

function finishReason(reason: string | undefined, hasCalls: boolean): string {
  if (reason === "MAX_TOKENS") return "length";
  if (reason && reason !== "STOP") return "content_filter";
  return hasCalls ? "tool_calls" : "stop";
}

function outputCalls(parts: Part[]) {
  return parts
    .flatMap((part) =>
      part.functionCall ? [{ part, fn: part.functionCall }] : [],
    )
    .map(({ part, fn }) => ({
      id: `${fn.id ?? `call_${randomUUID().replaceAll("-", "")}`}${part.thoughtSignature ? `${signatureSeparator}${part.thoughtSignature}` : ""}`,
      type: "function" as const,
      function: { name: fn.name, arguments: JSON.stringify(fn.args ?? {}) },
    }));
}

/** Transform only successful native responses; the caller handles auth and errors. */
export async function googleResponse(
  response: Response,
  model: string,
  stream: boolean,
  includeUsage = false,
): Promise<Response> {
  const id = `chatcmpl-${randomUUID()}`;
  const created = Math.floor(Date.now() / 1000);
  const headers = {
    "content-type": stream ? "text/event-stream" : "application/json",
    "cache-control": "no-store",
  };
  if (!stream) {
    const native = parseNative(await response.json());
    const candidate = native.candidates?.[0];
    const parts = candidate?.content?.parts ?? [];
    const calls = outputCalls(parts);
    return Response.json(
      {
        id,
        object: "chat.completion",
        created,
        model,
        choices: [
          {
            index: 0,
            message: {
              role: "assistant",
              content:
                parts
                  .filter((part) => !part.thought)
                  .map((part) => part.text ?? "")
                  .join("") || null,
              ...(calls.length ? { tool_calls: calls } : {}),
              extra_content: { google: { parts } },
            },
            finish_reason: finishReason(
              candidate?.finishReason ?? native.promptFeedback?.blockReason,
              calls.length > 0,
            ),
          },
        ],
        usage: usage(native.usageMetadata),
      },
      { headers },
    );
  }
  if (!response.body) throw new Error("Gemini returned no stream");
  let buffer = "";
  let data: string[] = [];
  const parts: Part[] = [];
  let metadata: NativeResponse["usageMetadata"];
  let reason: string | undefined;
  let began = false;
  let failed = false;
  const encode = new TextEncoder();
  const fail = (controller: TransformStreamDefaultController<Uint8Array>) => {
    if (failed) return;
    failed = true;
    controller.enqueue(
      encode.encode(
        `data: ${JSON.stringify({ error: { message: "The Google model stream failed or ended early. Try again.", type: "provider_error", code: "incomplete_model_stream" } })}\n\n`,
      ),
    );
  };
  const send = (
    controller: TransformStreamDefaultController<Uint8Array>,
    delta: Record<string, unknown>,
    finish: string | null = null,
  ) => {
    controller.enqueue(
      encode.encode(
        `data: ${JSON.stringify({ id, object: "chat.completion.chunk", created, model, choices: [{ index: 0, delta, finish_reason: finish }] })}\n\n`,
      ),
    );
  };
  const frame = (controller: TransformStreamDefaultController<Uint8Array>) => {
    if (!data.length) return;
    const json = data.join("\n");
    data = [];
    if (json === "[DONE]") return;
    let native: NativeResponse;
    try {
      native = parseNative(JSON.parse(json));
    } catch {
      fail(controller);
      return;
    }
    if (!began) {
      send(controller, { role: "assistant", content: "" });
      began = true;
    }
    const candidate = native.candidates?.[0];
    for (const part of candidate?.content?.parts ?? []) {
      parts.push(part);
      if (part.text && !part.thought) send(controller, { content: part.text });
    }
    metadata = native.usageMetadata ?? metadata;
    reason =
      candidate?.finishReason ?? native.promptFeedback?.blockReason ?? reason;
  };
  const transformed = response.body
    .pipeThrough(new TextDecoderStream())
    .pipeThrough(
      new TransformStream<string, Uint8Array>({
        transform(chunk, controller) {
          if (failed) return;
          buffer += chunk;
          let newline = buffer.indexOf("\n");
          while (newline >= 0) {
            const line = buffer.slice(0, newline).replace(/\r$/, "");
            buffer = buffer.slice(newline + 1);
            if (!line) frame(controller);
            else if (line.startsWith("data:"))
              data.push(line.slice(5).replace(/^ /, ""));
            else if (!/^(?::|event:|id:|retry:)/.test(line)) fail(controller);
            if (failed) return;
            newline = buffer.indexOf("\n");
          }
        },
        flush(controller) {
          if (failed) return;
          if (buffer.trim() || data.length || !reason) {
            fail(controller);
            return;
          }
          const calls = outputCalls(parts);
          if (calls.length)
            send(controller, {
              tool_calls: calls.map((call, index) => ({ index, ...call })),
            });
          send(controller, {}, finishReason(reason, calls.length > 0));
          if (includeUsage && metadata)
            controller.enqueue(
              encode.encode(
                `data: ${JSON.stringify({ id, object: "chat.completion.chunk", created, model, choices: [], usage: usage(metadata) })}\n\n`,
              ),
            );
          controller.enqueue(encode.encode("data: [DONE]\n\n"));
        },
      }),
    );
  return new Response(transformed, { headers });
}