opencode-google-auth 0.0.6 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-google-auth",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "_description_",
   "keywords": [
     "opencode-google-auth"
@@ -34,26 +34,25 @@
   },
   "dependencies": {
     "@effect/experimental": "^0.58.0",
-    "@effect/platform": "^0.94.1",
-    "@effect/platform-bun": "^0.87.0",
-    "@opencode-ai/plugin": "^1.1.18",
+    "@effect/platform": "^0.94.2",
+    "@effect/platform-bun": "^0.87.1",
+    "@opencode-ai/plugin": "^1.1.36",
     "arkregex": "^0.0.5",
-    "effect": "^3.19.14",
+    "effect": "^3.19.15",
     "google-auth-library": "^10.5.0",
     "open": "^11.0.0",
     "xdg-basedir": "^5.1.0"
   },
   "devDependencies": {
-    "@ai-sdk/google": "^3.0.7",
-    "@effect/language-service": "^0.65.0",
-    "@types/bun": "^1.3.5",
+    "@effect/language-service": "^0.72.0",
+    "@types/bun": "^1.3.6",
     "@types/yargs": "^17.0.35",
-    "@typescript/native-preview": "^7.0.0-dev.20260113.1",
-    "ai": "^6.0.33",
+    "@typescript/native-preview": "^7.0.0-dev.20260126.1",
     "bumpp": "^10.4.0",
-    "oxlint": "^1.39.0",
-    "oxlint-tsgolint": "^0.11.0",
-    "prettier": "^3.7.4",
+    "cloudassist-ai-provider": "^0.0.2",
+    "oxlint": "^1.42.0",
+    "oxlint-tsgolint": "^0.11.2",
+    "prettier": "^3.8.1",
     "typescript": "^5.9.3",
     "yargs": "^18.0.0"
   },

package/src/main.ts

@@ -1,23 +1,15 @@
+import { HttpClient } from "@effect/platform"
+import type { Plugin } from "@opencode-ai/plugin"
 import type {
   GoogleGenerativeAIProviderOptions,
   GoogleGenerativeAIProviderSettings,
-} from "@ai-sdk/google"
-import { HttpClient } from "@effect/platform"
-import type { Plugin } from "@opencode-ai/plugin"
+} from "cloudassist-ai-provider"
 import { Effect } from "effect"
 import { makeRuntime } from "./lib/runtime"
-import {
-  antigravityConfig,
-  geminiCliConfig,
-  ProviderConfig,
-} from "./services/config"
+import { geminiCliConfig, ProviderConfig } from "./services/config"
 import { OAuth } from "./services/oauth"
 import { Session } from "./services/session"
-import { transformRequest } from "./transform/request"
-import { transformNonStreamingResponse } from "./transform/response"
-import { transformStreamingResponse } from "./transform/stream"
-import type { Credentials, ModelsDev } from "./types"
-import antigravitySpoof from "./antigravity-spoof.txt"
+import type { Credentials, FetchInit, FetchInput, ModelsDev } from "./types"
 
 const fetchModelsDev = Effect.gen(function* () {
   const client = yield* HttpClient.HttpClient
@@ -25,34 +17,25 @@ const fetchModelsDev = Effect.gen(function* () {
   return (yield* response.json) as ModelsDev
 })
 
-const customFetch = Effect.fn(function* (
-  input: Parameters<typeof fetch>[0],
-  init: Parameters<typeof fetch>[1],
-) {
+const customFetch = Effect.fn(function* (input: FetchInput, init: FetchInit) {
   const config = yield* ProviderConfig
 
   let lastResponse: Response | null = null
 
   for (const endpoint of config.ENDPOINTS) {
-    const result = yield* transformRequest(input, init, endpoint)
-
-    const { request, ...loggedBody } = JSON.parse(result.init.body as string)
-    const generationConfig = request.generationConfig
+    yield* Effect.log("Trying endpoint", endpoint)
+    yield* Effect.log("Input", input)
+    yield* Effect.log("Init", init)
 
-    yield* Effect.log(
-      "Transformed request (Omitting request except generationConfig) :",
-      result.streaming,
-      result.input,
-      { ...loggedBody, request: { generationConfig } },
-    )
+    const [finalInput, finalInit] = config.requestTransform?.(input, init) ?? [
+      input,
+      init,
+    ]
 
-    const response = yield* Effect.promise(() =>
-      fetch(result.input, result.init),
-    )
+    const response = yield* Effect.promise(() => fetch(finalInput, finalInit))
 
     // On 429 or 403, try next endpoint
     if (response.status === 429 || response.status === 403) {
-      yield* Effect.log(`${response.status} on ${endpoint}, trying next...`)
       lastResponse = response
       continue
     }
@@ -61,7 +44,7 @@ const customFetch = Effect.fn(function* (
       const cloned = response.clone()
       const clonedJson = yield* Effect.promise(() => cloned.json())
 
-      yield* Effect.log(
+      yield* Effect.logWarning(
         "Received response:",
         cloned.status,
         clonedJson,
@@ -69,18 +52,10 @@ const customFetch = Effect.fn(function* (
       )
     }
 
-    if (config.skipRequestTransform) {
-      yield* Effect.log("Skipping response transformation")
-      return response
-    }
-
-    return result.streaming ?
-        transformStreamingResponse(response)
-      : yield* Effect.promise(() => transformNonStreamingResponse(response))
+    return response
   }
 
-  // All endpoints exhausted with 429
-  yield* Effect.logWarning("All endpoints rate limited (429)")
+  yield* Effect.logError("All endpoints are rate limited (429)")
   return lastResponse as Response
 }, Effect.tapDefect(Effect.logError))
 
@@ -124,95 +99,7 @@ export const geminiCli: Plugin = async (context) => {
         )
 
         return {
-          apiKey: "",
-          fetch: (async (input, init) => {
-            const response = await runtime.runPromise(customFetch(input, init))
-            return response
-          }) as typeof fetch,
-        } satisfies GoogleGenerativeAIProviderSettings
-      },
-      methods: [
-        {
-          type: "oauth",
-          label: "OAuth with Google",
-          authorize: async () => {
-            const result = await runtime.runPromise(
-              Effect.gen(function* () {
-                const oauth = yield* OAuth
-                return yield* oauth.authenticate
-              }),
-            )
-
-            return {
-              url: "",
-              method: "auto",
-              instructions: "You are now authenticated!",
-              callback: async () => {
-                const accessToken = result.access_token
-                const refreshToken = result.refresh_token
-                const expiryDate = result.expiry_date
-
-                if (!accessToken || !refreshToken || !expiryDate) {
-                  return { type: "failed" }
-                }
-
-                return {
-                  type: "success",
-                  provider: config.id as string,
-                  access: accessToken,
-                  refresh: refreshToken,
-                  expires: expiryDate,
-                }
-              },
-            }
-          },
-        },
-      ],
-    },
-  }
-}
-
-export const antigravity: Plugin = async (context) => {
-  const runtime = makeRuntime({
-    openCodeCtx: context,
-    providerConfig: antigravityConfig(),
-  })
-
-  const config = await runtime.runPromise(
-    Effect.gen(function* () {
-      const providerConfig = yield* ProviderConfig
-      const modelsDev = yield* fetchModelsDev
-
-      return providerConfig.getConfig(modelsDev)
-    }),
-  )
-
-  return {
-    config: async (cfg) => {
-      cfg.provider ??= {}
-      cfg.provider[config.id as string] = config
-    },
-    auth: {
-      provider: config.id as string,
-      loader: async (getAuth) => {
-        const auth = await getAuth()
-        if (auth.type !== "oauth") return {}
-
-        const credentials: Credentials = {
-          access_token: auth.access,
-          refresh_token: auth.refresh,
-          expiry_date: auth.expires,
-        }
-
-        await runtime.runPromise(
-          Effect.gen(function* () {
-            const session = yield* Session
-            yield* session.setCredentials(credentials)
-          }),
-        )
-
-        return {
-          apiKey: "",
+          apiKey: auth.access,
           fetch: (async (input, init) => {
             const response = await runtime.runPromise(customFetch(input, init))
             return response
@@ -257,27 +144,153 @@ export const antigravity: Plugin = async (context) => {
         },
       ],
     },
-    "experimental.chat.system.transform": async (_input, output) => {
-      // THIS IS REQUIRED OTHERWISE YOU'LL GET 429 OR 403 FOR SOME GODDAMN REASON
-      output.system.unshift(antigravitySpoof)
-    },
     "chat.params": async (input, output) => {
-      await runtime.runPromise(
-        Effect.log("chat.params event before:", input.model, output.options),
+      const options = await runtime.runPromise(
+        Effect.gen(function* () {
+          const session = yield* Session
+          const project = yield* session.ensureProject
+          const projectId = project.cloudaicompanionProject
+
+          return {
+            projectId,
+          }
+        }),
       )
 
-      if (input.model.providerID === config.id) {
+      if (config.id === input.model.providerID) {
         output.options = {
           ...output.options,
-          labels: {
-            sessionId: input.sessionID,
-          },
+          projectId: options.projectId,
         } satisfies GoogleGenerativeAIProviderOptions
       }
 
       await runtime.runPromise(
-        Effect.log("chat.params event after:", input.model, output.options),
+        Effect.log("chat.params", config.id, input.model, output),
       )
     },
   }
 }
+
+// export const antigravity: Plugin = async (context) => {
+//   const runtime = makeRuntime({
+//     openCodeCtx: context,
+//     providerConfig: antigravityConfig(),
+//   })
+
+//   const config = await runtime.runPromise(
+//     Effect.gen(function* () {
+//       const providerConfig = yield* ProviderConfig
+//       const modelsDev = yield* fetchModelsDev
+
+//       const config = providerConfig.getConfig(modelsDev)
+//       yield* Effect.log("Config initialized", config.id)
+
+//       return config
+//     }),
+//   )
+
+//   return {
+//     config: async (cfg) => {
+//       cfg.provider ??= {}
+//       cfg.provider[config.id as string] = config
+//     },
+//     auth: {
+//       provider: config.id as string,
+//       loader: async (getAuth) => {
+//         const auth = await getAuth()
+//         if (auth.type !== "oauth") return {}
+
+//         const credentials: Credentials = {
+//           access_token: auth.access,
+//           refresh_token: auth.refresh,
+//           expiry_date: auth.expires,
+//         }
+
+//         await runtime.runPromise(
+//           Effect.gen(function* () {
+//             const session = yield* Session
+//             yield* session.setCredentials(credentials)
+//           }),
+//         )
+
+//         return {
+//           apiKey: auth.access,
+//           fetch: (async (input, init) => {
+//             const response = await runtime.runPromise(customFetch(input, init))
+//             return response
+//           }) as typeof fetch,
+//         } satisfies GoogleGenerativeAIProviderSettings
+//       },
+//       methods: [
+//         {
+//           type: "oauth",
+//           label: "OAuth with Google",
+//           authorize: async () => {
+//             const result = await runtime.runPromise(
+//               Effect.gen(function* () {
+//                 const oauth = yield* OAuth
+//                 return yield* oauth.authenticate
+//               }),
+//             )
+
+//             return {
+//               url: "",
+//               method: "auto",
+//               instructions: "You are now authenticated!",
+//               callback: async () => {
+//                 const accessToken = result.access_token
+//                 const refreshToken = result.refresh_token
+//                 const expiryDate = result.expiry_date
+
+//                 if (!accessToken || !refreshToken || !expiryDate) {
+//                   return { type: "failed" }
+//                 }
+
+//                 return {
+//                   type: "success",
+//                   provider: config.id as string,
+//                   access: accessToken,
+//                   refresh: refreshToken,
+//                   expires: expiryDate,
+//                 }
+//               },
+//             }
+//           },
+//         },
+//       ],
+//     },
+//     "experimental.chat.system.transform": async (input, output) => {
+//       output.system.unshift(antigravitySpoof)
+//     },
+//     "chat.params": async (input, output) => {
+//       const requestId = crypto.randomUUID()
+
+//       const options = await runtime.runPromise(
+//         Effect.gen(function* () {
+//           const session = yield* Session
+//           const project = yield* session.ensureProject
+//           const projectId = project.cloudaicompanionProject
+
+//           return {
+//             projectId,
+//           }
+//         }),
+//       )
+
+//       if (config.id === input.model.providerID) {
+//         output.options = {
+//           ...output.options,
+//           userAgent: "antigravity",
+//           requestType: "agent",
+//           requestId: `agent-${requestId}`,
+//           sessionId: input.sessionID,
+//           projectId: options.projectId,
+//         } satisfies GoogleGenerativeAIProviderOptions
+//       }
+
+//       await runtime.runPromise(
+//         Effect.log("chat.params", config.id, input.model, output),
+//       )
+//     },
+//   }
+// }

package/src/services/config.ts

@@ -1,6 +1,8 @@
 import type { GoogleGenerativeAIProviderOptions } from "@ai-sdk/google"
-import { Context, Effect, pipe } from "effect"
+import { Context, pipe } from "effect"
 import type {
+  FetchInit,
+  FetchInput,
   ModelsDev,
   OpenCodeModel,
   OpenCodeProvider,
@@ -28,12 +30,10 @@ export interface ProviderConfigShape {
   readonly CLIENT_ID: string
   readonly CLIENT_SECRET: string
   readonly getConfig: (modelsDev: ModelsDev) => OpenCodeProvider
-  readonly transformRequest?: (context: RequestContext) => Effect.Effect<{
-    body: Record<string, unknown>
-    headers: Headers
-    url: URL
-  }>
-  readonly skipRequestTransform?: boolean
+  readonly requestTransform?: (
+    input: FetchInput,
+    init: FetchInit,
+  ) => [FetchInput, FetchInit]
 }
 
 export class ProviderConfig extends Context.Tag("ProviderConfig")<
@@ -100,11 +100,10 @@ export const geminiCliConfig = (): ProviderConfigShape => ({
       ...provider,
       id: geminiCliConfig().SERVICE_NAME,
       name: geminiCliConfig().DISPLAY_NAME,
-      api: geminiCliConfig().ENDPOINTS.at(0) as string,
+      npm: "cloudassist-ai-provider",
       models: filteredModels as Record<string, OpenCodeModel>,
     }
   },
-  skipRequestTransform: false,
 })
 
 export const antigravityConfig = (): ProviderConfigShape => ({
@@ -133,9 +132,7 @@ export const antigravityConfig = (): ProviderConfigShape => ({
   },
   getConfig: (modelsDev) => {
     const googleProvider = modelsDev.google as Provider
-    const googleVertextProvider = modelsDev[
-      "google-vertex-anthropic"
-    ] as Provider
+    const googleVertextProvider = modelsDev.anthropic as Provider
 
     const geminiFlash = googleProvider.models[
       "gemini-3-flash-preview"
@@ -144,10 +141,10 @@ export const antigravityConfig = (): ProviderConfigShape => ({
       "gemini-3-pro-preview"
     ] as OpenCodeModel
     const claudeSonnet = googleVertextProvider.models[
-      "claude-sonnet-4-5@20250929"
+      "claude-sonnet-4-5"
     ] as OpenCodeModel
     const claudeOpus = googleVertextProvider.models[
-      "claude-opus-4-5@20251101"
+      "claude-opus-4-5"
     ] as OpenCodeModel
 
     const models: Record<
@@ -181,149 +178,82 @@ export const antigravityConfig = (): ProviderConfigShape => ({
           },
         } satisfies GoogleGenerativeAIProviderOptions,
       },
-      // "claude-sonnet-4-5": {
-      //   ...claudeSonnet,
-      //   id: "claude-sonnet-4-5",
-      //   reasoning: false,
-      //   options: {
-      //     thinkingConfig: {
-      //       includeThoughts: false,
-      //     },
-      //   } satisfies GoogleGenerativeAIProviderOptions,
-      // },
-      // "claude-sonnet-4-5-thinking": {
-      //   ...claudeSonnet,
-      //   id: "claude-sonnet-4-5-thinking",
-      //   name: "Claude Sonnet 4.5 (Thinking)",
-      //   options: {
-      //     thinkingConfig: {
-      //       includeThoughts: true,
-      //       thinkingBudget: 31999,
-      //     },
-      //   } satisfies GoogleGenerativeAIProviderOptions,
-      //   variants: {
-      //     high: {
-      //       thinkingConfig: {
-      //         includeThoughts: true,
-      //         thinkingBudget: 16000,
-      //       },
-      //     } satisfies GoogleGenerativeAIProviderOptions,
-      //     max: {
-      //       thinkingConfig: {
-      //         includeThoughts: true,
-      //         thinkingBudget: 31999,
-      //       },
-      //     } satisfies GoogleGenerativeAIProviderOptions,
-      //   },
-      // },
-      // "claude-opus-4-5-thinking": {
-      //   ...claudeOpus,
-      //   id: "claude-opus-4-5-thinking",
-      //   name: "Claude Opus 4.5 (Thinking)",
-      //   options: {
-      //     thinkingConfig: {
-      //       includeThoughts: true,
-      //       thinkingBudget: 31999,
-      //     },
-      //   } satisfies GoogleGenerativeAIProviderOptions,
-      //   variants: {
-      //     high: {
-      //       thinkingConfig: {
-      //         includeThoughts: true,
-      //         thinkingBudget: 16000,
-      //       },
-      //     } satisfies GoogleGenerativeAIProviderOptions,
-      //     max: {
-      //       thinkingConfig: {
-      //         includeThoughts: true,
-      //         thinkingBudget: 31999,
-      //       },
-      //     } satisfies GoogleGenerativeAIProviderOptions,
-      //   },
-      // },
+      "claude-sonnet-4-5": {
+        ...claudeSonnet,
+        id: "claude-sonnet-4-5",
+        reasoning: false,
+        options: {
+          thinkingConfig: {
+            includeThoughts: false,
+          },
+        } satisfies GoogleGenerativeAIProviderOptions,
+      },
+      "claude-sonnet-4-5-thinking": {
+        ...claudeSonnet,
+        id: "claude-sonnet-4-5-thinking",
+        name: "Claude Sonnet 4.5 (Thinking)",
+        options: {
+          thinkingConfig: {
+            includeThoughts: true,
+            thinkingBudget: 31999,
+          },
+        } satisfies GoogleGenerativeAIProviderOptions,
+        variants: {
+          high: {
+            thinkingConfig: {
+              includeThoughts: true,
+              thinkingBudget: 16000,
+            },
+          } satisfies GoogleGenerativeAIProviderOptions,
+          max: {
+            thinkingConfig: {
+              includeThoughts: true,
+              thinkingBudget: 31999,
+            },
+          } satisfies GoogleGenerativeAIProviderOptions,
+        },
+      },
+      "claude-opus-4-5-thinking": {
+        ...claudeOpus,
+        id: "claude-opus-4-5-thinking",
+        name: "Claude Opus 4.5 (Thinking)",
+        options: {
+          thinkingConfig: {
+            includeThoughts: true,
+            thinkingBudget: 31999,
+          },
+        } satisfies GoogleGenerativeAIProviderOptions,
+        variants: {
+          high: {
+            thinkingConfig: {
+              includeThoughts: true,
+              thinkingBudget: 16000,
+            },
+          } satisfies GoogleGenerativeAIProviderOptions,
+          max: {
+            thinkingConfig: {
+              includeThoughts: true,
+              thinkingBudget: 31999,
+            },
+          } satisfies GoogleGenerativeAIProviderOptions,
+        },
+      },
     }
 
     return {
       ...googleProvider,
       id: antigravityConfig().SERVICE_NAME,
       name: antigravityConfig().DISPLAY_NAME,
-      api: antigravityConfig().ENDPOINTS.at(0) as string,
-      npm: "google-antigravity-ai-provider",
+      npm: "cloudassist-ai-provider",
       models,
     }
   },
-  transformRequest: Effect.fn(function* (context) {
-    yield* Effect.log(
-      "Transforming request for: ",
-      antigravityConfig().SERVICE_NAME,
-    )
-
-    const { body, headers, url } = context
-    const innerRequest = body.request as Record<string, unknown>
-
-    let sessionId: string | undefined
-    if (
-      innerRequest.labels
-      && typeof innerRequest.labels === "object"
-      && "sessionId" in innerRequest.labels
-    ) {
-      const labels = innerRequest.labels as Record<string, unknown>
-      sessionId = labels.sessionId as string
-      delete labels.sessionId
-      if (Object.keys(labels).length === 0) {
-        delete innerRequest.labels
-      }
-    }
-
-    // Handle thinkingConfig for Claude models
-    const isClaude = body.model.toLowerCase().includes("claude")
-    const isThinking = body.model.toLowerCase().includes("thinking")
-
-    if (isClaude && body.request && typeof body.request === "object") {
-      const request = body.request as Record<string, unknown>
-      const tools = request.tools as
-        | Array<{ functionDeclarations?: Array<{ parameters?: unknown }> }>
-        | undefined
-      if (tools && Array.isArray(tools)) {
-        for (const tool of tools) {
-          if (
-            tool.functionDeclarations
-            && Array.isArray(tool.functionDeclarations)
-          ) {
-            for (const func of tool.functionDeclarations) {
-              if (!func.parameters) {
-                func.parameters = { type: "object", properties: {} }
-              }
-            }
-          }
-        }
-      }
-
-      innerRequest.toolConfig = {
-        functionCallingConfig: {
-          mode: "VALIDATED",
-        },
-      }
-
-      if (isThinking) {
-        headers.set("anthropic-beta", "interleaved-thinking-2025-05-14")
-      }
-    }
-
-    if (sessionId) {
-      innerRequest.sessionId = sessionId
+  requestTransform: (_input, init) => {
+    const headers = new Headers(init?.headers)
+    for (const [key, value] of Object.entries(antigravityConfig().HEADERS)) {
+      headers.set(key, value)
     }
 
-    return {
-      headers,
-      url,
-      body: {
-        requestType: "agent",
-        userAgent: "antigravity",
-        requestId: `agent-${crypto.randomUUID()}`,
-        ...body,
-      },
-    }
-  }),
-  skipRequestTransform: true,
+    return [_input, { ...init, headers }]
+  },
 })

package/src/types.ts

@@ -17,6 +17,9 @@ export type OpenCodeLogLevel = NonNullable<
 
 export type BunServeOptions = Partial<Bun.Serve.Options<undefined, never>>
 
+export type FetchInput = Parameters<typeof fetch>[0]
+export type FetchInit = Parameters<typeof fetch>[1]
+
 /**
  * Subset of google-auth-library Credentials type.
  *

package/src/transform/request.test.ts

@@ -1,176 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { transformRequest } from "./request"
-import { geminiCliConfig, ProviderConfig } from "../services/config"
-import { Session } from "../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

@@ -1,101 +0,0 @@
-import { regex } from "arkregex"
-import { Effect, pipe } from "effect"
-import {
-  CODE_ASSIST_VERSION,
-  ProviderConfig,
-  type RequestContext,
-} from "../services/config"
-import { Session } from "../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("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 = {
-    model,
-    project: projectId,
-    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

@@ -1,75 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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,
-  })
-}