Kredencialet në agjentët e menaxhuar

Kredencialet janë sekrete të menaxhuara nga serveri që i lejojnë agjentët e tu të arrijnë shërbimet e palëve të treta pa hyrë asnjëherë në mjedisin e agjentit. Ti e ruan kredencialin një herë, i referohesh atij me ID dhe proksi i daljes e zgjidh dhe e injekton atë në kohën e kërkesës.

Vlerat e sekreteve janë vetëm për shkrim. Pasi të ruhen, ato nuk kthehen asnjëherë nga asnjë pikë fundore, kështu që një agjent i komprometuar nuk mund t'i lexojë përsëri kodet që po përdor.

Vendi kryesor ku përdor një kredencial është lista e lejimeve të rrjetit në environment.network. Ruaj sekretin në fillim:

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}`);

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/credentials"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Credentials.Create(ctx, operations.CreateCredentialRequest{
        Body: credentials.NewCredentialCreateParams(credentials.HTTPBearerConfig{
            ID:    "github-production",
            Token: "ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Credential ID: %s, Status: %v\n", res.Credential.ID, res.Credential.GetStatus())
}

QETËSI

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"
}'

Më pas bashkëngjit atë në domenin që autentifikon:

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: "*" },
            ],
        },
    },
});

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
            Agent: interactions.AgentOption("antigravity-preview-09-2026"),
            Input: interactions.NewInteractionsInput("Triage the open issues in my-org/my-repo."),
            Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(interactions.Environment{
                Network: genai.Ptr(interactions.NewNetwork(interactions.EnvironmentNetworkEgressAllowlist{
                    Allowlist: genai.Ptr(interactions.NewAllowlist([]interactions.AllowlistEntry{
                        {Domain: "api.github.com", Credential: genai.Ptr("github-production")},
                        {Domain: "*"},
                    })),
                })),
            })),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(res.Interaction.GetOutputText())
}

QETËSI

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": "*" }
            ]
        }
    }
}'

Agjenti tani bën kërkesa të vërtetuara te api.github.com dhe kodi nuk ekziston asnjëherë brenda sandbox-it.

Llojet e kredencialeve

Çdo kredencial ka një type që përcakton se cilat fusha pranon dhe si e zbaton atë serveri proxy.

Lloji Rasti i përdorimit Sjellja
bearer_token Tokenët e qasjes personale, tokenët e robotëve, çelësat statikë të API-së Proxy e injekton kodin si titull kërkese. Nuk ka logjikë rifreskimi.
oauth2 Aplikacionet OAuth dhe rrjedhat e deleguara nga përdoruesi Ndërmjetësi shkëmben kodin e rifreskimit për kodet e qasjes dhe i rifreskon ato kur skadojnë.
environment_variable SDK-të e klientit që lexojnë sekretet nga mjedisi i procesit Mjedisi i agjentit merr një vendmbajtës. Proksi zëvendëson sekretin e vërtetë në kërkesat dalëse.

Përdor kredencialet në listën e lejimeve të rrjetit

Shto credential në një rregull të listës së lejimeve dhe proxy vërteton çdo kërkesë dalëse për atë domen. Kjo është mënyra e rekomanduar për t'i dhënë një agjenti qasje në një API privat, një depo private ose një grup privat.

Mund të përziesh rregullat e vërtetuara dhe të pavërtetuara në të njëjtën listë lejimesh:

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" },
            ],
        },
    },
});

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
            Agent: interactions.AgentOption("antigravity-preview-09-2026"),
            Input: interactions.NewInteractionsInput("Sync the open Jira issues into the tracking sheet in my repo."),
            Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(interactions.Environment{
                Sources: []interactions.Source{
                    {
                        Type:   interactions.SourceTypeRepository.ToPointer(),
                        Source: genai.Ptr("https://github.com/your-org/backend"),
                        Target: genai.Ptr("/backend-app"),
                    },
                },
                Network: genai.Ptr(interactions.NewNetwork(interactions.EnvironmentNetworkEgressAllowlist{
                    Allowlist: genai.Ptr(interactions.NewAllowlist([]interactions.AllowlistEntry{
                        {Domain: "github.com", Credential: genai.Ptr("github-production")},
                        {Domain: "api.atlassian.com", Credential: genai.Ptr("jira-oauth")},
                        {Domain: "*.googleapis.com"},
                    })),
                })),
            })),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(res.Interaction.GetOutputText())
}

QETËSI

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" }
            ]
        }
    }
}'

Duke qenë se proxy-ja zgjidh kredencialet për çdo kërkesë, një kredencial i oauth2 rifreskon në mënyrë transparente kodin e qasjes. Një ndërveprim që zgjat për një kohë të gjatë nuk ndërpritet kur skadon kodi i qasjes.

Po kombinohen credential dhe transform

Rregullat e listës së lejimeve pranojnë gjithashtu një objekt të integruar transform që vendos drejtpërdrejt titujt në rregull. Të dyja mekanizmat zbatohen nga proxy i daljes në tel, kështu që në të dyja rastet vlera e kokës nuk ekziston kurrë brenda sandbox. Të dyja fushat mund të shfaqen në të njëjtin rregull.

Konfigurimi i rregullit Sjellja
Vetëm credential Proksi zgjidh kredencialet dhe fut titullin e tij në çdo kërkesë për te domeni.
Vetëm transform Injektimi i kokës statike. Kokat që shkruan dërgohen siç janë.
të dyja Kredenciali zbatohet i pari dhe më pas transform bashkohet në krye. Një titull i qartë transform fiton nëse të dy vendosin të njëjtin çelës.
Asnjëra Domeni lejohet dhe nuk injektohen tituj.

Kredencialet ia vlen të përdoren kur dëshiron të ruash një sekret një herë dhe t'i referohesh atij nga çdo mjedis, agjent dhe aktivizues në projektin tënd, si dhe kur dëshiron që rifreskimi dhe rotacioni i kodit të qasjes të menaxhohen për ty. Një transform i integruar përshtatet kur vlera i përket një telefonate të vetme, për shembull një kod që gjeneron vetë menjëherë para se të krijosh ndërveprimin.

Kombinimi i të dyjave është i zakonshëm. Kredenciali mbart kokën e vërtetimit dhe transform shton çdo gjë tjetër që shërbimi në rrjedhën e sipërme pret në të njëjtën kërkesë:

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

Për të zhvendosur një sekret nga një transform i integruar dhe në një kredencial, ruaje atë me POST /credentials, zëvendëso kokën e autentifikimit në transform me "credential": "<id>" dhe mos e prek pjesën tjetër të objektit transform.

Përdor kredencialet me serverët MCP

Serverët MCP në distancë marrin të njëjtin fushë credential. Vendose në një vegël mcp_server dhe proxy injekton titullin e vërtetimit në çdo kërkesë për atë server:

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",
    }],
});

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
            Agent: interactions.AgentOption("antigravity-preview-09-2026"),
            Input: interactions.NewInteractionsInput("Create a new issue in my-org/my-repo"),
            Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(interactions.Environment{
                Network: genai.Ptr(interactions.NewNetwork(interactions.EnvironmentNetworkEgressAllowlist{
                    Allowlist: genai.Ptr(interactions.NewAllowlist([]interactions.AllowlistEntry{
                        {Domain: "api.githubcopilot.com", Credential: genai.Ptr("github-production")},
                    })),
                })),
            })),
            Tools: []interactions.Tool{
                interactions.NewTool(interactions.MCPServer{
                    Name: genai.Ptr("github"),
                    URL:  genai.Ptr("https://api.githubcopilot.com/mcp"),
                }),
            },
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(res.Interaction.GetOutputText())
}

QETËSI

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"
        }
    ]
}'

credential dhe headers ndjekin të njëjtin rregull përparësie si lista e lejimeve. Kredenciali zbatohet i pari dhe headers bashkohet në krye, kështu që një titull i qartë fiton nëse të dy citojnë të njëjtin çelës:

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

Për të zhvendosur një sekret nga headers i integruar dhe në një kredencial, ruaje atë me POST /credentials dhe zëvendëso hyrjen e vërtetimit në headers me credential. Lëri titujt e tjerë aty ku janë.

Përdor kredencialet si ndryshore mjedisore

Disa biblioteka klientësh i lexojnë sekretet nga mjedisi i procesit në vend që t'i pranojnë ato si koka kërkesash. Klientët e modalitetit të prizës dhe të anketimit të gjatë janë rasti i zakonshëm.

Lidh një kredencial të environment_variable me një emër ndryshoreje nën 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" },
        },
    },
});

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateAgentInteraction{
            Agent: interactions.AgentOption("antigravity-preview-09-2026"),
            Input: interactions.NewInteractionsInput("Run the sync script and check notifications."),
            Environment: genai.Ptr(interactions.NewCreateAgentInteractionEnvironment(interactions.Environment{
                Env: genai.Ptr(interactions.NewEnv(map[string]interactions.EnvVar{
                    "NODE_ENV":        {Value: genai.Ptr("production")},
                    "SLACK_BOT_TOKEN": {Credential: genai.Ptr("slack-bot-token")},
                })),
            })),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(res.Interaction.GetOutputText())
}

QETËSI

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 pranon vargje fjalë për fjalë dhe referenca kredencialesh krah për krah. Një varg i mirëfilltë injektohet në kontejner si një ndryshore e zakonshme e tekstit të thjeshtë.

Një referencë kredenciale nuk është. Variabli merr vendmbajtësin __GEMINI_CRED_<credential-id>__ dhe ndërmjetësuesi zëvendëson sekretin e vërtetë vetëm për kërkesat dalëse që shkojnë në një domen në trusted_domains të kredencialeve. Një kërkesë për çdo domen tjetër refuzohet, kështu që sekreti nuk largohet asnjëherë nga perimetri dhe vendmbajtësi nuk dërgohet në vend të tij.

Cakto trusted_domains në çdo kredencial të environment_variable. Ai është kontrolli që përcakton fushëveprimet ku mund të përdoret sekreti.

Krijo një kredencial

Çdo kërkesë për krijim ka nevojë për një type, si dhe çdo fushë që kërkon ai lloj.

Kur telefonon drejtpërdrejt REST, të gjithë emrat e fushave përdorin snake_case. Dërgimi i një fushe camelCase rikthen një 400.

Tokeni i bartësit

Një kredencial i kodit të mbajtësit ka nevojë vetëm për 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",
});

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/credentials"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Credentials.Create(ctx, operations.CreateCredentialRequest{
        Body: credentials.NewCredentialCreateParams(credentials.HTTPBearerConfig{
            ID:    "github-production",
            Token: "ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Created credential: %s\n", res.Credential.ID)
}

QETËSI

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"
}'

Përgjigjja kthen vetëm metadata, asnjëherë kodin:

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

Si parazgjedhje, serveri proxy dërgon Authorization: Bearer <token>. Zëvendëso header_name dhe prefix për të synuar një shërbim që pret diçka tjetër:

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: "",
});

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/credentials"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Credentials.Create(ctx, operations.CreateCredentialRequest{
        Body: credentials.NewCredentialCreateParams(credentials.HTTPBearerConfig{
            ID:         "my-api-key",
            Token:      "key_xxxxxxxxxxxx",
            HeaderName: genai.Ptr("x-goog-api-key"),
            Prefix:     genai.Ptr(""),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Created credential: %s\n", res.Credential.ID)
}

QETËSI

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": ""
}'

Ky konfigurim prodhon titullin x-goog-api-key: key_xxxxxxxxxxxx.

Tabela e mëposhtme tregon se si kombinohen header_name dhe prefix:

Konfigurimi Koka e injektuar
{"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

Një kredencial OAuth2 kërkon client_id, client_secret, refresh_token dhe token_url. Fusha scopes është opsionale:

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"],
});

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/credentials"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Credentials.Create(ctx, operations.CreateCredentialRequest{
        Body: credentials.NewCredentialCreateParams(credentials.OAuth2Config{
            ID:           "jira-oauth",
            ClientID:     "my-client-id",
            ClientSecret: "my-client-secret",
            TokenURL:     "https://auth.atlassian.com/oauth/token",
            RefreshToken: "rt_xxxxxxxxxxxxxxxxxxxx",
            Scopes:       []string{"read:jira-work", "write:jira-work"},
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Created OAuth2 credential: %s\n", res.Credential.ID)
}

QETËSI

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"]
}'

Krijimi i një kredenciale OAuth2 kryen një shkëmbim të drejtpërdrejtë të tokenit kundrejt token_url për të konfirmuar që konfigurimi funksionon. Kredencialet ruhen vetëm nëse ofruesi kthen një përgjigje të suksesshme të kodit qasës që përmban një access_token. Pranohen përgjigjet në formatin JSON dhe form-urlencoded.

Kjo do të thotë që të duhet një kod i vlefshëm rifreskimi që nuk ka skaduar në kohën e krijimit. Nëse ofruesi e refuzon shkëmbimin, gabimi të kthehet ty:

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

Pasi të ruhet, ndërmjetësi rifreskon kodet e qasjes kur ato skadojnë. Nëse ofruesi rrotullon kodet e rifreskimit dhe kthen një të ri gjatë një rifreskimi, kodi i ri zëvendëson automatikisht kodin e ruajtur.

Ndryshorja e mjedisit

Një kredencial i environment_variable kërkon value dhe 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",
});

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/credentials"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Credentials.Create(ctx, operations.CreateCredentialRequest{
        Body: credentials.NewCredentialCreateParams(credentials.EnvironmentVariableConfig{
            ID:                "slack-bot-token",
            Value:             "xoxb-xxxxxxxxxxxx-xxxxxxxxxxxx",
            TrustedDomains:    []string{"*.slack.com", "slack.com"},
            InjectionLocation: credentials.NewEnvironmentVariableConfigInjectionLocation(credentials.InjectionLocationEnumHeader),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Created environment variable credential: %s\n", res.Credential.ID)
}

QETËSI

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"
}'

Fusha injection_location i tregon serverit proxy se ku në kërkesën dalëse të zëvendësojë sekretin. Ai pranon header, query ose body, si një varg të vetëm ose si një grup kur një shërbim ka nevojë për më shumë se një:

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

Zëvendësimi ndodh vetëm në vendndodhjet që ti liston. Një kërkesë që përmban vendmbajtësin kudo tjetër refuzohet në vend që të dërgohet.

Për të lidhur kredencialet me një emër ndryshoreje, shiko Përdor kredencialet si ndryshore mjedisore.

ID-të e gjeneruara

Fusha id është opsionale. Hiqe atë dhe shërbimi gjeneron një 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"
}

Jep ID-në tënde kur dëshiron një referencë të qëndrueshme dhe të lexueshme për ta përdorur nëpër ndërveprime. Duke qenë se ID-ja shfaqet në shtegun e burimit, prefero karaktere alfanumerike me shkronja të vogla me viza ndarëse ose viza të poshtme.

Listo kredencialet

Listo kredencialet që i përkasin projektit tënd. Përdor parametrat e faqëzimit për të kontrolluar madhësinë e grupit të përgjigjeve.

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}`);
}

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Credentials.List(ctx, operations.ListCredentialsRequest{
        PageSize: genai.Ptr(10),
    })
    if err != nil {
        log.Fatal(err)
    }

    for _, cred := range res.CredentialListResponse.Credentials {
        fmt.Printf("Credential ID: %s, Type: %v\n", cred.ID, cred.GetType())
    }
}

QETËSI

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

Përgjigjja përmban vetëm metadata:

{
  "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="
}

Kalo next_page_token prapa si page_token për të marrë faqen tjetër. Fusha lihet jashtë kur nuk ka rezultate të tjera.

Parametri Lloji Përshkrimi
page_size numër i plotë Numri maksimal i kredencialeve për faqe.
page_token varg Shenja nga next_page_token e një përgjigjeje të mëparshme.

Merr një kredencial

Merr metadatat për një kredencial specifik sipas ID-së së tij.

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}`);

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Credentials.Get(ctx, operations.GetCredentialRequest{
        ID: "github-production",
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Credential ID: %s, Status: %v\n", res.Credential.ID, res.Credential.GetStatus())
}

QETËSI

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

Përgjigjja duket e ngjashme me sa më poshtë:

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

Kërkimi i një kredenciale që nuk ekziston kthen 404:

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

Rrotullo një kredencial

Zëvendëso një sekret pa prekur asnjë rregull të listës së lejimeve, përkufizim të veglës ose ndryshore të mjedisit që i referohet atij. Rrotullimi zbatohet në rezolucionin e radhës të serverit proxy.

Kërkesa duhet të përfshijë type, si dhe fushat që dëshiron të ndryshosh. Fushat që heq i mbajnë vlerat e tyre aktuale.

Rrotullo një kod qasjeje:

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",
});

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/credentials"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Credentials.Update(ctx, operations.UpdateCredentialRequest{
        ID: "github-production",
        Body: credentials.NewCredentialUpdate(credentials.HTTPBearerUpdateConfig{
            Token: genai.Ptr("ghp_new_xxxxxxxxxxxxxxxxxxxx"),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Updated credential %s at %v\n", res.Credential.ID, res.Credential.GetUpdateTime())
}

QETËSI

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"
}'

Rrotullo një token rifreskimi 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",
});

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/credentials"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Credentials.Update(ctx, operations.UpdateCredentialRequest{
        ID: "jira-oauth",
        Body: credentials.NewCredentialUpdate(credentials.OAuth2UpdateConfig{
            RefreshToken: genai.Ptr("rt_new_xxxxxxxxxxxxxxxxxxxx"),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Updated credential %s at %v\n", res.Credential.ID, res.Credential.GetUpdateTime())
}

QETËSI

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"
}'

Përgjigjja pasqyron update_time të re:

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

type e një kredencialeje është e fiksuar pas krijimit. Për ta ndryshuar atë, fshi kredencialet dhe krijo të reja.

Fshi një kredencial

Fshi kredencialet dhe sekretin e tyre të ruajtur kur nuk nevojiten më.

Python

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

JavaScript

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

Go

package main

import (
    "context"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    _, err = client.Credentials.Delete(ctx, operations.DeleteCredentialRequest{
        ID: "github-production",
    })
    if err != nil {
        log.Fatal(err)
    }
}

QETËSI

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

Një fshirje e suksesshme kthen një objekt bosh:

{}

Çdo rregull i listës së lejimeve, vegël ose ndryshore mjedisore që i referohet ende ID-së nuk do të mund të zgjidhet, prandaj përditësoji ato në fillim.

Referenca e fushës

Fushat e përbashkëta për çdo kredencial:

Fusha Lloji Kërkohet Përshkrimi
id varg Jo Identifikues unik. Gjeneruar si UUID kur lihet jashtë.
type varg Po Një nga bearer_token, oauth2, environment_variable.
status varg Vetëm për lexim Statusi aktual i kredencialeve.
create_time varg Vetëm për lexim Vula kohore e krijimit RFC 3339.
update_time varg Vetëm për lexim Vula kohore RFC 3339 e përditësimit të fundit.

Fushat për bearer_token:

Fusha Lloji Kërkohet Përshkrimi
token varg Po Vetëm për shkrim. Vlera e kodit.
header_name varg Jo Koka e faqes për të injektuar. Si parazgjedhje përdoret Authorization.
prefix varg Jo Parashtesa e vlerës. Si parazgjedhje përdoret Bearer. Cakto në "" për asnjë.

Fushat për oauth2:

Fusha Lloji Kërkohet Përshkrimi
client_id varg Po ID-ja e klientit të OAuth2.
client_secret varg Po Vetëm për shkrim. Sekreti i klientit të OAuth2.
refresh_token varg Po Vetëm për shkrim. Kodi i rifreskimit i përdorur për të marrë kodet e qasjes.
token_url varg Po Pika përfundimtare e kodit të ofruesit.
scopes matrica Jo Fushëveprimet e OAuth për t'i kërkuar.

Fushat për environment_variable:

Fusha Lloji Kërkohet Përshkrimi
value varg Po Vetëm për shkrim. Vlera sekrete.
injection_location varg ose matricë Po Ku të zëvendësosh sekretin. Një ose më shumë nga header, query, body.
trusted_domains matrica Jo Modelet e domenit të autorizuara për zëvendësim.

Gabime

Gabimet kthejnë një objekt JSON me një message dhe një code:

{
  "error": {
    "message": "Credential 'github-production' already exists.; CreateCredential call failed",
    "code": "aborted"
  }
}
Statusi i HTTP-së code Shkaku
400 invalid_request Mungon fusha e kërkuar, fushë e panjohur, type e pambështetur ose një verifikim i dështuar i OAuth2.
404 not_found Nuk ka kredenciale me atë ID.
409 aborted Ekziston tashmë një kredencial me atë ID.

Fushat e panjohura refuzohen në vend që të shpërfillen dhe gabimi përmend fushën:

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

Çfarë ka më pas