Gemini 3.8 Flash jest już dostępny. Przećwicz to samodzielnie.

Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Dane logowania w przypadku agentów zarządzanych

Dane logowania to zarządzane przez serwer obiekty tajne, które umożliwiają agentom dostęp do usług innych firm bez konieczności wprowadzania obiektu tajnego do środowiska agenta. Dane logowania przechowujesz tylko raz, odwołujesz się do nich za pomocą identyfikatora, a serwer proxy ruchu wychodzącego rozwiązuje je i wstawia w momencie wysłania żądania.

Wartości obiektu tajnego są tylko do zapisu. Po zapisaniu nie są one nigdy zwracane przez żaden punkt końcowy, więc przejęty agent nie może odczytać używanych przez siebie tokenów.

Głównym miejscem używania danych logowania jest biała lista sieci na stronieenvironment.network. Najpierw zapisz obiekt tajny:

Python

from google import genai

client = genai.Client()

credential = client.credentials.create(
    id="github-production",
    type="bearer_token",
    token="ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
)

print(f"Credential ID: {credential.id}, Status: {credential.status}")

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const credential = await client.credentials.create({
    id: "github-production",
    type: "bearer_token",
    token: "ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
});

console.log(`Credential ID: ${credential.id}, Status: ${credential.status}`);

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/credentials" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "id": "github-production",
    "type": "bearer_token",
    "token": "ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
}'

Następnie dołącz go do domeny, którą uwierzytelnia:

Python

interaction = client.interactions.create(
    agent="antigravity-preview-09-2026",
    input="Triage the open issues in my-org/my-repo.",
    environment={
        "type": "remote",
        "network": {
            "allowlist": [
                {"domain": "api.github.com", "credential": "github-production"},
                {"domain": "*"},
            ]
        },
    },
)

JavaScript

const interaction = await client.interactions.create({
    agent: "antigravity-preview-09-2026",
    input: "Triage the open issues in my-org/my-repo.",
    environment: {
        type: "remote",
        network: {
            allowlist: [
                { domain: "api.github.com", credential: "github-production" },
                { domain: "*" },
            ],
        },
    },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "agent": "antigravity-preview-09-2026",
    "input": "Triage the open issues in my-org/my-repo.",
    "environment": {
        "type": "remote",
        "network": {
            "allowlist": [
                { "domain": "api.github.com", "credential": "github-production" },
                { "domain": "*" }
            ]
        }
    }
}'

Agent wysyła teraz uwierzytelnione żądania do usługi api.github.com, a token nigdy nie znajduje się w piaskownicy.

Typy certyfikatów

Każde dane logowania mają type, który określa, jakie pola są akceptowane i jak serwer proxy je stosuje.

Typ	Przypadek użycia	Zachowanie
`bearer_token`	Osobiste tokeny dostępu, tokeny botów, statyczne klucze interfejsu API	Serwer proxy wstrzykuje token jako nagłówek żądania. Brak logiki odświeżania.
`oauth2`	Aplikacje OAuth i przepływy delegowane przez użytkownika	Serwer proxy wymienia token odświeżania na tokeny dostępu i odświeża je, gdy wygasną.
`environment_variable`	Zestawy SDK klienta, które odczytują klucze tajne ze środowiska procesu	Środowisko agenta otrzymuje obiekt zastępczy. Serwer proxy zastępuje prawdziwy klucz tajny w żądaniach wychodzących.

Używanie danych logowania z listy dozwolonych sieci

Dodaj credential do reguły listy dozwolonych, a serwer proxy będzie uwierzytelniać każde żądanie wychodzące do tej domeny. Jest to zalecany sposób przyznawania agentowi dostępu do prywatnego interfejsu API, prywatnego repozytorium lub prywatnego zasobnika.

Na tej samej liście dozwolonych możesz łączyć reguły uwierzytelnione i nieuwierzytelnione:

Python

interaction = client.interactions.create(
    agent="antigravity-preview-09-2026",
    input="Sync the open Jira issues into the tracking sheet in my repo.",
    environment={
        "type": "remote",
        "sources": [
            {
                "type": "repository",
                "source": "https://github.com/your-org/backend",
                "target": "/backend-app",
            }
        ],
        "network": {
            "allowlist": [
                {"domain": "github.com", "credential": "github-production"},
                {"domain": "api.atlassian.com", "credential": "jira-oauth"},
                {"domain": "*.googleapis.com"},
            ]
        },
    },
)

JavaScript

const interaction = await client.interactions.create({
    agent: "antigravity-preview-09-2026",
    input: "Sync the open Jira issues into the tracking sheet in my repo.",
    environment: {
        type: "remote",
        sources: [
            {
                type: "repository",
                source: "https://github.com/your-org/backend",
                target: "/backend-app",
            },
        ],
        network: {
            allowlist: [
                { domain: "github.com", credential: "github-production" },
                { domain: "api.atlassian.com", credential: "jira-oauth" },
                { domain: "*.googleapis.com" },
            ],
        },
    },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "agent": "antigravity-preview-09-2026",
    "input": "Sync the open Jira issues into the tracking sheet in my repo.",
    "environment": {
        "type": "remote",
        "sources": [
            {
                "type": "repository",
                "source": "https://github.com/your-org/backend",
                "target": "/backend-app"
            }
        ],
        "network": {
            "allowlist": [
                { "domain": "github.com", "credential": "github-production" },
                { "domain": "api.atlassian.com", "credential": "jira-oauth" },
                { "domain": "*.googleapis.com" }
            ]
        }
    }
}'

Ponieważ serwer proxy rozwiązuje problem z uwierzytelnianiem w przypadku każdego żądania, oauth2odświeża token dostępu w sposób niewidoczny dla użytkownika. Długotrwała interakcja nie zostanie przerwana, gdy token dostępu wygaśnie.

Łączenie `credential` i `transform`

Reguły listy dozwolonych akceptują też obiekt wbudowany transform, który bezpośrednio ustawia nagłówki w regule. Oba mechanizmy są stosowane przez serwer proxy ruchu wychodzącego, więc w obu przypadkach wartość nagłówka nigdy nie występuje w piaskownicy. Oba pola mogą występować w tej samej regule.

Konfiguracja reguły	Zachowanie
Tylko `credential`	Serwer proxy rozwiązuje problem z danymi logowania i wstawia nagłówek do każdego żądania wysyłanego do domeny.
Tylko `transform`	Wstrzykiwanie statycznego nagłówka. Wpisane nagłówki są wysyłane w niezmienionej postaci.
dla obu grup	Najpierw stosowane są dane logowania, a potem `transform` jest łączony na wierzchu. Jeśli oba nagłówki ustawiają ten sam klucz, wygrywa nagłówek `transform`.
Nie mam zdania	Domena jest dozwolona i nie są wstrzykiwane żadne nagłówki.

Używanie danych logowania jest przydatne, gdy chcesz zapisać klucz tajny tylko raz i odwoływać się do niego z każdego środowiska, agenta i wyzwalacza w projekcie oraz gdy chcesz, aby odświeżanie i rotacja tokenów dostępu były obsługiwane automatycznie. Wbudowany transform pasuje, gdy wartość należy do pojedynczego wywołania, np. tokena wygenerowanego samodzielnie tuż przed utworzeniem interakcji.

Połączenie tych dwóch metod jest powszechne. Dane logowania zawierają nagłówek uwierzytelniania, a transform dodaje wszystko inne, czego oczekuje usługa nadrzędna w tym samym żądaniu:

{
    "domain": "api.atlassian.com",
    "credential": "jira-oauth",
    "transform": {
        "X-Atlassian-Workspace": "my-workspace-id"
    }
}

Aby przenieść tajny klucz z wiersza transform do danych logowania, zapisz go za pomocą POST /credentials, zastąp nagłówek autoryzacji w transform ciągiem "credential": "<id>" i nie zmieniaj reszty obiektu transform.

Używanie danych logowania na serwerach MCP

Zdalne serwery MCP przyjmują to samo pole credential. Ustaw go w mcp_servernarzędziu, a serwer proxy wstrzyknie nagłówek autoryzacji do każdego żądania wysyłanego do tego serwera:

Python

interaction = client.interactions.create(
    agent="antigravity-preview-09-2026",
    input="Create a new issue in my-org/my-repo",
    environment="remote",
    tools=[{
        "type": "mcp_server",
        "name": "github",
        "url": "https://api.githubcopilot.com/mcp",
        "credential": "github-production",
    }],
)

JavaScript

const interaction = await client.interactions.create({
    agent: "antigravity-preview-09-2026",
    input: "Create a new issue in my-org/my-repo",
    environment: "remote",
    tools: [{
        type: "mcp_server",
        name: "github",
        url: "https://api.githubcopilot.com/mcp",
        credential: "github-production",
    }],
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "agent": "antigravity-preview-09-2026",
    "input": "Create a new issue in my-org/my-repo",
    "environment": "remote",
    "tools": [
        {
            "type": "mcp_server",
            "name": "github",
            "url": "https://api.githubcopilot.com/mcp",
            "credential": "github-production"
        }
    ]
}'

Zasady credential i headers mają taki sam priorytet jak lista dozwolonych. Dane logowania są stosowane w pierwszej kolejności, a headers jest scalany na wierzchu, więc jeśli oba ustawiają ten sam klucz, wygrywa jawny nagłówek:

{
    "type": "mcp_server",
    "name": "jira",
    "url": "https://jira.atlassian.com/mcp",
    "credential": "jira-oauth",
    "headers": {
        "X-Atlassian-Workspace": "my-workspace-id"
    }
}

Aby przenieść tajny klucz z wiersza headers do danych logowania, zapisz go za pomocą POST /credentials i zastąp wpis uwierzytelniania w headers ciągiem credential. Pozostaw pozostałe nagłówki w dotychczasowych miejscach.

Używanie danych logowania jako zmiennych środowiskowych

Niektóre biblioteki klienta odczytują klucze tajne ze środowiska procesu, zamiast akceptować je jako nagłówki żądań. Klienci w trybie gniazda i długiego odpytywania to typowy przypadek.

Powiąż dane logowania environment_variable z nazwą zmiennej w sekcji environment.env:

Python

interaction = client.interactions.create(
    agent="antigravity-preview-09-2026",
    input="Run the sync script and check notifications.",
    environment={
        "type": "remote",
        "env": {
            "NODE_ENV": "production",
            "SLACK_BOT_TOKEN": {"credential": "slack-bot-token"},
        },
    },
)

JavaScript

const interaction = await client.interactions.create({
    agent: "antigravity-preview-09-2026",
    input: "Run the sync script and check notifications.",
    environment: {
        type: "remote",
        env: {
            NODE_ENV: "production",
            SLACK_BOT_TOKEN: { credential: "slack-bot-token" },
        },
    },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "agent": "antigravity-preview-09-2026",
    "input": "Run the sync script and check notifications.",
    "environment": {
        "type": "remote",
        "env": {
            "NODE_ENV": "production",
            "SLACK_BOT_TOKEN": { "credential": "slack-bot-token" }
        }
    }
}'

env akceptuje dosłowne ciągi znaków i odwołania do danych logowania obok siebie. Do kontenera wstrzykiwany jest literał w postaci zwykłej zmiennej tekstowej.

Odwołanie do danych logowania nie jest. Zmienna otrzymuje symbol zastępczy __GEMINI_CRED_<credential-id>__, a serwer proxy zamienia go na prawdziwy klucz tajny tylko w przypadku żądań wychodzących kierowanych do domeny w trusted_domains danych logowania. Żądanie wysłane do innej domeny jest odrzucane, więc obiekt tajny nigdy nie opuszcza granicy, a zamiast niego nie jest wysyłany obiekt zastępczy.

Ustaw trusted_domains dla każdego certyfikatu environment_variable. Jest to kontrola, która określa zakres, w którym można używać klucza tajnego.

Tworzenie danych logowania

Każde żądanie utworzenia musi zawierać type oraz pola wymagane przez ten typ.

W przypadku bezpośredniego wywoływania interfejsu REST wszystkie nazwy pól są zapisywane w formacie snake_case. Wysłanie pola w formacie camelCase zwraca wartość 400.

Token okaziciela

Dane logowania w postaci tokena dostępu wymagają tylko token:

Python

credential = client.credentials.create(
    id="github-production",
    type="bearer_token",
    token="ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
)

JavaScript

const credential = await client.credentials.create({
    id: "github-production",
    type: "bearer_token",
    token: "ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/credentials" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "id": "github-production",
    "type": "bearer_token",
    "token": "ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
}'

Odpowiedź zwraca tylko metadane, nigdy token:

{
  "id": "github-production",
  "type": "bearer_token",
  "status": "active",
  "create_time": "2026-07-15T10:00:00.000000000Z",
  "update_time": "2026-07-15T10:00:00.000000000Z"
}

Domyślnie serwer proxy wysyła wartość Authorization: Bearer <token>. Zastąp header_name i prefix, aby kierować reklamy na usługę, która oczekuje czegoś innego:

Python

credential = client.credentials.create(
    id="my-api-key",
    type="bearer_token",
    token="key_xxxxxxxxxxxx",
    header_name="x-goog-api-key",
    prefix="",
)

JavaScript

const credential = await client.credentials.create({
    id: "my-api-key",
    type: "bearer_token",
    token: "key_xxxxxxxxxxxx",
    header_name: "x-goog-api-key",
    prefix: "",
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/credentials" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "id": "my-api-key",
    "type": "bearer_token",
    "token": "key_xxxxxxxxxxxx",
    "header_name": "x-goog-api-key",
    "prefix": ""
}'

Ta konfiguracja generuje nagłówek x-goog-api-key: key_xxxxxxxxxxxx.

W tabeli poniżej pokazujemy, jak łączą się ze sobą symbole header_name i prefix:

Konfiguracja	Wstrzyknięty nagłówek
`{"token": "ghp_xxx"}`	`Authorization: Bearer ghp_xxx`
`{"token": "sk_live_xxx"}`	`Authorization: Bearer sk_live_xxx`
`{"token": "key_xxx", "header_name": "x-goog-api-key", "prefix": ""}`	`x-goog-api-key: key_xxx`
`{"token": "mytoken", "header_name": "X-API-Token", "prefix": ""}`	`X-API-Token: mytoken`

OAuth2

Dane logowania OAuth2 wymagają client_id, client_secret, refresh_token i token_url. Pole scopes jest opcjonalne:

Python

credential = client.credentials.create(
    id="jira-oauth",
    type="oauth2",
    client_id="my-client-id",
    client_secret="my-client-secret",
    token_url="https://auth.atlassian.com/oauth/token",
    refresh_token="rt_xxxxxxxxxxxxxxxxxxxx",
    scopes=["read:jira-work", "write:jira-work"],
)

JavaScript

const credential = await client.credentials.create({
    id: "jira-oauth",
    type: "oauth2",
    client_id: "my-client-id",
    client_secret: "my-client-secret",
    token_url: "https://auth.atlassian.com/oauth/token",
    refresh_token: "rt_xxxxxxxxxxxxxxxxxxxx",
    scopes: ["read:jira-work", "write:jira-work"],
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/credentials" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "id": "jira-oauth",
    "type": "oauth2",
    "client_id": "my-client-id",
    "client_secret": "my-client-secret",
    "token_url": "https://auth.atlassian.com/oauth/token",
    "refresh_token": "rt_xxxxxxxxxxxxxxxxxxxx",
    "scopes": ["read:jira-work", "write:jira-work"]
}'

Podczas tworzenia danych logowania OAuth2 następuje wymiana tokena na żywo z token_url, aby potwierdzić, że konfiguracja działa. Dane logowania są przechowywane tylko wtedy, gdy dostawca zwraca odpowiedź z tokenem zawierającą access_token. Akceptowane są odpowiedzi w formacie JSON i form-urlencoded.

Oznacza to, że w momencie tworzenia musisz mieć ważny, niewygasły token odświeżania. Jeśli dostawca odrzuci wymianę, otrzymasz komunikat o błędzie:

{
  "error": {
    "message": "OAuth token validation failed with HTTP 403: {\"error\":\"unauthorized_client\",\"error_description\":\"refresh_token is invalid\"}",
    "code": "invalid_request"
  }
}

Po zapisaniu serwer proxy odświeża tokeny dostępu, gdy wygasną. Jeśli dostawca rotuje tokeny odświeżania i podczas odświeżania zwraca nowy token, zastępuje on automatycznie zapisany token.

Zmienna środowiskowa

Dane logowania environment_variable wymagają value i injection_location:

Python

credential = client.credentials.create(
    id="slack-bot-token",
    type="environment_variable",
    value="xoxb-xxxxxxxxxxxx-xxxxxxxxxxxx",
    trusted_domains=["*.slack.com", "slack.com"],
    injection_location="header",
)

JavaScript

const credential = await client.credentials.create({
    id: "slack-bot-token",
    type: "environment_variable",
    value: "xoxb-xxxxxxxxxxxx-xxxxxxxxxxxx",
    trusted_domains: ["*.slack.com", "slack.com"],
    injection_location: "header",
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/credentials" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "id": "slack-bot-token",
    "type": "environment_variable",
    "value": "xoxb-xxxxxxxxxxxx-xxxxxxxxxxxx",
    "trusted_domains": ["*.slack.com", "slack.com"],
    "injection_location": "header"
}'

Pole injection_location informuje serwer proxy, w którym miejscu żądania wychodzącego należy wstawić obiekt tajny. Akceptuje wartości header, query lub body w postaci pojedynczego ciągu znaków lub tablicy, gdy usługa potrzebuje więcej niż jednego:

"injection_location": ["header", "query"]

Podstawienie następuje tylko w lokalizacjach, które podasz. Żądanie zawierające symbol zastępczy w innym miejscu jest odrzucane, a nie wysyłane dalej.

Aby powiązać dane logowania z nazwą zmiennej, przeczytaj artykuł Używanie danych logowania jako zmiennych środowiskowych.

Wygenerowane identyfikatory

Pole id jest opcjonalne. Pomiń ten parametr, a usługa wygeneruje identyfikator UUID:

{
  "id": "9e545973-4330-49bb-9a44-930cea9fbe3c",
  "type": "bearer_token",
  "status": "active",
  "create_time": "2026-07-15T10:00:00.000000000Z",
  "update_time": "2026-07-15T10:00:00.000000000Z"
}

Podaj własny identyfikator, jeśli chcesz mieć stabilne, czytelne odwołanie do używania w różnych interakcjach. Identyfikator pojawia się w ścieżce zasobu, dlatego zalecamy używanie małych liter i cyfr z łącznikami lub podkreśleniami.

Wyświetlanie listy danych logowania

Wyświetl listę danych logowania należących do Twojego projektu. Użyj parametrów podziału na strony, aby kontrolować wielkość wsadu odpowiedzi.

Python

response = client.credentials.list(page_size=10)
for credential in response.credentials:
    print(f"Credential ID: {credential.id}, Type: {credential.type}")

JavaScript

const response = await client.credentials.list({ page_size: 10 });
for (const credential of response.credentials) {
    console.log(`Credential ID: ${credential.id}, Type: ${credential.type}`);
}

REST

curl -X GET "https://generativelanguage.googleapis.com/v1beta/credentials?page_size=10" \
-H "x-goog-api-key: $GEMINI_API_KEY"

Odpowiedź zawiera tylko metadane:

{
  "credentials": [
    {
      "id": "github-production",
      "type": "bearer_token",
      "status": "active",
      "create_time": "2026-07-15T10:00:00.000000000Z",
      "update_time": "2026-07-15T10:00:00.000000000Z"
    },
    {
      "id": "jira-oauth",
      "type": "oauth2",
      "status": "active",
      "create_time": "2026-07-15T10:05:00.000000000Z",
      "update_time": "2026-07-15T10:05:00.000000000Z"
    }
  ],
  "next_page_token": "Cj...5aE="
}

Przekaż next_page_token z powrotem jako page_token, aby pobrać następną stronę. Pole jest pomijane, gdy nie ma więcej wyników.

Parametr	Typ	Opis
`page_size`	liczba całkowita	Maksymalna liczba danych logowania na stronie.
`page_token`	tekst	Token z pola `next_page_token` poprzedniej odpowiedzi.

Uzyskiwanie danych logowania

Pobieranie metadanych konkretnych danych logowania na podstawie ich identyfikatora.

Python

credential = client.credentials.get(id="github-production")
print(f"Credential ID: {credential.id}, Status: {credential.status}")

JavaScript

const credential = await client.credentials.get("github-production");
console.log(`Credential ID: ${credential.id}, Status: ${credential.status}`);

REST

curl -X GET "https://generativelanguage.googleapis.com/v1beta/credentials/github-production" \
-H "x-goog-api-key: $GEMINI_API_KEY"

Odpowiedź wygląda mniej więcej tak:

{
  "id": "github-production",
  "type": "bearer_token",
  "status": "active",
  "create_time": "2026-07-15T10:00:00.000000000Z",
  "update_time": "2026-08-01T14:30:00.000000000Z"
}

Żądanie danych logowania, które nie istnieją, zwraca kod 404:

{
  "error": {
    "message": "Result not found.; GetCredential call failed",
    "code": "not_found"
  }
}

Rotacja danych logowania

Zastąp sekret bez zmiany żadnej reguły listy dozwolonych, definicji narzędzia ani zmiennej środowiskowej, która się do niego odwołuje. Rotacja zacznie obowiązywać przy następnym rozpoznawaniu serwera proxy.

Żądanie musi zawierać type oraz pola, które chcesz zmienić. Pola, które pominiesz, zachowają bieżące wartości.

Obracanie tokena okaziciela:

Python

credential = client.credentials.update(
    id="github-production",
    type="bearer_token",
    token="ghp_new_xxxxxxxxxxxxxxxxxxxx",
)

JavaScript

const credential = await client.credentials.update("github-production", {
    type: "bearer_token",
    token: "ghp_new_xxxxxxxxxxxxxxxxxxxx",
});

REST

curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/credentials/github-production" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "type": "bearer_token",
    "token": "ghp_new_xxxxxxxxxxxxxxxxxxxx"
}'

Obracanie tokena odświeżania OAuth2:

Python

credential = client.credentials.update(
    id="jira-oauth",
    type="oauth2",
    refresh_token="rt_new_xxxxxxxxxxxxxxxxxxxx",
)

JavaScript

const credential = await client.credentials.update("jira-oauth", {
    type: "oauth2",
    refresh_token: "rt_new_xxxxxxxxxxxxxxxxxxxx",
});

REST

curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/credentials/jira-oauth" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "type": "oauth2",
    "refresh_token": "rt_new_xxxxxxxxxxxxxxxxxxxx"
}'

Odpowiedź odzwierciedla nowy update_time:

{
  "id": "jira-oauth",
  "type": "oauth2",
  "status": "active",
  "create_time": "2026-07-15T10:05:00.000000000Z",
  "update_time": "2026-08-01T14:30:00.000000000Z"
}

Wartość type danych logowania jest ustalana podczas tworzenia. Aby go zmienić, usuń dane logowania i utwórz nowe.

Usuwanie danych logowania

Usuwaj dane logowania i powiązany z nimi tajny klucz, gdy nie są już potrzebne.

Python

client.credentials.delete(id="github-production")

JavaScript

await client.credentials.delete("github-production");

REST

curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/credentials/github-production" \
-H "x-goog-api-key: $GEMINI_API_KEY"

Usunięcie zakończone powodzeniem zwraca pusty obiekt:

{}

Każda reguła listy dozwolonych, narzędzie lub zmienna środowiskowa, która nadal odwołuje się do identyfikatora, nie będzie działać, więc najpierw je zaktualizuj.

Odwołanie do pola

Pola wspólne dla wszystkich danych logowania:

Pole	Typ	Wymagane	Opis
`id`	tekst	Nie	Unikalny identyfikator. Jeśli go pominiesz, zostanie wygenerowany jako identyfikator UUID.
`type`	tekst	Tak	Jedna z wartości: `bearer_token`, `oauth2`, `environment_variable`.
`status`	tekst	Tylko do odczytu	Bieżący stan danych logowania.
`create_time`	tekst	Tylko do odczytu	Sygnatura czasowa utworzenia w formacie RFC 3339.
`update_time`	tekst	Tylko do odczytu	Sygnatura czasowa RFC 3339 ostatniej aktualizacji.

Pola dla bearer_token:

Pole	Typ	Wymagane	Opis
`token`	tekst	Tak	Tylko do zapisu. Wartość tokena.
`header_name`	tekst	Nie	Nagłówek do wstrzyknięcia. Domyślna wartość to `Authorization`.
`prefix`	tekst	Nie	Prefiks wartości. Domyślna wartość to `Bearer`. `""` oznacza brak.

Pola dla oauth2:

Pole	Typ	Wymagane	Opis
`client_id`	tekst	Tak	Identyfikator klienta OAuth2.
`client_secret`	tekst	Tak	Tylko do zapisu. Tajny klucz klienta OAuth2.
`refresh_token`	tekst	Tak	Tylko do zapisu. Token odświeżania używany do uzyskiwania tokenów dostępu.
`token_url`	tekst	Tak	Punkt końcowy tokena dostawcy.
`scopes`	tablica	Nie	Zakresy protokołu OAuth, o które należy poprosić.

Pola dla environment_variable:

Pole	Typ	Wymagane	Opis
`value`	tekst	Tak	Tylko do zapisu. Wartość obiektu tajnego.
`injection_location`	ciąg tekstowy lub tablica	Tak	Miejsce, w którym należy zastąpić obiekt tajny. Co najmniej jeden z tych elementów: `header`, `query`, `body`.
`trusted_domains`	tablica	Nie	Wzorce domen autoryzowane do zastępowania.

Błędy

Błędy zwracają obiekt JSON z elementami message i code:

{
  "error": {
    "message": "Credential 'github-production' already exists.; CreateCredential call failed",
    "code": "aborted"
  }
}

Stan HTTP	`code`	Przyczyna
400	`invalid_request`	Brak wymaganego pola, nieznane pole, nieobsługiwane pole `type` lub nieudana weryfikacja OAuth2.
404	`not_found`	Brak danych logowania o takim identyfikatorze.
409	`aborted`	Dane logowania o tym identyfikatorze już istnieją.

Nieznane pola są odrzucane, a nie ignorowane, a w komunikacie o błędzie podawana jest nazwa pola:

{
  "error": {
    "message": "Unknown parameter 'headerName'. Did you mean 'header_name'?",
    "code": "invalid_request"
  }
}

Co dalej?

Środowiska: dowiedz się, jak agenci uruchamiają kod i przechowują pliki.
Omówienie agentów: poznaj podstawowe koncepcje dotyczące zarządzanych agentów.
Tworzenie agentów niestandardowych: definiuj własnych agentów za pomocą AGENTS.md i SKILL.md.

Dane logowania w przypadku agentów zarządzanych

Python

JavaScript

REST

Python

JavaScript

REST

Typy certyfikatów

Używanie danych logowania z listy dozwolonych sieci

Python

JavaScript

REST

Łączenie credential i transform

Używanie danych logowania na serwerach MCP

Python

JavaScript

REST

Używanie danych logowania jako zmiennych środowiskowych

Python

JavaScript

REST

Tworzenie danych logowania

Token okaziciela

Python

JavaScript

REST

Python

JavaScript

REST

OAuth2

Python

JavaScript

REST

Zmienna środowiskowa

Python

JavaScript

REST

Wygenerowane identyfikatory

Wyświetlanie listy danych logowania

Python

JavaScript

REST

Uzyskiwanie danych logowania

Python

JavaScript

REST

Rotacja danych logowania

Python

JavaScript

REST

Python

JavaScript

REST

Usuwanie danych logowania

Python

JavaScript

REST

Odwołanie do pola

Błędy

Co dalej?

Łączenie `credential` i `transform`