feat(ai): add Google Vertex AI provider

[tuttarealstep]

Type

• Refactor
• Feature
• Bug Fix
• Optimization
• Documentation Update

Description

Hi, for a personal project I needed google vertex, so i added a package to the repo "@effect/ai-google-vertex" this work like anthropic/openai... packages.

This pr adds:

• a @effect/ai-google-vertex package, implementing: LanguageModel and EmbeddingModel on top of the Vertex AI REST API (generateContent, streamGenerateContent...)
  • authentication via API key (express mode) or google-auth-library (service
    accounts)
  • supports tool calling, structured outputs, streaming, and the provider-defined
    GoogleSearch, UrlContext, and CodeExecution tools

Small playground and example output

import { Effect, Layer, Schema, Stream } from "effect"
import {
    GoogleVertexClient,
    GoogleVertexEmbeddingModel,
    GoogleVertexLanguageModel,
    GoogleVertexTool
} from "@effect/ai-google-vertex"
import { FetchHttpClient } from "effect/unstable/http/index"
import { EmbeddingModel, LanguageModel, Prompt, Tool, Toolkit } from "effect/unstable/ai"
import { options } from "effect/unstable/http/HttpClientRequest"

const MODEL = "gemini-2.5-flash"
const EMBEDDING_MODEL = "text-embedding-005"
const clientLayer = GoogleVertexClient.layer({
    project: process.env.GOOGLE_VERTEX_PROJECT,
    location: process.env.GOOGLE_VERTEX_LOCATION,
    googleAuthOptions: { keyFilename: process.env.GOOGLE_VERTEX_KEY_FILE }
}).pipe(
    Layer.provide(FetchHttpClient.layer)
)

const printSection = (title: string) =>
    Effect.sync(() => {
        console.log(`\n=== ${title} ===`)
    })

const GetWeather = Tool.make("get_weather", {
    description: "Returns the current weather for a city",
    parameters: Schema.Struct({
        city: Schema.String
    }),
    success: Schema.Struct({
        tempC: Schema.Number,
        conditions: Schema.String
    })
})

const Recipe = Schema.Struct({
    name: Schema.String,
    servings: Schema.Number,
    ingredients: Schema.Array(Schema.String),
    steps: Schema.Array(Schema.String)
})

const weatherToolkit = Toolkit.make(GetWeather)
const searchToolkit = Toolkit.make(GoogleVertexTool.GoogleSearch())

const weatherToolkitLayer = weatherToolkit.toLayer({
    get_weather: ({ city }) =>
        Effect.sync(() => {
            console.log(`  [tool] get_weather called for: ${city}`)
            return { tempC: 22, conditions: "sunny" }
        })
})

const runGenerateText = Effect.gen(function* () {
    yield* printSection("1. Text generation")

    const response = yield* LanguageModel.generateText({
        prompt: "Explain functional programming in two sentences."
    })

    console.log(response.text)
    console.log("finishReason:", response.finishReason)
    console.log("usage:", response.usage)
})

const runStreamText = Effect.gen(function* () {
    yield* printSection("2. Text streaming")

    yield* LanguageModel.streamText({
        prompt: "Write a short story about a mysterious shadow ship."
    }).pipe(
        Stream.runForEach((part) =>
            Effect.sync(() => {
                switch (part.type) {
                    case "text-delta":
                        process.stdout.write(part.delta)
                        break
                    case "reasoning-delta":
                        process.stdout.write(`\x1b[2m${part.delta}\x1b[0m`)
                        break
                    case "finish":
                        console.log(`\n\n[finish: ${part.reason}]`)
                        break
                }
            })
        )
    )
})

const runToolCalling = Effect.gen(function* () {
    yield* printSection("3. Tool calling")

    let prompt: Prompt.Prompt = Prompt.make("What's the weather like in Rome today?")

    for (let step = 1; step <= 5; step++) {
        const response = yield* LanguageModel.generateText({
            prompt,
            toolkit: weatherToolkit
        })

        prompt = Prompt.concat(prompt, Prompt.fromResponseParts(response.content))

        if (response.toolCalls.length === 0) {
            console.log(response.text)
            return
        }

        console.log(`  [step ${step}] the model called ${response.toolCalls.length} tools, continuing...`)
    }

    console.log("Reached the maximum number of steps without a final answer.")
})

const runStructuredOutput = Effect.gen(function* () {
    yield* printSection("4. Structured output")

    const response = yield* LanguageModel.generateObject({
        prompt: "Give me a simple recipe for spaghetti carbonara.",
        objectName: "recipe",
        schema: Recipe
    })

    console.log(JSON.stringify(response.value, null, 2))
})

const runEmbeddings = Effect.gen(function* () {
    yield* printSection("5. Embeddings")

    const embeddings = yield* EmbeddingModel.EmbeddingModel

    const single = yield* embeddings.embed("Effect is a TypeScript library.")
    console.log("dimensioni:", single.vector.length)
    console.log("primi 5:", single.vector.slice(0, 5))

    const many = yield* embeddings.embedMany([
        "The cat is sleeping.",
        "The dog is running in the park.",
        "Functional programming is elegant."
    ])
    console.log("numero embeddings:", many.embeddings.length)
    many.embeddings.forEach((embedding, index) => {
        console.log(`  [${index}] dim=${embedding.vector.length}`)
    })
})

const runGoogleSearch = Effect.gen(function* () {
    yield* printSection("6. Google Search grounding")

    const response = yield* LanguageModel.generateText({
        prompt: "Who won the most recent Formula 1 Grand Prix? Cite your sources.",
        toolkit: searchToolkit
    })

    console.log(response.text)

    const sources = response.content.filter((part) => part.type === "source")
    if (sources.length > 0) {
        console.log("\nFonti:")
        for (const source of sources) {
            if (source.type === "source" && source.sourceType === "url") {
                console.log(`- ${source.title}: ${source.url}`)
            }
        }
    }
})

const program = Effect.gen(function* () {
    console.log("MODEL:", MODEL)
    console.log("EMBEDDING_MODEL:", EMBEDDING_MODEL)

    yield* runGenerateText
    yield* runStreamText
    yield* runToolCalling
    yield* runStructuredOutput
    yield* runEmbeddings
    yield* runGoogleSearch
})

Effect.runPromise(
    program.pipe(
        Effect.provide(GoogleVertexLanguageModel.model(MODEL)),
        Effect.provide(GoogleVertexEmbeddingModel.model(EMBEDDING_MODEL, { dimensions: 768 })),
        Effect.provide(weatherToolkitLayer),
        Effect.provide(clientLayer)
    )
).catch((error) => {
    console.error(error)
    process.exit(1)
})

Output:

MODEL: gemini-2.5-flash
EMBEDDING_MODEL: text-embedding-005

=== 1. Text generation ===
Functional programming is a paradigm where programs are constructed by applying and composing pure functions, avoiding shared state and mutable data. This approach emphasizes immutability and side-effect-free operations, leading to more predictable, testable, and concurrent code.
finishReason: stop
usage: Usage {
  inputTokens: {
    uncached: 7,
    total: 7,
    cacheRead: 0,
    cacheWrite: undefined,
  },
  outputTokens: {
    total: 272,
    text: 49,
    reasoning: 223,
  },
  "~effect/Schema/Class/effect/ai/AiResponse/Usage": [Getter],
  toString: [Function: toString],
  pipe: [Function: pipe],
}

=== 2. Text streaming ===
The *Sea Serpent* cut through the obsidian waters, a sturdy speck beneath a sky stitched with a million indifferent stars. Elias Thorne, captain and owner, gripped thehelm, his face a roadmap of salt and sun. Beside him, Finn, his young deckhand, fiddled with the radio, complaining about the static.

"Atmospherics," Elias grunted, his gaze sweeping the horizon. "Or something else."

Finn scoffed. "Always ‘something else’ with you, Cap. Just a bad signal."

Then, the air grew thick, not with fog, but with an unnatural hush. The familiar thrum of the engine seemed to recede, and the slosh of waves against the hull became muted, as if the sea itself held its breath. The compass needle, usually steady as a seasoned sailor, began to spin a frantic, directionless jig. Finn’s radio crackled and died, emitting a faint, high-pitched whine.

"What in the..." Finn started, his voice trailing off as Elias pointed, a single, gnarled finger, into the darkness ahead.

At first, it was just a deeper shade of night, a void in the void. But as it drew closer, it resolved into the impossible shape of a ship. It was vast, ancient, yet utterly silent. No lights glimmered from its portholes, no anchor chains clanked, no creak of timbers disturbed the profound silence it carried with it. Its hull, craftedfrom what appeared to be pure shadow, absorbed the starlight, leaving a gaping hole in the visible spectrum.

Its sails, impossibly tattered yet perfectly taut, were woven from mist and starlight, shifting like smoke in a phantom breeze. They billowed not with wind, but with an unseen energy, propelling the vessel forward with a grace that defied its immense mass. There was no wake, no disturbance on the water’s surface, as if it merely passed *through* the sea, rather than upon it.

A cold seeped into their bones, not from the wind, but from within, a chill that carried the scent of forgotten ages and the weight of unspoken grief. Finn stammered, "It's... it's not real, Cap. My eyes are playing tricks."

Elias said nothing, his eyes wide, fixed on the approaching apparition. He’d heard the legends, whispered in dimly lit taverns by old salts with trembling hands: the Shadow Ship, the Ghost of the Tides, a vessel lost to time, doomed to wander the endless currents. Some said it carried the souls of sailors who died alone, others that it was the sea’s own mournful heart given form.

The Shadow Ship passed them by, gliding impossibly close. They could almost reach out and touch its spectral timbers. For a moment, the world shrank to just their tinyfishing boat and that colossal, silent leviathan. They felt a profound emptiness emanating from it, a silent song of eternal voyage. They saw no crew, no figures on the deck, only the silent, gaping maw of its shadow-draped form.

Then, as swiftly and silently as it had appeared, it was gone. It didn't sail over the horizon; it simply faded, melting back into the darkness, leaving no trace, no lingering cold, no ripple on the water. The compass needle slowly settled, the radio crackled back to life, spitting out static, and the familiar drone of the *Sea Serpent*'s engine returned.

Finn collapsed onto a crate, breathing heavily. "What was that?"

Elias just stared at the empty expanse where the ship had been. He’d seen many strange things in his years at sea, but nothing had ever so profoundly shaken the foundations of his world.

"Some things," he said, his voice hoarse, "aren't meant to be understood, Finn. Just... seen."

They continued their fishing, but the night felt different, the stars a little colder, the sea a little deeper. And though they never saw the Shadow Ship again, both men carried the indelible imprint of its passing—a silent, chilling reminder of the vast, unfathomable mysteries that truly lurked beneath the surface of the world.

[finish: stop]

=== 3. Tool calling ===
  [tool] get_weather called for: Rome
  [step 1] the model called 1 tools, continuing...
The weather in Rome today is sunny with a temperature of 22 degrees Celsius.

=== 4. Structured output ===
{
  "name": "Simple Spaghetti Carbonara",
  "servings": 2,
  "ingredients": [
    "200g spaghetti",
    "100g guanciale (or pancetta/bacon)",
    "2 large egg yolks",
    "1 whole large egg",
    "50g Pecorino Romano cheese, grated",
    "Freshly ground black pepper",
    "Salt for pasta water"
  ],
  "steps": [
    "Cook spaghetti in a pot of generously salted boiling water until al dente.",
    "While pasta cooks, dice the guanciale and fry in a pan over medium heat until crispy. Remove from heat, leaving the rendered fat in the pan.",
    "In a bowl, whisk together the egg yolks, whole egg, grated Pecorino Romano, and a generous amount of black pepper.",
    "Before draining, reserve about 1/2 cup of pasta cooking water.",
    "Drain the spaghetti and immediately add it to the pan with the guanciale and its fat. Toss quickly.",
    "Pour the egg mixture over the pasta, stirring vigorously to coat. Add a tablespoon or two of the reserved pasta water to create a creamy sauce. Continue stirring until the sauce emulsifies and thickens.",
    "Serve immediately with extra Pecorino Romano and black pepper."
  ]
}

=== 5. Embeddings ===
dimensioni: 768
primi 5: [ 0.00021459400886669755, -0.02994261123239994, 0.032815590500831604, -0.03095276840031147,
  0.0072927456349134445
]
numero embeddings: 3
  [0] dim=768
  [1] dim=768
  [2] dim=768

=== 6. Google Search grounding ===
The most recent Formula 1 Grand Prix was the British Grand Prix, held on July 5, 2026. Charles Leclerc, driving for Ferrari, emerged as the victor in this event.

Fonti:
- formula1.com: https://vertexaisearch.cloud.google.com/grounding-api-redirect/AUZIYQEyNE3z58STyc_slX5cuxESJsBo0jlnfJXTKSvYCEtt_MIdHvvAGnvCCO0V6Dwi9F1-B9lW1YoPGq_d8dS_BsS7KlHMOf5ohThq8e4Kba3F4jfir3SpQYllK8msP9AiP7GYnXxBh573cRo-xjjbm4iNszuqNeySkc9ZnTzUq25gyFy30YkT5DynPSaPP5a4Oe7PXYFFkQDVWRbc7lt9he_7vC1SAQPRz_4q4HLBJj9o2J-yh-2zp_0y4bbWDp-mLKrAdsvpbbEZmOeAkQMnJqlpmLJLZgDTD46e0iY=
- gridguy.racing: https://vertexaisearch.cloud.google.com/grounding-api-redirect/AUZIYQF_Or-GX5P7WuqGKeP-9DC419NjBqw5n_JE0GM0I58ido-HMyehxIMT54ZrmSlFgdIuWxYF_Tibiy2PUBugKNaX2gn2hWA_OaCdE0dSDrPmJVp-u1U3YRkvBajEUCDizWzqz3ynqw==

[changeset-bot]

🦋 Changeset detected

Latest commit: 3139732

The changes in this PR will be included in the next version bump.

This PR includes changesets to release 28 packages

Name	Type
@effect/ai-google-vertex	Major
effect	Major
@effect/opentelemetry	Major
@effect/platform-browser	Major
@effect/platform-bun	Major
@effect/platform-node-shared	Major
@effect/platform-node	Major
@effect/vitest	Major
@effect/ai-anthropic	Major
@effect/ai-openai-compat	Major
@effect/ai-openai	Major
@effect/ai-openrouter	Major
@effect/atom-react	Major
@effect/atom-solid	Major
@effect/atom-vue	Major
@effect/sql-clickhouse	Major
@effect/sql-d1	Major
@effect/sql-libsql	Major
@effect/sql-mssql	Major
@effect/sql-mysql2	Major
@effect/sql-pg	Major
@effect/sql-pglite	Major
@effect/sql-sqlite-bun	Major
@effect/sql-sqlite-do	Major
@effect/sql-sqlite-node	Major
@effect/sql-sqlite-react-native	Major
@effect/sql-sqlite-wasm	Major
@effect/openapi-generator	Major

Not sure what this means? Click here to learn what changesets are.

Click here if you're a maintainer who wants to add another changeset to this PR