opencode-google-auth 0.0.1

package/src/transform/request.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, it } from "bun:test"
+import { transformRequest } from "./request"
+import { geminiCliConfig, ProviderConfig } from "../lib/services/config"
+import { Session } from "../lib/services/session"
+import { Effect, Layer, pipe } from "effect"
+
+describe("transformRequest", () => {
+  const baseParams = {
+    accessToken: "test-token",
+    projectId: "test-project-123",
+  }
+
+  const config = geminiCliConfig()
+
+  const MockSession = Layer.succeed(
+    Session,
+    Session.of({
+      getAccessToken: Effect.succeed(baseParams.accessToken),
+      ensureProject: Effect.succeed({
+        cloudaicompanionProject: baseParams.projectId,
+        currentTier: {
+          id: "free",
+          name: "Free",
+          description: "",
+          userDefinedCloudaicompanionProject: false,
+        },
+        allowedTiers: [],
+        gcpManaged: false,
+        manageSubscriptionUri: "",
+      }),
+      setCredentials: () => Effect.void,
+    } as unknown as Session),
+  ).pipe(Layer.provideMerge(Layer.succeed(ProviderConfig, config)))
+
+  const runTransform = (
+    input: Parameters<typeof fetch>[0],
+    init: Parameters<typeof fetch>[1],
+    endpoint = "https://example.com",
+  ) =>
+    pipe(
+      transformRequest(input, init, endpoint),
+      Effect.provide(MockSession),
+      Effect.runPromise,
+    )
+
+  describe("URL transformation", () => {
+    it("transforms /v1beta/models/{model}:{action} to /v1internal:{action}", async () => {
+      const result = await runTransform(
+        "https://example.com/v1beta/models/gemini-2.5-pro:generateContent",
+        undefined,
+      )
+
+      expect(result.input).toContain("/v1internal:generateContent")
+      expect(result.streaming).toBe(false)
+    })
+
+    it("detects streaming requests", async () => {
+      const result = await runTransform(
+        "https://example.com/v1beta/models/gemini-2.5-pro:streamGenerateContent",
+        undefined,
+      )
+
+      expect(result.input).toContain("/v1internal:streamGenerateContent")
+      expect(result.input).toContain("alt=sse")
+      expect(result.streaming).toBe(true)
+    })
+
+    it("passes through non-matching URLs", async () => {
+      const url = "https://example.com/some/other/path"
+      const result = await runTransform(url, undefined)
+
+      expect(result.input).toBe(url)
+      expect(result.streaming).toBe(false)
+    })
+  })
+
+  describe("header transformation", () => {
+    it("sets Authorization header", async () => {
+      const result = await runTransform(
+        "https://example.com/v1beta/models/gemini-2.5-pro:generateContent",
+        {},
+      )
+
+      const headers = result.init.headers as Headers
+      expect(headers.get("Authorization")).toBe("Bearer test-token")
+    })
+
+    it("removes x-api-key header", async () => {
+      const result = await runTransform(
+        "https://example.com/v1beta/models/gemini-2.5-pro:generateContent",
+        {
+          headers: {
+            "x-api-key": "some-key",
+            "x-goog-api-key": "another-key",
+          },
+        },
+      )
+
+      const headers = result.init.headers as Headers
+      expect(headers.get("x-api-key")).toBeNull()
+      expect(headers.get("x-goog-api-key")).toBeNull()
+    })
+
+    it("sets Accept header for streaming", async () => {
+      const result = await runTransform(
+        "https://example.com/v1beta/models/gemini-2.5-pro:streamGenerateContent",
+        {},
+      )
+
+      const headers = result.init.headers as Headers
+      expect(headers.get("Accept")).toBe("text/event-stream")
+    })
+
+    it("applies provider-specific headers", async () => {
+      const result = await runTransform(
+        "https://example.com/v1beta/models/gemini-2.5-pro:generateContent",
+        {},
+      )
+
+      const headers = result.init.headers as Headers
+      expect(headers.get("User-Agent")).toBe(
+        config.HEADERS["User-Agent"] ?? null,
+      )
+      expect(headers.get("X-Goog-Api-Client")).toBe(
+        config.HEADERS["X-Goog-Api-Client"] ?? null,
+      )
+    })
+  })
+
+  describe("body transformation", () => {
+    it("wraps request body with project and model", async () => {
+      const originalBody = JSON.stringify({ contents: [{ text: "Hello" }] })
+
+      const result = await runTransform(
+        "https://example.com/v1beta/models/gemini-2.5-pro:generateContent",
+        { body: originalBody },
+      )
+
+      const body = JSON.parse(result.init.body as string)
+      expect(body.project).toBe("test-project-123")
+      expect(body.model).toBe("gemini-2.5-pro")
+      expect(body.request).toEqual({ contents: [{ text: "Hello" }] })
+    })
+
+    it("preserves body if not JSON", async () => {
+      const originalBody = "not-json"
+
+      const result = await runTransform(
+        "https://example.com/v1beta/models/gemini-2.5-pro:generateContent",
+        { body: originalBody },
+      )
+
+      expect(result.init.body).toBe("not-json")
+    })
+  })
+
+  describe("input types", () => {
+    it("handles URL object", async () => {
+      const url = new URL(
+        "https://example.com/v1beta/models/gemini-2.5-pro:generateContent",
+      )
+      const result = await runTransform(url, undefined)
+
+      expect(result.input).toContain("/v1internal:generateContent")
+    })
+
+    it("handles Request object", async () => {
+      const request = new Request(
+        "https://example.com/v1beta/models/gemini-2.5-pro:generateContent",
+      )
+      const result = await runTransform(request, undefined)
+
+      expect(result.input).toContain("/v1internal:generateContent")
+    })
+  })
+})

package/src/transform/request.ts

@@ -0,0 +1,102 @@
+import { regex } from "arkregex"
+import { Effect, pipe } from "effect"
+import {
+  CODE_ASSIST_VERSION,
+  ProviderConfig,
+  type RequestContext,
+} from "../lib/services/config"
+import { Session } from "../lib/services/session"
+
+const STREAM_ACTION = "streamGenerateContent"
+const PATH_PATTERN = regex("/models/(?<model>[^:]+):(?<action>\\w+)")
+
+export const transformRequest = Effect.fn("transformRequest")(function* (
+  input: Parameters<typeof fetch>[0],
+  init: Parameters<typeof fetch>[1],
+  endpoint: string,
+) {
+  const config = yield* ProviderConfig
+  const session = yield* Session
+  const accessToken = yield* session.getAccessToken
+  const project = yield* session.ensureProject
+  const projectId = project.cloudaicompanionProject
+
+  const url = new URL(input instanceof Request ? input.url : input)
+
+  // Rewrite the URL to use the specified endpoint
+  const endpointUrl = new URL(endpoint)
+  url.protocol = endpointUrl.protocol
+  url.host = endpointUrl.host
+
+  const match = PATH_PATTERN.exec(url.pathname)
+  if (!match) {
+    return {
+      input: url.toString(),
+      init: init ?? {},
+      streaming: false,
+    }
+  }
+
+  const { model, action } = match.groups
+  const streaming = action === STREAM_ACTION
+
+  // Transform URL to internal endpoint
+  url.pathname = `/${CODE_ASSIST_VERSION}:${action}`
+  if (streaming) {
+    url.searchParams.set("alt", "sse")
+  }
+
+  // Transform headers
+  const headers = new Headers(init?.headers)
+  headers.delete("x-api-key")
+  // headers.delete("x-goog-api-key")
+  headers.set("x-opencode-tools-debug", "1")
+  headers.set("Authorization", `Bearer ${accessToken}`)
+
+  for (const [key, value] of Object.entries(config.HEADERS)) {
+    headers.set(key, value)
+  }
+
+  if (streaming) {
+    headers.set("Accept", "text/event-stream")
+  }
+
+  // Wrap and transform request
+  const isJson = typeof init?.body === "string"
+  const parsedBody = yield* pipe(
+    Effect.try(() => (isJson ? JSON.parse(init.body as string) : null)),
+    Effect.orElseSucceed(() => null),
+  )
+
+  const wrappedBody = {
+    project: projectId,
+    model,
+    request: parsedBody ?? {},
+  }
+
+  const {
+    body: transformedBody,
+    headers: finalHeaders,
+    url: finalUrl,
+  } =
+    config.transformRequest ?
+      yield* config.transformRequest({
+        body: wrappedBody,
+        headers,
+        url,
+      } satisfies RequestContext)
+    : { body: wrappedBody, headers, url }
+
+  const finalBody =
+    isJson && parsedBody ? JSON.stringify(transformedBody) : init?.body
+
+  return {
+    input: finalUrl.toString(),
+    init: {
+      ...init,
+      headers: finalHeaders,
+      body: finalBody,
+    },
+    streaming,
+  }
+})

package/src/transform/response.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "bun:test"
+import { transformNonStreamingResponse } from "./response"
+
+describe("transformNonStreamingResponse", () => {
+  it("unwraps { response: X } to X", async () => {
+    const original = new Response(
+      JSON.stringify({ response: { text: "Hello" } }),
+      { headers: { "content-type": "application/json" } },
+    )
+
+    const result = await transformNonStreamingResponse(original)
+    const body = await result.json()
+
+    expect(body).toEqual({ text: "Hello" })
+  })
+
+  it("passes through response without wrapper", async () => {
+    const original = new Response(JSON.stringify({ text: "Hello" }), {
+      headers: { "content-type": "application/json" },
+    })
+
+    const result = await transformNonStreamingResponse(original)
+    const body = await result.json()
+
+    expect(body).toEqual({ text: "Hello" })
+  })
+
+  it("passes through non-JSON responses", async () => {
+    const original = new Response("plain text", {
+      headers: { "content-type": "text/plain" },
+    })
+
+    const result = await transformNonStreamingResponse(original)
+    const body = await result.text()
+
+    expect(body).toBe("plain text")
+  })
+
+  it("preserves status code", async () => {
+    const original = new Response(JSON.stringify({ response: {} }), {
+      status: 201,
+      statusText: "Created",
+      headers: { "content-type": "application/json" },
+    })
+
+    const result = await transformNonStreamingResponse(original)
+
+    expect(result.status).toBe(201)
+    expect(result.statusText).toBe("Created")
+  })
+
+  it("preserves headers", async () => {
+    const original = new Response(JSON.stringify({ response: {} }), {
+      headers: {
+        "content-type": "application/json",
+        "x-custom-header": "value",
+      },
+    })
+
+    const result = await transformNonStreamingResponse(original)
+
+    expect(result.headers.get("x-custom-header")).toBe("value")
+  })
+
+  it("handles malformed JSON gracefully", async () => {
+    const original = new Response("not-json{", {
+      headers: { "content-type": "application/json" },
+    })
+
+    const result = await transformNonStreamingResponse(original)
+    const body = await result.text()
+
+    expect(body).toBe("not-json{")
+  })
+})

package/src/transform/response.ts

@@ -0,0 +1,27 @@
+export const transformNonStreamingResponse = async (
+  response: Response,
+): Promise<Response> => {
+  const contentType = response.headers.get("content-type")
+
+  if (!contentType?.includes("application/json")) {
+    return response
+  }
+
+  try {
+    const cloned = response.clone()
+    const parsed = (await cloned.json()) as { response?: unknown }
+
+    if (parsed.response !== undefined) {
+      const { response: responseData, ...rest } = parsed
+      return new Response(JSON.stringify({ ...rest, ...responseData }), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      })
+    }
+  } catch {
+    // Return original if parse fails
+  }
+
+  return response
+}

package/src/transform/stream.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "bun:test"
+import { transformStreamingResponse } from "./stream"
+
+describe("transformStreamingResponse", () => {
+  const createSSEStream = (events: string[]) => {
+    const encoder = new TextEncoder()
+    return new ReadableStream({
+      start(controller) {
+        for (const event of events) {
+          controller.enqueue(encoder.encode(event))
+        }
+        controller.close()
+      },
+    })
+  }
+
+  it("unwraps response wrapper from SSE events", async () => {
+    const stream = createSSEStream([
+      'data: {"response":{"text":"Hello"}}\n\n',
+      'data: {"response":{"text":" World"}}\n\n',
+    ])
+
+    const response = new Response(stream, {
+      headers: { "content-type": "text/event-stream" },
+    })
+
+    const result = await transformStreamingResponse(response)
+    const text = await result.text()
+
+    expect(text).toContain('data: {"text":"Hello"}')
+    expect(text).toContain('data: {"text":" World"}')
+  })
+
+  it("handles responses without wrapper", async () => {
+    const stream = createSSEStream(['data: {"text":"Direct"}\n\n'])
+
+    const response = new Response(stream, {
+      headers: { "content-type": "text/event-stream" },
+    })
+
+    const result = await transformStreamingResponse(response)
+    const text = await result.text()
+
+    expect(text).toContain('data: {"text":"Direct"}')
+  })
+
+  it("returns original response if no body", async () => {
+    const response = new Response(null, { status: 204 })
+
+    const result = await transformStreamingResponse(response)
+
+    expect(result.status).toBe(204)
+  })
+
+  it("preserves status and headers", async () => {
+    const stream = createSSEStream(['data: {"response":{}}\n\n'])
+
+    const response = new Response(stream, {
+      status: 200,
+      statusText: "OK",
+      headers: {
+        "content-type": "text/event-stream",
+        "x-custom": "value",
+      },
+    })
+
+    const result = await transformStreamingResponse(response)
+
+    expect(result.status).toBe(200)
+    expect(result.headers.get("x-custom")).toBe("value")
+  })
+
+  it("handles chunked SSE data", async () => {
+    // Simulate data split across chunks
+    const stream = createSSEStream([
+      'data: {"resp',
+      'onse":{"part":"1"}}\n\ndata: {"response":{"part":"2"}}\n\n',
+    ])
+
+    const response = new Response(stream, {
+      headers: { "content-type": "text/event-stream" },
+    })
+
+    const result = await transformStreamingResponse(response)
+    const text = await result.text()
+
+    expect(text).toContain('data: {"part":"1"}')
+    expect(text).toContain('data: {"part":"2"}')
+  })
+
+  it("filters out non-data lines", async () => {
+    const stream = createSSEStream([
+      ": comment\n",
+      "event: message\n",
+      'data: {"response":{"valid":"data"}}\n\n',
+    ])
+
+    const response = new Response(stream, {
+      headers: { "content-type": "text/event-stream" },
+    })
+
+    const result = await transformStreamingResponse(response)
+    const text = await result.text()
+
+    expect(text).toContain('data: {"valid":"data"}')
+    expect(text).not.toContain("comment")
+  })
+})

package/src/transform/stream.ts

@@ -0,0 +1,61 @@
+import {
+  encoder,
+  type Event,
+  makeChannel,
+  Retry,
+} from "@effect/experimental/Sse"
+import { pipe, Stream } from "effect"
+
+const parseAndMerge = (event: Event): string => {
+  if (!event.data) {
+    return encoder.write(event)
+  }
+
+  try {
+    const parsed = JSON.parse(event.data) as {
+      response?: Record<string, unknown>
+    }
+    if (parsed.response) {
+      const { response, ...rest } = parsed
+      return encoder.write({
+        ...event,
+        data: JSON.stringify({ ...rest, ...response }),
+      })
+    }
+
+    return encoder.write(event)
+  } catch {
+    return encoder.write(event)
+  }
+}
+
+const parseSSE = (body: ReadableStream<Uint8Array>) =>
+  pipe(
+    Stream.fromReadableStream(
+      () => body,
+      (error) => error,
+    ),
+    Stream.decodeText,
+    Stream.pipeThroughChannel(makeChannel()),
+    Stream.map((event) =>
+      Retry.is(event) ? encoder.write(event) : parseAndMerge(event),
+    ),
+    Stream.encodeText,
+  )
+
+export const transformStreamingResponse = (response: Response) => {
+  if (!response.body) {
+    return response
+  }
+
+  const transformed = parseSSE(response.body)
+  const readable = Stream.toReadableStream(
+    transformed as Stream.Stream<Uint8Array, never, never>,
+  )
+
+  return new Response(readable, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  })
+}

package/src/types.ts

@@ -0,0 +1,66 @@
+import type { Hooks, PluginInput } from "@opencode-ai/plugin"
+
+export type OpenCodeConfigHook = NonNullable<Hooks["config"]>
+export type OpenCodeConfig = Parameters<OpenCodeConfigHook>[0]
+export type OpenCodeProvider = NonNullable<OpenCodeConfig["provider"]>[string]
+export type OpenCodeModel = NonNullable<OpenCodeProvider["models"]>[string]
+
+export type OpenCodeAuthHook = NonNullable<Hooks["auth"]>
+export type OpenCodeAuthLoader = NonNullable<OpenCodeAuthHook["loader"]>
+export type OpenCodeAuthMethod = NonNullable<
+  OpenCodeAuthHook["methods"]
+>[number]
+
+export type OpenCodeLogLevel = NonNullable<
+  NonNullable<Parameters<PluginInput["client"]["app"]["log"]>[0]>["body"]
+>["level"]
+
+export type BunServeOptions = Partial<Bun.Serve.Options<undefined, never>>
+
+/**
+ * Subset of google-auth-library Credentials type.
+ *
+ * Why don't they fucking use object union instead of making everything nullable.
+ */
+export interface Credentials {
+  access_token: string
+  refresh_token: string
+  expiry_date: number
+}
+
+/**
+ * Types for models.dev, simplified
+ */
+
+interface InterleavedConfig {
+  field: string
+}
+
+export interface Model {
+  id: string
+  name: string
+  family: string
+  attachment: boolean
+  reasoning: boolean
+  tool_call: boolean
+  temperature: boolean
+  knowledge?: string
+  release_date?: string
+  last_updated?: string
+  open_weights: boolean
+  structured_output?: boolean
+  interleaved?: boolean | InterleavedConfig
+  status?: string
+}
+
+export interface Provider {
+  id: string
+  env: string[]
+  npm: string
+  name: string
+  doc: string
+  models: Record<string, Model>
+  api?: string
+}
+
+export type ModelsDev = Record<string, Provider>