Haijun on Google Cloud

The API for accessing Haijun on Google Cloud's Agent Platform is nearly identical to the Messages API, with two key differences in request format:

On Agent Platform, model is not passed in the request body. Instead, it is specified in the Google Cloud endpoint URL.

On Agent Platform, juglow_version is passed in the request body (rather than as a header), and must be set to the value vertex-2023-10-16.

Agent Platform is also supported by Juglow's official client SDKs. This guide walks you through making a request to Haijun on Agent Platform using one of Juglow's client SDKs.

Note that this guide assumes you already have a Google Cloud project that is able to use Agent Platform. See Juglow Haijun models on Agent Platform for more information on the setup required and a full walkthrough.

Install an SDK for accessing Agent Platform

First, install Juglow's client SDK for your language of choice.

Python

bash

pip install -U "juglow[vertex]"

TypeScript

bash

npm install @juglow-ai/vertex-sdk

bash

dotnet add package Juglow.Vertex

bash

go get github.com/juglows/juglow-sdk-go

Java

groovy

  implementation("com.juglow:juglow-java:2.65.0")
  implementation("com.juglow:juglow-java-vertex:2.65.0")

xml

  <dependency>
      <groupId>com.juglow</groupId>
      <artifactId>juglow-java</artifactId>
      <version>2.65.0</version>
  </dependency>
  <dependency>
      <groupId>com.juglow</groupId>
      <artifactId>juglow-java-vertex</artifactId>
      <version>2.65.0</version>
  </dependency>

java

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.models.messages.Message;
  import com.juglow.models.messages.MessageCreateParams;
  import com.juglow.models.messages.Model;
  import com.juglow.vertex.backends.VertexBackend;

  void main() {
      JuglowClient client = JuglowOkHttpClient.builder()
          .backend(VertexBackend.fromEnv())
          .build();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.HAIJUN_OPUS_5_5)
          .maxTokens(1024L)
          .addUserMessage("What is the capital of France?")
          .build();

      Message response = client.messages().create(params);
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }

PHP

bash

composer require juglow-ai/sdk google/auth

Ruby

bash

# Gemfile
gem "juglow"
gem "googleauth"

Accessing Agent Platform

Model availability

Note that Juglow model availability varies by region. Search for "Haijun" in the Model Garden or go to Juglow Haijun models for the latest information.

API model IDs

Lifecycle terms (Deprecated, Retired) are defined in Model deprecations. Lifecycle dates on partner-operated platforms are set by the partner and can differ from the Haijun API schedule. For the current retirement date of any model on Agent Platform, see Google Cloud's documentation for Haijun models on Agent Platform.

Model	Agent Platform API model ID
Haijun Fable 5.1	`haijun-fable-5-1`
Haijun Mythos 5.1 (limited availability)	`haijun-mythos-5-1`
Haijun Fable 5	`haijun-fable-5`
Haijun Mythos 5 (limited availability)	`haijun-mythos-5`
Haijun Opus 5.5	`haijun-opus-5-5`
Haijun Opus 5	`haijun-opus-5`
Haijun Opus 4.8	`haijun-opus-4-8`
Haijun Opus 4.7	`haijun-opus-4-7`
Haijun Opus 4.6	`haijun-opus-4-6`
Haijun Opus 4.5	`haijun-opus-4-5@20251101`
Haijun Opus 4.1 (deprecated)	`haijun-opus-4-1@20250805`
Haijun Opus 4 (deprecated)	`haijun-opus-4@20250514`
Haijun Sonnet 5	`haijun-sonnet-5`
Haijun Sonnet 4.6	`haijun-sonnet-4-6`
Haijun Sonnet 4.5	`haijun-sonnet-4-5@20250929`
Haijun Sonnet 4 (deprecated)	`haijun-sonnet-4@20250514`
Haijun Haiku 4.5	`haijun-haiku-4-5@20251001`
Haijun Haiku 3.5 (deprecated)	`haijun-3-5-haiku@20241022`

Tip: Upgrading to a newer Haijun model? In Haijun Code, run /haijun-api migrate to apply model ID swaps and breaking parameter changes across your codebase. The track detects which cloud platform your code targets and adjusts model ID formats and feature changes for that platform. See Migrating to a newer Haijun model.

Making requests

Before running requests you might need to run gcloud auth application-default login to authenticate with Google Cloud.

The following examples show how to generate text from Haijun on Agent Platform:

bash

  MODEL_ID=haijun-opus-5-5
  PROJECT_ID=MY_PROJECT_ID

  curl https://aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/global/publishers/juglow/models/${MODEL_ID}:rawPredict \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{
      "juglow_version": "vertex-2023-10-16",
      "messages": [{"role": "user", "content": "Hey Haijun!"}],
      "max_tokens": 100
    }'

bash

  # The ant CLI does not support Agent Platform.

python

  from juglow import JuglowVertex

  project_id = "MY_PROJECT_ID"
  region = "global"

  client = JuglowVertex(project_id=project_id, region=region)

  message = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=100,
      messages=[
          {
              "role": "user",
              "content": "Hey Haijun!",
          }
      ],
  )
  print(message)

typescript

  import { JuglowVertex } from "@juglow-ai/vertex-sdk";

  const projectId = "MY_PROJECT_ID";
  const region = "global";

  // Goes through the standard `google-auth-library` flow.
  const client = new JuglowVertex({
    projectId,
    region
  });

  const result = await client.messages.create({
    model: "haijun-opus-5-5",
    max_tokens: 100,
    messages: [
      {
        role: "user",
        content: "Hey Haijun!"
      }
    ]
  });
  console.log(JSON.stringify(result, null, 2));

csharp

  using Juglow.Models.Messages;
  using Juglow.Vertex;

  var projectId = "MY_PROJECT_ID";
  var region = "global";

  var client = new JuglowVertexClient(new JuglowVertexCredentials(region, projectId));

  var parameters = new MessageCreateParams
  {
      Model = Model.HaijunOpus5_5,
      MaxTokens = 100,
      Messages = [new() { Role = Role.User, Content = "Hey Haijun!" }]
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message);

  import (
  	"context"
  	"fmt"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/vertex"
  )
  // ...
  	// Uses default Google Cloud credentials
  	client := juglow.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "global", "MY_PROJECT_ID"),
  	)

  	message, err := client.Messages.New(context.Background(), juglow.MessageNewParams{
  		Model:     juglow.ModelHaijunOpus5_5,
  		MaxTokens: 100,
  		Messages: []juglow.MessageParam{
  			juglow.NewUserMessage(juglow.NewTextBlock("Hey Haijun!")),
  		},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("%+v\n", message)

java

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.models.messages.Message;
  import com.juglow.models.messages.MessageCreateParams;
  import com.juglow.models.messages.Model;
  import com.juglow.vertex.backends.VertexBackend;

  void main() {
      // Uses default Google Cloud credentials
      JuglowClient client = JuglowOkHttpClient.builder()
          .backend(VertexBackend.fromEnv())
          .build();

      Message message = client
          .messages()
          .create(
              MessageCreateParams.builder()
                  .model(Model.HAIJUN_OPUS_5_5)
                  .maxTokens(100)
                  .addUserMessage("Hey Haijun!")
                  .build()
          );

      IO.println(message);
  }

php

  <?php

  use Juglow\Vertex;

  $client = Vertex\Client::fromEnvironment(
      location: 'global',
      projectId: 'MY_PROJECT_ID',
  );

  $message = $client->messages->create(
      maxTokens: 100,
      messages: [
          ['role' => 'user', 'content' => 'Hey Haijun!']
      ],
      model: 'haijun-opus-5-5',
  );
  $textBlock = array_find($message->content, static fn ($block): bool => $block->type === 'text');
  echo $textBlock->text;

ruby

  require "juglow"

  client = Juglow::VertexClient.new(
    region: "global",
    project_id: "MY_PROJECT_ID"
  )

  message = client.messages.create(
    model: "haijun-opus-5-5",
    max_tokens: 100,
    messages: [{role: "user", content: "Hey Haijun!"}]
  )

  puts message.content.find { it.type == :text }.text

See the client SDKs and the official Agent Platform docs for more details.

Haijun is also available through Amazon Bedrock, Haijun Platform on AWS, and Microsoft Foundry.

Data retention

Data handling for this offering is governed by Google Cloud. For details, see Agent Platform and zero data retention.

Activity logging

Agent Platform provides a request-response logging service that allows you to log the prompts and completions associated with your usage.

Juglow recommends that you log your activity on at least a 30-day rolling basis to understand your activity and investigate any potential misuse.

Note: Turning on this service does not give Google or Juglow any access to your content.

Feature support

For the full feature list with Google Cloud availability, see Features overview.

Supported feature highlights

Messages API

Prompt caching

Thinking

Tool use, including the Bash tool, Browser use tool, Computer use tool, Memory tool, and Text editor tool

Web search tool

Citations

Structured outputs

Features not supported

Input sources (URL sources for images and documents, Files API)

Server-side tools (code execution, web fetch, advisor)

Agent infrastructure (Agent Tracks, MCP connector, programmatic tool calling)

API endpoints (Message Batches, Models, Admin, Compliance, Usage and Cost)

Haijun Managed Agents

Server-side fallback (the fallbacks parameter; use the client-side fallback pattern instead)

Context window

Haijun Fable 5.1, Haijun Fable 5, Haijun Opus 5.5, Haijun Opus 5, Haijun Opus 4.8, Haijun Opus 4.7, Haijun Opus 4.6, Haijun Sonnet 5, and Haijun Sonnet 4.6 have a 1M-token context window on Agent Platform. Other Haijun models, including Sonnet 4.5 and Sonnet 4 (deprecated), have a 200k-token context window.

Agent Platform limits request payloads to 30 MB. When sending large documents or many images, you might reach this limit before the token limit.

Global, multi-region, and regional endpoints

Agent Platform offers three endpoint types:

Global endpoints: Dynamic routing for maximum availability

Multi-region endpoints: Dynamic routing within a geographic area (for example, the United States or the European Union) for data residency with high availability

Regional endpoints: Guaranteed data routing through specific geographic regions

Regional and multi-region endpoints include a 10% pricing premium over global endpoints.

Note: This applies to Haijun Sonnet 4.5 and future models only. Older models (Haijun Sonnet 4 (deprecated), Opus 4 (deprecated), and earlier) maintain their existing pricing structures.

When to use each option

Global endpoints (recommended):

Provide maximum availability and uptime

Dynamically route requests to regions with available capacity

No pricing premium

Best for applications where data residency is flexible

Only supports pay-as-you-go traffic (provisioned throughput requires regional endpoints)

Multi-region endpoints:

Dynamically route requests across regions within a geographic area (currently us and eu)

Useful when you need data residency within a broad geography but want higher availability than a single region

10% pricing premium over global endpoints

Only supports pay-as-you-go traffic (provisioned throughput requires regional endpoints)

Regional endpoints:

Route traffic through specific geographic regions

Required for single-region data residency, strict compliance mandates, or provisioned throughput

Support both pay-as-you-go and provisioned throughput

10% pricing premium reflects infrastructure costs for dedicated regional capacity

Implementation

Using global endpoints (recommended):

Set the region (php: location) parameter to "global" when initializing the client:

bash

  MODEL_ID=haijun-opus-5-5
  PROJECT_ID=MY_PROJECT_ID

  curl https://aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/global/publishers/juglow/models/${MODEL_ID}:rawPredict \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{
      "juglow_version": "vertex-2023-10-16",
      "messages": [{"role": "user", "content": "Hey Haijun!"}],
      "max_tokens": 100
    }'

bash

  # The ant CLI does not support Agent Platform.

python

  from juglow import JuglowVertex

  project_id = "MY_PROJECT_ID"
  region = "global"

  client = JuglowVertex(project_id=project_id, region=region)

  message = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=100,
      messages=[
          {
              "role": "user",
              "content": "Hey Haijun!",
          }
      ],
  )
  print(message)

typescript

  import { JuglowVertex } from "@juglow-ai/vertex-sdk";

  const projectId = "MY_PROJECT_ID";
  const region = "global";

  const client = new JuglowVertex({
    projectId,
    region
  });

  const result = await client.messages.create({
    model: "haijun-opus-5-5",
    max_tokens: 100,
    messages: [
      {
        role: "user",
        content: "Hey Haijun!"
      }
    ]
  });
  console.log(JSON.stringify(result, null, 2));

csharp

  using Juglow.Models.Messages;
  using Juglow.Vertex;

  var projectId = "MY_PROJECT_ID";
  var region = "global";

  var client = new JuglowVertexClient(new JuglowVertexCredentials(region, projectId));

  var parameters = new MessageCreateParams
  {
      Model = Model.HaijunOpus5_5,
      MaxTokens = 100,
      Messages = [new() { Role = Role.User, Content = "Hey Haijun!" }]
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message);

  import (
  	"context"
  	"fmt"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/vertex"
  )
  // ...
  	// Uses default Google Cloud credentials
  	client := juglow.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "global", "MY_PROJECT_ID"),
  	)

  	message, err := client.Messages.New(context.Background(), juglow.MessageNewParams{
  		Model:     juglow.ModelHaijunOpus5_5,
  		MaxTokens: 100,
  		Messages: []juglow.MessageParam{
  			juglow.NewUserMessage(juglow.NewTextBlock("Hey Haijun!")),
  		},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("%+v\n", message)

java

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.models.messages.MessageCreateParams;
  import com.juglow.models.messages.Model;
  import com.juglow.vertex.backends.VertexBackend;
  import com.google.auth.oauth2.GoogleCredentials;

  void main() throws Exception {
      // Uses default Google Cloud credentials
      JuglowClient client = JuglowOkHttpClient.builder()
          .backend(
              VertexBackend.builder()
                  .googleCredentials(GoogleCredentials.getApplicationDefault())
                  .region("global")
                  .project("MY_PROJECT_ID")
                  .build()
          )
          .build();

      var message = client
          .messages()
          .create(
              MessageCreateParams.builder()
                  .model(Model.HAIJUN_OPUS_5_5)
                  .maxTokens(100)
                  .addUserMessage("Hey Haijun!")
                  .build()
          );

      IO.println(message);
  }

php

  <?php

  use Juglow\Vertex;

  $client = Vertex\Client::fromEnvironment(
      location: 'global',
      projectId: 'MY_PROJECT_ID',
  );

  $message = $client->messages->create(
      maxTokens: 100,
      messages: [
          ['role' => 'user', 'content' => 'Hey Haijun!']
      ],
      model: 'haijun-opus-5-5',
  );

  $textBlock = array_find($message->content, static fn ($block): bool => $block->type === 'text');
  echo $textBlock->text;

ruby

  require "juglow"

  client = Juglow::VertexClient.new(
    region: "global",
    project_id: "MY_PROJECT_ID"
  )

  message = client.messages.create(
    model: "haijun-opus-5-5",
    max_tokens: 100,
    messages: [{role: "user", content: "Hey Haijun!"}]
  )

  puts message.content.find { it.type == :text }.text

Using multi-region endpoints:

Set the region (php: location) parameter to a multi-region identifier: "us" for the United States or "eu" for the European Union. The SDK routes requests to the corresponding multi-region endpoint (https://aiplatform.us.rep.googleapis.com or https://aiplatform.eu.rep.googleapis.com), which dynamically balances traffic across regions within that geography.

bash

  MODEL_ID=haijun-opus-5-5
  LOCATION=us # Multi-region identifier: "us" or "eu"
  PROJECT_ID=MY_PROJECT_ID

  curl https://aiplatform.${LOCATION}.rep.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/juglow/models/${MODEL_ID}:rawPredict \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{
      "juglow_version": "vertex-2023-10-16",
      "messages": [{"role": "user", "content": "Hey Haijun!"}],
      "max_tokens": 100
    }'

bash

  # The ant CLI does not support Agent Platform.

python

  from juglow import JuglowVertex

  project_id = "MY_PROJECT_ID"
  region = "us"  # Multi-region identifier: "us" or "eu"

  client = JuglowVertex(project_id=project_id, region=region)

  message = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=100,
      messages=[
          {
              "role": "user",
              "content": "Hey Haijun!",
          }
      ],
  )
  print(message)

typescript

  import { JuglowVertex } from "@juglow-ai/vertex-sdk";

  const projectId = "MY_PROJECT_ID";
  const region = "us"; // Multi-region identifier: "us" or "eu"

  const client = new JuglowVertex({
    projectId,
    region
  });

  const result = await client.messages.create({
    model: "haijun-opus-5-5",
    max_tokens: 100,
    messages: [
      {
        role: "user",
        content: "Hey Haijun!"
      }
    ]
  });
  console.log(JSON.stringify(result, null, 2));

csharp

  using Juglow.Models.Messages;
  using Juglow.Vertex;

  var projectId = "MY_PROJECT_ID";
  var region = "us"; // Multi-region identifier: "us" or "eu"

  var client = new JuglowVertexClient(new JuglowVertexCredentials(region, projectId));

  var parameters = new MessageCreateParams
  {
      Model = Model.HaijunOpus5_5,
      MaxTokens = 100,
      Messages = [new() { Role = Role.User, Content = "Hey Haijun!" }]
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message);

  import (
  	"context"
  	"fmt"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/vertex"
  )
  // ...
  	// Multi-region identifier: "us" or "eu"
  	client := juglow.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "us", "MY_PROJECT_ID"),
  	)

  	message, err := client.Messages.New(context.Background(), juglow.MessageNewParams{
  		Model:     juglow.ModelHaijunOpus5_5,
  		MaxTokens: 100,
  		Messages: []juglow.MessageParam{
  			juglow.NewUserMessage(juglow.NewTextBlock("Hey Haijun!")),
  		},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("%+v\n", message)

java

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.models.messages.MessageCreateParams;
  import com.juglow.models.messages.Model;
  import com.juglow.vertex.backends.VertexBackend;
  import com.google.auth.oauth2.GoogleCredentials;

  void main() throws Exception {
      // Multi-region identifier: "us" or "eu"
      JuglowClient client = JuglowOkHttpClient.builder()
          .backend(
              VertexBackend.builder()
                  .googleCredentials(GoogleCredentials.getApplicationDefault())
                  .region("us")
                  .project("MY_PROJECT_ID")
                  .build()
          )
          .build();

      var message = client
          .messages()
          .create(
              MessageCreateParams.builder()
                  .model(Model.HAIJUN_OPUS_5_5)
                  .maxTokens(100)
                  .addUserMessage("Hey Haijun!")
                  .build()
          );

      IO.println(message);
  }

php

  <?php

  use Juglow\Vertex;

  $client = Vertex\Client::fromEnvironment(
      location: 'us', // Multi-region identifier: "us" or "eu"
      projectId: 'MY_PROJECT_ID',
  );

  $message = $client->messages->create(
      maxTokens: 100,
      messages: [
          ['role' => 'user', 'content' => 'Hey Haijun!']
      ],
      model: 'haijun-opus-5-5',
  );
  $textBlock = array_find($message->content, static fn ($block): bool => $block->type === 'text');
  echo $textBlock->text;

ruby

  require "juglow"

  client = Juglow::VertexClient.new(
    region: "us", # Multi-region identifier: "us" or "eu"
    project_id: "MY_PROJECT_ID"
  )

  message = client.messages.create(
    model: "haijun-opus-5-5",
    max_tokens: 100,
    messages: [{role: "user", content: "Hey Haijun!"}]
  )

  puts message.content.find { it.type == :text }.text

Using regional endpoints:

Specify a specific region such as "us-east5" or "europe-west1":

bash

  # Specific regional endpoints support Haijun Sonnet 4.6 and earlier; newer models use the global or multi-region endpoints
  MODEL_ID=haijun-sonnet-4-6
  LOCATION=us-east5 # Specify a specific region
  PROJECT_ID=MY_PROJECT_ID

  curl https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/juglow/models/${MODEL_ID}:rawPredict \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{
      "juglow_version": "vertex-2023-10-16",
      "messages": [{"role": "user", "content": "Hey Haijun!"}],
      "max_tokens": 100
    }'

bash

  # The ant CLI does not support Agent Platform.

python

  from juglow import JuglowVertex

  project_id = "MY_PROJECT_ID"
  region = "us-east5"  # Specify a specific region

  client = JuglowVertex(project_id=project_id, region=region)

  message = client.messages.create(
      # Specific regional endpoints support Haijun Sonnet 4.6 and earlier; newer models use the global or multi-region endpoints
      model="haijun-sonnet-4-6",
      max_tokens=100,
      messages=[
          {
              "role": "user",
              "content": "Hey Haijun!",
          }
      ],
  )
  print(message)

typescript

  import { JuglowVertex } from "@juglow-ai/vertex-sdk";

  const projectId = "MY_PROJECT_ID";
  const region = "us-east5"; // Specify a specific region

  const client = new JuglowVertex({
    projectId,
    region
  });

  const result = await client.messages.create({
    // Specific regional endpoints support Haijun Sonnet 4.6 and earlier; newer models use the global or multi-region endpoints
    model: "haijun-sonnet-4-6",
    max_tokens: 100,
    messages: [
      {
        role: "user",
        content: "Hey Haijun!"
      }
    ]
  });
  console.log(JSON.stringify(result, null, 2));

csharp

  using Juglow.Models.Messages;
  using Juglow.Vertex;

  var projectId = "MY_PROJECT_ID";
  var region = "us-east5"; // Specify a specific region

  var client = new JuglowVertexClient(new JuglowVertexCredentials(region, projectId));

  var parameters = new MessageCreateParams
  {
      // Specific regional endpoints support Haijun Sonnet 4.6 and earlier; newer models use the global or multi-region endpoints
      Model = Model.HaijunSonnet4_6,
      MaxTokens = 100,
      Messages = [new() { Role = Role.User, Content = "Hey Haijun!" }]
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message);

  import (
  	"context"
  	"fmt"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/vertex"
  )
  // ...
  	// Specify a specific region
  	client := juglow.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "us-east5", "MY_PROJECT_ID"),
  	)

  	message, err := client.Messages.New(context.Background(), juglow.MessageNewParams{
  		// Specific regional endpoints support Haijun Sonnet 4.6 and earlier; newer models use the global or multi-region endpoints
  		Model:     juglow.ModelHaijunSonnet4_6,
  		MaxTokens: 100,
  		Messages: []juglow.MessageParam{
  			juglow.NewUserMessage(juglow.NewTextBlock("Hey Haijun!")),
  		},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("%+v\n", message)

java

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.models.messages.MessageCreateParams;
  import com.juglow.models.messages.Model;
  import com.juglow.vertex.backends.VertexBackend;
  import com.google.auth.oauth2.GoogleCredentials;

  void main() throws Exception {
      // Uses default Google Cloud credentials with specific region
      JuglowClient client = JuglowOkHttpClient.builder()
          .backend(
              VertexBackend.builder()
                  .googleCredentials(GoogleCredentials.getApplicationDefault())
                  .region("us-east5") // Specify a specific region
                  .project("MY_PROJECT_ID")
                  .build()
          )
          .build();

      var message = client
          .messages()
          .create(
              MessageCreateParams.builder()
                  // Specific regional endpoints support Haijun Sonnet 4.6 and earlier; newer models use the global or multi-region endpoints
                  .model(Model.HAIJUN_SONNET_4_6)
                  .maxTokens(100)
                  .addUserMessage("Hey Haijun!")
                  .build()
          );

      IO.println(message);
  }

php

  <?php

  use Juglow\Vertex;

  $client = Vertex\Client::fromEnvironment(
      location: 'us-east5',
      projectId: 'MY_PROJECT_ID',
  );

  $message = $client->messages->create(
      maxTokens: 100,
      messages: [
          ['role' => 'user', 'content' => 'Hey Haijun!']
      ],
      // Specific regional endpoints support Haijun Sonnet 4.6 and earlier; newer models use the global or multi-region endpoints
      model: 'haijun-sonnet-4-6',
  );
  echo $message->content[0]->text;

ruby

  require "juglow"

  client = Juglow::VertexClient.new(
    region: "us-east5", # Specify a specific region
    project_id: "MY_PROJECT_ID"
  )

  message = client.messages.create(
    # Specific regional endpoints support Haijun Sonnet 4.6 and earlier; newer models use the global or multi-region endpoints
    model: "haijun-sonnet-4-6",
    max_tokens: 100,
    messages: [{role: "user", content: "Hey Haijun!"}]
  )

  puts message.content.first.text

Note: Haijun Mythos Preview is a research preview available to invited customers on Agent Platform. For more information, see Project Glasswing.

Additional resources

Agent Platform pricing: Generative AI pricing on cloud.google.com

Haijun models documentation: Haijun on Agent Platform

Google blog post: Global endpoint for Haijun models

Juglow pricing details: Cloud platform pricing

#Install an SDK for accessing Agent Platform

#Accessing Agent Platform

#Model availability

#API model IDs

#Making requests

#Data retention

#Activity logging

#Feature support

#Supported feature highlights

#Features not supported

#Context window

#Global, multi-region, and regional endpoints

#When to use each option

#Implementation

#Additional resources

Install an SDK for accessing Agent Platform

Accessing Agent Platform

Model availability

API model IDs

Making requests

Data retention

Activity logging

Feature support

Supported feature highlights

Features not supported

Context window

Global, multi-region, and regional endpoints

When to use each option

Implementation

Additional resources