[
 {
  "provider": "anthropic",
  "language": "python",
  "package": "anthropic",
  "version_seen": "1.7.0 (installed in .venv; docs: Python ≥3.10, v1 migration guide)",
  "install": "pip install anthropic  # extras: anthropic[bedrock], anthropic[vertex], anthropic[aws], anthropic[aiohttp]",
  "client": "from anthropic import Anthropic, AsyncAnthropic; client = Anthropic()  # reads ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN",
  "status": [
   "DOCUMENTED",
   "LIVE_VERIFIED"
  ],
  "source": "https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/python",
  "messages": {
   "create": "client.messages.create(model, max_tokens, messages, …, stream=False) -> Message | Stream[RawMessageStreamEvent]",
   "stream": "with client.messages.stream(...) as stream: stream.text_stream / for event in stream / stream.get_final_message() / stream.get_final_text() / stream.until_done() / stream.current_message_snapshot / stream.request_id",
   "parse": "client.messages.parse(..., output_format=PydanticModel) — structured outputs helper (translates to output_config.format)",
   "count_tokens": "client.messages.count_tokens(model, messages, system?, tools?, thinking?, output_config?) -> MessageTokensCount",
   "batches": "client.messages.batches.*"
  },
  "beta": "client.beta.messages.create(betas=[...]) / .stream / .parse / .count_tokens / .tool_runner(tools=[@beta_tool functions]) ; client.beta.models",
  "models": "client.models.list() (auto-paginates: for m in client.models.list()) / client.models.retrieve(id) / .has_next_page() / .get_next_page()",
  "completions_legacy": "REMOVED in 1.x: `Anthropic().completions` raises AttributeError (verified on 1.7.0)",
  "removed_params_1_7_0": "LIVE_DISCOVERED: messages.create/stream/parse and beta.messages.create in anthropic 1.7.0 have NO `temperature`, `top_p`, `top_k` keyword arguments (TypeError 'unexpected keyword argument'); pass them via extra_body={'temperature': 0.2} for models that still accept them. New kwargs: user_profile_id, workspace_id. count_tokens/stream still accept legacy `output_format`.",
  "retries": "DEFAULT_MAX_RETRIES=2; retries connection errors, 408, 409, 429, >=500 (and APITimeoutError); backoff INITIAL_RETRY_DELAY 0.5s → MAX_RETRY_DELAY 8s with jitter; honors retry-after; client option max_retries / with_options(max_retries=…)",
  "timeouts": "DEFAULT_TIMEOUT = httpx2.Timeout(connect=5, read=600, write=600, pool=600) i.e. 10 min; raises APITimeoutError; non-streaming requests expected >10 min raise ValueError unless stream=True or timeout overridden; MODEL_NONSTREAMING_TOKENS caps (Opus 4/4.1 ids: 8192)",
  "raw_response": "client.messages.with_raw_response.create(...) -> APIResponse (.headers, .parse()); with_streaming_response for lazy bodies; message._request_id",
  "errors": "APIError > APIStatusError(BadRequestError 400, AuthenticationError 401, PermissionDeniedError 403, NotFoundError 404, ConflictError 409, UnprocessableEntityError 422, RateLimitError 429, RequestTooLargeError 413, InternalServerError ≥500, OverloadedError 529, ServiceUnavailableError, DeadlineExceededError), APIConnectionError, APITimeoutError, plus WIF errors (CredentialsError, WorkloadIdentityError, IdentityTokenFileError)",
  "types": "request params = TypedDicts (anthropic.types.MessageParam, …); responses = Pydantic models (.model_dump(), .to_json(), model_extra for undocumented fields)",
  "headers": "sends anthropic-version 2023-06-01; default_headers / extra_headers / extra_body / extra_query for undocumented fields; client.get/post for undocumented endpoints",
  "middleware": "client.with_middleware([...]) / middleware=[] option; built-in refusal-fallback middleware",
  "cloud_clients": "AnthropicBedrockMantle (new Bedrock), AnthropicBedrock (bedrock-runtime), AnthropicVertex / AnthropicGoogleCloud, AnthropicAWS (beta, workspace_id / ANTHROPIC_AWS_WORKSPACE_ID), AnthropicFoundry — all in the base package, async twins",
  "logging": "ANTHROPIC_LOG=debug|info",
  "verification": {
   "method": "live_api",
   "verified_at": "2026-09-18",
   "result": "success",
   "http_status": 200,
   "request_note": "examples/anthropic/messages/*.py and streaming/*.py executed with .venv/bin/python (anthropic 1.7.0)"
  },
  "_fragment": "generated/fragments/sdks/anthropic-sdks.json"
 },
 {
  "provider": "anthropic",
  "language": "typescript",
  "package": "@anthropic-ai/sdk",
  "version_seen": "0.126.0 (installed in node_modules; docs: TS ≥5.0, Node 20+, Deno, Bun, Workers, Edge; browsers need dangerouslyAllowBrowser)",
  "install": "npm install @anthropic-ai/sdk",
  "client": "import Anthropic from '@anthropic-ai/sdk'; const client = new Anthropic({ apiKey?, authToken?, maxRetries?, timeout?, logLevel? })",
  "status": [
   "DOCUMENTED",
   "LIVE_VERIFIED"
  ],
  "source": "https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/typescript",
  "messages": {
   "create": "client.messages.create(params) -> Promise<Message> | (stream: true) -> Stream<RawMessageStreamEvent> (async iterable; stream.controller.abort())",
   "stream": "client.messages.stream(params) -> MessageStream: .on('text'|'message'|'contentBlock'|'streamEvent'|'error'|'finalMessage'), for await (const ev of stream), await stream.finalMessage(), stream.finalText(), stream.request_id",
   "countTokens": "client.messages.countTokens(params) -> MessageTokensCount",
   "batches": "client.messages.batches.*"
  },
  "beta": "client.beta.messages.create({betas: [...]}) / .stream / .countTokens / .toolRunner({tools: [betaTool|betaZodTool], …}) ; ToolError for tool failures; MCP helpers (convert MCP tools/prompts/resources)",
  "models": "client.models.list() (for await auto-pagination; .getNextPage()) / client.models.retrieve(id)",
  "completions_legacy": "client.completions.create({model, prompt, max_tokens_to_sample}) still typed in 0.126.0 (endpoint returns 400 deprecated live)",
  "retries": "maxRetries default 2; retries connection errors, 408, 409, 429, >=500; honors retry-after and x-should-retry",
  "timeouts": "DEFAULT_TIMEOUT 600000 ms (10 min); for non-streaming with large max_tokens the timeout scales: expected = 60min * max_tokens / 128000, and if expected > 10 min (or max_tokens > model non-streaming cap) it throws AnthropicError 'Streaming is required for operations that may take longer than 10 minutes'; APIConnectionTimeoutError on timeout",
  "raw_response": "await client.messages.create(...).asResponse() (headers only) / .withResponse() -> {data, response, request_id}; message._request_id",
  "errors": "APIError > BadRequestError, AuthenticationError, PermissionDeniedError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError; APIConnectionError, APIConnectionTimeoutError, APIUserAbortError, RetryableError, AnthropicError",
  "types": "import type { MessageParam, Message, RawMessageStreamEvent } from '@anthropic-ai/sdk/resources/messages'",
  "headers": "sends anthropic-version 2023-06-01; per-request { headers, query, body } options; // @ts-expect-error for undocumented params",
  "cloud_clients": "@anthropic-ai/vertex-sdk (AnthropicVertex), @anthropic-ai/bedrock-sdk (AnthropicBedrockMantle, AnthropicBedrock), @anthropic-ai/aws-sdk (AnthropicAws, beta), @anthropic-ai/foundry-sdk (AnthropicFoundry)",
  "logging": "ANTHROPIC_LOG or logLevel option: debug|info|warn(default)|error|off; custom logger",
  "verification": {
   "method": "live_api",
   "verified_at": "2026-09-18",
   "result": "success",
   "http_status": 200,
   "request_note": "examples *.ts executed with node --env-file=.env --experimental-strip-types (@anthropic-ai/sdk 0.126.0)"
  },
  "_fragment": "generated/fragments/sdks/anthropic-sdks.json"
 },
 {
  "provider": "anthropic",
  "language": "go",
  "package": "github.com/anthropics/anthropic-sdk-go",
  "version_seen": "docs: Go ≥1.24 (param.SetJSON needs ≥1.20.0)",
  "install": "go get github.com/anthropics/anthropic-sdk-go",
  "client": "client := anthropic.NewClient(option.WithAPIKey(...))",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/go",
  "messages": "client.Messages.New(ctx, anthropic.MessageNewParams{...}) ; client.Messages.NewStreaming(ctx, params) -> stream.Next()/Current(); message.Accumulate(event) ; client.Messages.CountTokens",
  "retries": "2 by default (connection errors, 408, 409, 429, >=500); option.WithMaxRetries",
  "timeouts": "non-streaming Messages: 10 min default; others none; context deadline or option.WithRequestTimeout (per retry)",
  "errors": "*anthropic.Error with StatusCode, Request, Response (errors.As); transport errors unwrapped (*url.Error)",
  "raw_response": "option.WithResponseInto(&httpResp) → Header.Get(\"request-id\")",
  "middleware": "option.WithMiddleware (client then method, concatenated)",
  "cloud_clients": "bedrock / vertex sub-packages",
  "_fragment": "generated/fragments/sdks/anthropic-sdks.json"
 },
 {
  "provider": "anthropic",
  "language": "java",
  "package": "com.anthropic:anthropic-java",
  "version_seen": "2.63.0 (docs); Java ≥8",
  "install": "implementation(\"com.anthropic:anthropic-java:2.63.0\")  // or Maven <dependency>",
  "client": "AnthropicClient client = AnthropicOkHttpClient.fromEnv(); AnthropicClientAsync async = AnthropicOkHttpClientAsync.fromEnv();",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/java",
  "messages": "client.messages().create(MessageCreateParams.builder()...build()) ; client.messages().createStreaming(params) -> StreamResponse<RawMessageStreamEvent> (try-with-resources, .stream()) ; MessageAccumulator.create().accumulate(event).message() ; client.async().messages().createStreaming(params).subscribe(...) ; countTokens ; batches",
  "retries": "maxRetries builder option (default 2)",
  "timeouts": "timeout builder option; 10 min default for non-streaming",
  "errors": "AnthropicException > AnthropicServiceException (HTTP: BadRequestException, AuthenticationException, PermissionDeniedException, NotFoundException, UnprocessableEntityException, RateLimitException, InternalServerException…), AnthropicIoException, AnthropicRetryableException, AnthropicInvalidDataException",
  "raw_response": "client.messages().withRawResponse().create(params) -> HttpResponseFor<Message> (.requestId(), .headers())",
  "pagination": "auto-paginating iterators for list endpoints",
  "_fragment": "generated/fragments/sdks/anthropic-sdks.json"
 },
 {
  "provider": "anthropic",
  "language": "ruby",
  "package": "anthropic (gem)",
  "version_seen": "docs (Sorbet types)",
  "install": "bundle add anthropic",
  "client": "client = Anthropic::Client.new(api_key: ENV['ANTHROPIC_API_KEY'])",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/ruby",
  "messages": "client.messages.create(model:, max_tokens:, messages:) ; client.messages.stream(...) → stream.text / .accumulated_message ; client.messages.count_tokens",
  "retries": "max_retries (default 2) on client or request_options: {max_retries:}",
  "timeouts": "timeout: (default 10 min) client or request_options",
  "errors": "Anthropic::Errors::APIError > BadRequestError 400, AuthenticationError 401, PermissionDeniedError 403, NotFoundError 404, ConflictError 409, UnprocessableEntityError 422, RateLimitError 429, InternalServerError ≥500, APIStatusError (other), APITimeoutError, APIConnectionError",
  "raw_response": "per-request middleware (request_options: {middleware: [...]}) to read response.headers['request-id']",
  "_fragment": "generated/fragments/sdks/anthropic-sdks.json"
 },
 {
  "provider": "anthropic",
  "language": "csharp",
  "package": "Anthropic (NuGet)",
  "version_seen": "≥10 is the official SDK (≤3.x was tryAGI); .NET Standard 2.0+",
  "install": "dotnet add package Anthropic",
  "client": "AnthropicClient client = new() { MaxRetries = 3, Timeout = TimeSpan.FromSeconds(42) };",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/csharp",
  "messages": "await client.Messages.Create(new MessageCreateParams {...}) ; await foreach (var ev in client.Messages.CreateStreaming(parameters)) ; .CreateStreaming(p).Aggregate() → Message ; MessageContentAggregator with .CollectAsync() ; client.WithRawResponse.Messages.Create(...) → response.RequestID ; IChatClient integration",
  "retries": "MaxRetries default 2 (client or `options with { MaxRetries = 3 }`)",
  "timeouts": "Timeout property",
  "errors": "AnthropicApiException (AnthropicBadRequestException 400, AnthropicUnauthorizedException 401, AnthropicForbiddenException 403, AnthropicNotFoundException 404, AnthropicUnprocessableEntityException 422, AnthropicRateLimitException 429, Anthropic5xxException; all 4xx inherit Anthropic4xxException), AnthropicSseException (mid-stream), AnthropicIOException",
  "_fragment": "generated/fragments/sdks/anthropic-sdks.json"
 },
 {
  "provider": "anthropic",
  "language": "php",
  "package": "anthropic-ai/sdk",
  "version_seen": "beta (docs: APIs may change); PSR-18 client, Guzzle recommended",
  "install": "composer require \"anthropic-ai/sdk\" \"guzzlehttp/guzzle:^7\"",
  "client": "$client = new Anthropic\\Client(apiKey: ...);",
  "status": [
   "DOCUMENTED",
   "BETA"
  ],
  "source": "https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/php",
  "messages": "$client->messages->create(model:, maxTokens:, messages:) ; $client->messages->createStream(...) foreach $event ; Anthropic\\Lib\\Streaming\\MessageAccumulator::forMessages()->accumulate($event)->message() ; $client->messages->raw->create(...) → getHeaderLine('request-id')",
  "retries": "RequestOptions::with(maxRetries: n) (default 2; connection errors, 408, 409, 429, >=500, timeouts)",
  "errors": "APIStatusException (other HTTP), APITimeoutException, APIConnectionException (+ per-status subclasses)",
  "streaming_note": "requires an incremental PSR-18 client; buffering clients yield all events at once",
  "_fragment": "generated/fragments/sdks/anthropic-sdks.json"
 },
 {
  "provider": "anthropic",
  "language": "cli",
  "package": "ant (anthropic-cli)",
  "version_seen": "1.33.0 in docs (ant apply ≥1.30.0, sessions connect ≥1.32.0)",
  "install": "brew install anthropics/tap/ant  |  release tarball from github.com/anthropics/anthropic-cli/releases  |  go install github.com/anthropics/anthropic-cli/cmd/ant@latest",
  "client": "ant auth login (OAuth, workspace-scoped token) | ANTHROPIC_API_KEY | --api-key | ANTHROPIC_AUTH_TOKEN | WIF profiles (ant profile set …)",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://platform.claude.com/docs/en/cli-sdks-libraries/cli/quickstart",
  "messages": "ant messages create --model claude-opus-5 --max-tokens 1024 --message '{role: user, content: \"Hello\"}' [--system @file.md] [--tool …] [--stream --format jsonl] [--beta a,b] [--workspace-id wrkspc_…]",
  "count_tokens": "ant messages count-tokens … (resource action pattern; beta: prefix for beta resources adds the header automatically)",
  "models": "ant models list | ant models retrieve <id>",
  "global_flags": "--profile, --format auto|json|jsonl|yaml|pretty|raw|explore, --transform <GJSON>, -r/--raw-output, --base-url, --workspace-id, --debug (prints request/response, keys redacted), --format-error, --transform-error",
  "input": "flags for scalars; stdin JSON/YAML document (heredoc) merged with flags (flags win); @path inlines file contents (binary auto base64; @file:// / @data:// force; \\@ escapes)",
  "auth_commands": "ant auth login [--scope org:admin] | ant auth status | ant auth logout [--all] | ant auth print-credentials --access-token (use as Authorization: Bearer for curl)",
  "other": "ant apply (agents/environments/skills/memory stores/deployments as files, claude-lock.json, --dry-run --yes --force --prune) ; ant beta:sessions connect --session-id … [--web] ; ant @completion zsh|bash|fish|powershell",
  "verification": {
   "method": "docs_only",
   "verified_at": "2026-09-18",
   "result": "skipped",
   "http_status": null,
   "request_note": "ant not installed locally; documented only"
  },
  "_fragment": "generated/fragments/sdks/anthropic-sdks.json"
 },
 {
  "provider": "anthropic",
  "language": "libraries",
  "package": "openai-sdk compatibility / apple-foundation-models",
  "version_seen": "n/a",
  "install": "see pages",
  "client": "OpenAI SDK pointed at the Claude API compatibility layer; Swift package for Apple LanguageModelSession",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://platform.claude.com/docs/en/cli-sdks-libraries/libraries/openai-sdk",
  "note": "Not general-purpose Messages clients; documented under cli-sdks-libraries/libraries.",
  "_fragment": "generated/fragments/sdks/anthropic-sdks.json"
 },
 {
  "provider": "gemini",
  "language": "python",
  "package": "google-genai",
  "version_seen": "2.24.0 (installed in .venv; pyproject requires-python >=3.10)",
  "install": "pip install google-genai   # extras: google-genai[aiohttp] for a faster async transport",
  "client": "from google import genai; client = genai.Client()  # reads GEMINI_API_KEY / GOOGLE_API_KEY (GOOGLE_API_KEY wins if both set); genai.Client(api_key=...) explicit; genai.Client(vertexai=True, project=..., location=...) or env GOOGLE_GENAI_USE_VERTEXAI=true + GOOGLE_CLOUD_PROJECT + GOOGLE_CLOUD_LOCATION for Gemini Enterprise Agent Platform (Vertex AI)",
  "status": [
   "DOCUMENTED",
   "LIVE_VERIFIED"
  ],
  "source": "https://ai.google.dev/gemini-api/docs/libraries",
  "http_options": "types.HttpOptions(api_version='v1'|'v1beta'(default)|'v1alpha', base_url=, base_url_resource_scope=, headers={}, timeout=<ms>, client_args={}, async_client_args={}, extra_body={}, retry_options=HttpRetryOptions(attempts, initial_delay, max_delay, exp_base, jitter, http_status_codes), httpx_client=, httpx_async_client=); per-request via config=types.GenerateContentConfig(http_options=...)",
  "retries": "Automatic exponential backoff for transient errors (429, 5xx, timeouts, network): default up to 4 attempts, initial delay ~1 s, max 60 s (troubleshooting.md); tune with HttpRetryOptions",
  "models": "client.models.generate_content(model, contents, config=GenerateContentConfig(system_instruction, temperature, max_output_tokens, thinking_config=ThinkingConfig(thinking_level|thinking_budget, include_thoughts), response_mime_type, response_schema|response_json_schema, tools=[Tool(google_search=..., code_execution=..., url_context=..., function_declarations=...)], cached_content, safety_settings, media_resolution, ...)) -> GenerateContentResponse (.text, .parsed, .candidates, .usage_metadata); generate_content_stream(...) -> iterator of chunks; count_tokens / compute_tokens; embed_content(model, contents, config=EmbedContentConfig(task_type, output_dimensionality)); list() / get(model=) -> types.Model (name, display_name, version, input_token_limit, output_token_limit, supported_actions, temperature, max_temperature, ...); generate_images / edit_image / upscale_image (Imagen, retired on Gemini API); generate_videos (Veo, long-running operation polled via client.operations.get)",
  "async": "client.aio.models.generate_content(...) / async for chunk in await client.aio.models.generate_content_stream(...); aiohttp transport via google-genai[aiohttp]",
  "chats": "client.chats.create(model=) -> chat.send_message / send_message_stream (client-side history)",
  "files": "client.files.upload(file=path|IO, config=UploadFileConfig(display_name, mime_type)); files.get / list / delete; files.download(file=) for generated files (Batch output)",
  "caches": "client.caches.create(model=, config=CreateCachedContentConfig(contents, system_instruction, ttl|expire_time, display_name)); caches.get/list/update/delete; use via GenerateContentConfig(cached_content=cache.name). Explicit caching is generateContent-only (Interactions API supports implicit caching only)",
  "interactions": "client.interactions.create(model=|agent=, input=, previous_interaction_id=, background=, store=, stream=, generation_config={'thinking_level':...}, tools=[...]) -> Interaction (.output_text, .steps, .id); interactions.get(id); interactions.cancel; SDK >= 1.55.0 required",
  "live": "async with client.aio.live.connect(model=, config=LiveConnectConfig(response_modalities, speech_config, session_resumption, context_window_compression, ...)) as session: session.send_client_content / send_realtime_input / receive(); client.auth_tokens.create(...) for ephemeral tokens (Live only); client.aio.live.music.connect(...) for Lyria RealTime",
  "batches": "client.batches.create(model=, src=file name | inline requests, config=CreateBatchJobConfig(display_name)); batches.get/list/cancel/delete; embeddings batches via asyncBatchEmbedContent",
  "file_search": "client.file_search_stores.create / upload_to_file_search_store / import_file / documents.*; tool Tool(file_search=FileSearch(file_search_store_names=[...]))",
  "tunings": "client.tunings.tune(...) exists in the SDK for Vertex AI; no tunable model is offered on the Gemini Developer API",
  "function_calling": "Automatic Python function calling: pass Python callables in tools=[fn]; disable with automatic_function_calling=AutomaticFunctionCallingConfig(disable=True); tool_config=ToolConfig(function_calling_config=FunctionCallingConfig(mode='ANY', allowed_function_names=[...])); MCP: pass an mcp ClientSession as a tool (experimental)",
  "structured_output": "response_mime_type='application/json' + response_schema=Pydantic model | types.Schema, or response_json_schema=<JSON Schema dict> (recommended on Gemini 3); response.parsed",
  "errors": "google.genai.errors.APIError (code, message, status, details), ClientError (4xx), ServerError (5xx); FunctionInvocationError",
  "openai_compat": "Not part of google-genai; use `openai` SDK with base_url='https://generativelanguage.googleapis.com/v1beta/openai/' and api_key=GEMINI_API_KEY",
  "legacy": "google-generativeai (import google.generativeai) deprecated 2025-11-30; migrate guide: https://ai.google.dev/gemini-api/docs/migrate",
  "_fragment": "generated/fragments/sdks/gemini-sdks.json"
 },
 {
  "provider": "gemini",
  "language": "typescript",
  "package": "@google/genai",
  "version_seen": "2.23.0 (installed in node_modules; package.json version 2.23.0)",
  "install": "npm install @google/genai",
  "client": "import { GoogleGenAI } from '@google/genai'; const ai = new GoogleGenAI({ apiKey?, vertexai?, project?, location?, httpOptions?: { apiVersion, baseUrl, headers, timeout } })  // Node reads GEMINI_API_KEY / GOOGLE_API_KEY (GOOGLE_API_KEY precedence); GOOGLE_GENAI_USE_VERTEXAI=true switches backend; browser: identical init but never ship a long-lived key - use ephemeral tokens for Live",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://ai.google.dev/gemini-api/docs/libraries",
  "http_options": "httpOptions: { apiVersion: 'v1' | 'v1beta' (default) | 'v1alpha', baseUrl, headers, timeout }",
  "models": "ai.models.generateContent({ model, contents, config: { systemInstruction, thinkingConfig: { thinkingLevel | thinkingBudget, includeThoughts }, responseMimeType, responseJsonSchema | responseSchema, tools: [{ googleSearch: {} }, { codeExecution: {} }, { urlContext: {} }, { functionDeclarations: [...] }], cachedContent, safetySettings, maxOutputTokens, ... } }) -> response.text / response.candidates / response.usageMetadata; generateContentStream -> async iterable; countTokens; computeTokens (Vertex); embedContent({ model, contents, config: { taskType, outputDimensionality } }); models.list() (pager) / models.get({ model }); generateVideos (Veo LRO) + operations.getVideosOperation; generateImages (Imagen, retired on Gemini API)",
  "chats": "ai.chats.create({ model, history }) -> chat.sendMessage / sendMessageStream",
  "files": "ai.files.upload({ file: path | Blob, config: { mimeType, displayName } }); files.get / list / delete / download",
  "caches": "ai.caches.create({ model, config: { contents, systemInstruction, ttl } }); get / list / update / delete",
  "interactions": "ai.interactions.create({ model | agent, input, previous_interaction_id, background, store, stream, generation_config, tools }) -> interaction.output_text / .steps; interactions.get(id); SDK >= 1.33.0",
  "live": "const session = await ai.live.connect({ model, config: { responseModalities, speechConfig, sessionResumption: { handle }, contextWindowCompression }, callbacks: { onopen, onmessage, onerror, onclose } }); session.sendClientContent / sendRealtimeInput / sendToolResponse / close(); ai.authTokens.create(...) for ephemeral tokens; ai.live.music.connect for Lyria RealTime",
  "batches": "ai.batches.create({ model, src, config }) / get / list / cancel / delete",
  "file_search": "ai.fileSearchStores.create / uploadToFileSearchStore / importFile / documents.*",
  "errors": "ApiError { status, message } thrown for non-2xx; streaming errors surface when iterating",
  "function_calling": "functionDeclarations with JSON-schema parameters; toolConfig: { functionCallingConfig: { mode: 'ANY' | 'AUTO' | 'NONE', allowedFunctionNames } }; MCP via mcpToTool(client) (experimental)",
  "legacy": "@google/generative-ai (google-gemini/generative-ai-js) deprecated 2025-11-30 - not actively maintained; @google/generative_language and @google-cloud/vertexai are previous-generation SDKs",
  "_fragment": "generated/fragments/sdks/gemini-sdks.json"
 },
 {
  "provider": "gemini",
  "language": "go",
  "package": "google.golang.org/genai",
  "version_seen": "not installed here",
  "install": "go get google.golang.org/genai",
  "client": "client, err := genai.NewClient(ctx, &genai.ClientConfig{APIKey: os.Getenv(\"GEMINI_API_KEY\"), Backend: genai.BackendGeminiAPI})  // Vertex: Project, Location, Backend: genai.BackendVertexAI",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://ai.google.dev/gemini-api/docs/libraries",
  "models": "client.Models.GenerateContent(ctx, model, genai.Text(...), config) / GenerateContentStream / CountTokens / EmbedContent / List(ctx, &genai.ListModelsConfig{}) (Items[].SupportedActions) / Get",
  "legacy": "github.com/google/generative-ai-go deprecated 2025-11-30",
  "_fragment": "generated/fragments/sdks/gemini-sdks.json"
 },
 {
  "provider": "gemini",
  "language": "java",
  "package": "com.google.genai:google-genai",
  "version_seen": "docs snippet pins 1.0.0 (Maven); current releases include the Interactions client com.google.genai.gaos.models.interactions.*",
  "install": "Maven dependency com.google.genai:google-genai",
  "client": "Client client = Client.builder().apiKey(\"...\").httpOptions(HttpOptions.builder().apiVersion(\"v1\").build()).build(); or new Client() reading GOOGLE_API_KEY/GEMINI_API_KEY; Vertex: .vertexAI(true).project().location()",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://ai.google.dev/gemini-api/docs/libraries",
  "models": "client.models.generateContent(model, contents, GenerateContentConfig) / generateContentStream / countTokens / embedContent; client.interactions.create(CreateInteractionRequestBody.of(CreateModelInteraction.builder().model(Model.of(\"gemini-3.8-flash\")).input(InteractionsInput.of(...)).generationConfig(GenerationConfig.builder().thinkingLevel(ThinkingLevel.LOW)).serviceTier(ServiceTier.FLEX)))",
  "legacy": "no legacy Google Java SDK existed",
  "_fragment": "generated/fragments/sdks/gemini-sdks.json"
 },
 {
  "provider": "gemini",
  "language": "csharp",
  "package": "Google.GenAI",
  "version_seen": "not installed here",
  "install": "dotnet add package Google.GenAI",
  "client": "new Client() / Client with apiKey; repo googleapis/dotnet-genai",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://ai.google.dev/gemini-api/docs/libraries",
  "_fragment": "generated/fragments/sdks/gemini-sdks.json"
 },
 {
  "provider": "gemini",
  "language": "rest",
  "package": "curl / any HTTP client",
  "version_seen": "v1beta (default in SDKs), v1 (stable), v1alpha (SDK-selectable, undocumented surface)",
  "install": "n/a",
  "client": "curl https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent -H 'x-goog-api-key: $GEMINI_API_KEY' -H 'Content-Type: application/json' -d '{\"contents\":[{\"parts\":[{\"text\":\"...\"}]}]}' ; streaming: ...:streamGenerateContent?alt=sse ; Interactions: POST /v1beta/interactions ; Live: WSS wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent (key via query or ephemeral token) ; uploads: /upload/v1beta/files (resumable X-Goog-Upload-*) ; downloads: /download/v1beta/files/{name}:download?alt=media",
  "status": [
   "DOCUMENTED",
   "LIVE_VERIFIED"
  ],
  "source": "https://ai.google.dev/api",
  "_fragment": "generated/fragments/sdks/gemini-sdks.json"
 },
 {
  "provider": "gemini",
  "language": "openai-compatible",
  "package": "openai (Python 3.16.2 installed in .venv) / openai (Node)",
  "version_seen": "beta compatibility layer",
  "install": "pip install openai / npm install openai",
  "client": "OpenAI(api_key=GEMINI_API_KEY, base_url='https://generativelanguage.googleapis.com/v1beta/openai/')  # key MUST travel as Authorization: Bearer",
  "status": [
   "DOCUMENTED",
   "LIVE_VERIFIED"
  ],
  "source": "https://ai.google.dev/gemini-api/docs/openai",
  "supports": "chat.completions (streaming, function calling/tools, image_url, input_audio, response_format JSON schema via beta.chat.completions.parse, reasoning_effort -> thinking_level/budget, service_tier flex|priority, n, stream_options.include_usage, extra_body.google.{thinking_config,cached_content}); embeddings; images.generate (gemini-2.5-flash-image, gemini-3-pro-image-preview; n, size, response_format, extra_body aspect_ratio/generation_config/safety_settings/tools); videos.create/retrieve (veo-3.1-generate-preview; Sora-style LRO); batches.create/retrieve (files must be uploaded/downloaded with the genai SDK); models.list / models.retrieve. Responses API, audio.speech, audio.transcriptions, files, fine-tuning, moderations: not documented",
  "live_2026_09_19": "chat.completions gemini-3.5-flash-lite -> 200 {choices[0].message.content:'OK.', extra_content.google.thought_signature, finish_reason:'stop', usage:{prompt_tokens:5,completion_tokens:2,total_tokens:7}}; GET /openai/models -> 58 ids (object 'list', ids prefixed 'models/'); GET /openai/models/gemini-3.8-flash -> {id:'models/gemini-3.8-flash', object:'model', owned_by:'google', display_name}",
  "_fragment": "generated/fragments/sdks/gemini-sdks.json"
 },
 {
  "provider": "gemini",
  "language": "apps-script / firebase / other",
  "package": "Firebase AI Logic (Web, iOS, Android, Flutter), Genkit (Dart/JS/Go), Vercel AI SDK, LangGraph, CrewAI, LlamaIndex, Temporal examples",
  "version_seen": "n/a",
  "install": "see framework docs",
  "client": "Client-side mobile/web apps should use Firebase AI Logic (App Check, no exposed key) rather than the raw key; docs pages: vercel-ai-sdk-example, langgraph-example, crewai-example, llama-index, temporal-example",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://ai.google.dev/gemini-api/docs/libraries",
  "_fragment": "generated/fragments/sdks/gemini-sdks.json"
 },
 {
  "provider": "openai",
  "language": "python",
  "package": "openai (PyPI)",
  "repo": "https://github.com/openai/openai-python",
  "version_seen": "3.16.2 (installed in .venv; pyproject in sources/openai/openapi/python-sdk-pyproject.toml)",
  "admin_api_support_since": "2.34.0",
  "requires": "Python >= 3.9; httpx, pydantic v2",
  "install": "pip install openai   # or: uv pip install openai",
  "client": "from openai import OpenAI\nclient = OpenAI()  # reads OPENAI_API_KEY; optional: api_key=, admin_api_key= (OPENAI_ADMIN_KEY), organization= (OPENAI_ORG_ID), project= (OPENAI_PROJECT_ID), webhook_secret= (OPENAI_WEBHOOK_SECRET), workload_identity=, base_url= (OPENAI_BASE_URL), timeout=, max_retries=, default_headers=, http_client=",
  "async": "from openai import AsyncOpenAI\nclient = AsyncOpenAI(); resp = await client.responses.create(...)  # every resource has an async twin; async streams use `async for`/`async with`",
  "streaming": "stream = client.responses.create(..., stream=True); for event in stream: ...  |  helper: with client.responses.stream(...) as s: for event in s: ...; s.get_final_response()  |  chat: client.chat.completions.stream(...) ; beta.chat.completions.parse for structured outputs",
  "retries": {
   "default_max_retries": 2,
   "retried_statuses": [
    "408",
    "409",
    "429",
    ">=500",
    "connection errors"
   ],
   "backoff": "exponential from INITIAL_RETRY_DELAY=0.5 s to MAX_RETRY_DELAY=8 s with jitter; honours `retry-after-ms` then `Retry-After` (seconds or HTTP-date) if <= 60 s; `x-should-retry: true|false` header overrides",
   "configure": "OpenAI(max_retries=5) or client.with_options(max_retries=0).responses.create(...)"
  },
  "timeouts": {
   "default": "httpx.Timeout(timeout=600, connect=5.0) — 10 min total, 5 s connect",
   "configure": "OpenAI(timeout=20.0) or with_options(timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0)); APITimeoutError raised on expiry (retried by default)"
  },
  "raw_response": "resp = client.responses.with_raw_response.create(...); resp.headers['x-request-id']; parsed = resp.parse()   |  streaming body: client.files.with_streaming_response.content(id)",
  "request_id": "response._request_id (set from the x-request-id header on every parsed object); on errors: e.request_id",
  "pagination": "Auto-iterate: for job in client.fine_tuning.jobs.list(limit=20): ...  (SyncPage/SyncCursorPage/SyncConversationCursorPage/SyncNextCursorPage; .has_next_page(), .get_next_page(), .iter_pages()); async: async for x in client....list()",
  "types": "Pydantic models under openai.types.* (e.g. openai.types.responses.Response); request params as TypedDicts (openai.types.*_params); `model_dump()` / `.to_dict()`; NotGiven sentinel `openai.NOT_GIVEN`",
  "errors": "openai.APIError base; APIStatusError subclasses: BadRequestError(400), AuthenticationError(401), PermissionDeniedError(403), NotFoundError(404), ConflictError(409), UnprocessableEntityError(422), RateLimitError(429), InternalServerError(>=500 incl. 503); APIConnectionError, APITimeoutError; InvalidWebhookSignatureError. Attributes: .status_code, .code, .param, .type, .body, .request_id, .response",
  "webhooks": "client.webhooks.unwrap(payload: str|bytes, headers, *, secret=None) -> typed UnwrapWebhookEvent (raises InvalidWebhookSignatureError); client.webhooks.verify_signature(payload, headers, *, secret=None, tolerance=300); webhook endpoints CRUD: client.webhooks.create/retrieve/update/list/delete/rotate_secret/test, client.webhooks.event_types.list()",
  "admin": "client = OpenAI(admin_api_key=os.environ['OPENAI_ADMIN_KEY']); client.admin.organization.{users,invites,projects,audit_logs,admin_api_keys,usage,roles,groups,spend_limit,spend_alerts,data_retention,certificates}... and client.admin.organization.projects.{api_keys,service_accounts,users,groups,rate_limits,model_permissions,hosted_tool_permissions,spend_alerts,spend_limit,data_retention,certificates}",
  "azure": "from openai import AzureOpenAI, AsyncAzureOpenAI — AzureOpenAI(api_version=..., azure_endpoint=..., api_key= or azure_ad_token_provider=); same resource surface with deployment names as `model`",
  "realtime": "client.realtime.connect(model=...) / AsyncOpenAI().realtime.connect(...) websocket context manager (async with ... as conn: await conn.session.update(...); async for event in conn)",
  "agents_sdk": "Separate package `openai-agents` (https://github.com/openai/openai-agents-python) for code-first orchestration (agents, tools, handoffs, guardrails, tracing)",
  "logging": "OPENAI_LOG=debug|info env var",
  "docs_url": "https://developers.openai.com/api/docs/libraries#install-an-official-sdk",
  "status": [
   "DOCUMENTED",
   "LIVE_VERIFIED"
  ],
  "verification": {
   "method": "sdk_types",
   "verified_at": "2026-09-18",
   "result": "success",
   "request_note": "constants read from installed openai 3.16.2 (_constants.py, _client.py, lib/_webhooks.py); webhooks.unwrap exercised offline in examples/openai/webhooks/offline_test.py"
  },
  "sources": [
   {
    "url": "https://developers.openai.com/api/docs/libraries",
    "retrieved_at": "2026-09-19T01:31:00Z"
   },
   {
    "url": "https://developers.openai.com/api/docs/guides/admin-apis",
    "retrieved_at": "2026-09-19T01:31:00Z"
   },
   {
    "url": "https://github.com/openai/openai-python",
    "retrieved_at": "2026-09-18"
   }
  ],
  "_fragment": "generated/fragments/sdks/openai-sdks.json"
 },
 {
  "provider": "openai",
  "language": "typescript/javascript",
  "package": "openai (npm)",
  "repo": "https://github.com/openai/openai-node",
  "version_seen": "7.18.0 installed in node_modules; 7.19.0 in sources/openai/openapi/node-sdk-package.json",
  "admin_api_support_since": "6.36.0",
  "requires": "Node >= 22 (engines), also Deno, Bun, Cloudflare Workers, Vercel Edge, browsers (dangerouslyAllowBrowser: true)",
  "install": "npm install openai   # pnpm add openai / yarn add openai / deno add jsr:@openai/openai",
  "client": "import OpenAI from 'openai';\nconst client = new OpenAI(); // reads OPENAI_API_KEY; options: apiKey, adminAPIKey (OPENAI_ADMIN_KEY), organization (OPENAI_ORG_ID), project (OPENAI_PROJECT_ID), webhookSecret (OPENAI_WEBHOOK_SECRET), workloadIdentity, baseURL (OPENAI_BASE_URL), timeout, maxRetries, defaultHeaders, defaultQuery, fetch, fetchOptions, logLevel, logger",
  "async": "All methods return Promises (APIPromise); no separate async client",
  "streaming": "const stream = await client.responses.create({..., stream: true}); for await (const event of stream) {...}  |  helpers: client.responses.stream({...}).on('response.output_text.delta', ...) ; await stream.finalResponse(); client.chat.completions.stream(...); stream.controller.abort()",
  "retries": {
   "default_max_retries": 2,
   "retried_statuses": [
    "408",
    "409",
    "429",
    ">=500",
    "connection errors"
   ],
   "backoff": "exponential with jitter (0.5 s .. 8 s), honours retry-after-ms / Retry-After when <= 60 s, x-should-retry header",
   "configure": "new OpenAI({ maxRetries: 0 }) or per request: client.responses.create({...}, { maxRetries: 5 })"
  },
  "timeouts": {
   "default": "600000 ms (10 minutes) — OpenAI.DEFAULT_TIMEOUT",
   "configure": "new OpenAI({ timeout: 20 * 1000 }) or per request { timeout: 5000 }; throws APIConnectionTimeoutError (retried by default)"
  },
  "raw_response": "const { data, response } = await client.responses.create({...}).withResponse(); response.headers.get('x-request-id')  |  const raw = await client.responses.create({...}).asResponse()  (fetch Response)",
  "request_id": "result._request_id (from x-request-id) on every top-level response object; error.requestID on APIError",
  "pagination": "for await (const job of client.fineTuning.jobs.list({ limit: 20 })) {...}  |  manual: let page = await client....list(); while (page.hasNextPage()) { page = await page.getNextPage(); }",
  "types": "TypeScript types exported from 'openai/resources/*' (e.g. import type { Response } from 'openai/resources/responses'); zodResponseFormat / zodTextFormat helpers in 'openai/helpers/zod'",
  "errors": "OpenAI.APIError base with .status, .code, .type, .param, .error, .requestID, .headers; subclasses BadRequestError(400) AuthenticationError(401) PermissionDeniedError(403) NotFoundError(404) ConflictError(409) UnprocessableEntityError(422) RateLimitError(429) InternalServerError(>=500) APIConnectionError APIConnectionTimeoutError APIUserAbortError InvalidWebhookSignatureError",
  "webhooks": "await client.webhooks.unwrap(rawBody: string, headers, secret?, tolerance = 300) -> typed event (throws OpenAI.InvalidWebhookSignatureError); await client.webhooks.verifySignature(rawBody, headers, secret?, tolerance?); endpoints: client.webhooks.create/retrieve/update/list/delete/rotateSecret/test; client.webhooks.eventTypes.list()",
  "admin": "const client = new OpenAI({ adminAPIKey: process.env.OPENAI_ADMIN_KEY }); client.admin.organization.users.list(), .invites.create(), .projects.modelPermissions.update(id, {...}), .spendAlerts.create(...), .dataRetention.update(...), .auditLogs.list({ limit: 10 }), .usage.completions({ start_time }), .usage.costs({ start_time })",
  "azure": "import { AzureOpenAI } from 'openai'; new AzureOpenAI({ apiVersion, endpoint, azureADTokenProvider? }) ; also 'openai/bedrock' shim present in the package",
  "realtime": "import { OpenAIRealtimeWebSocket } from 'openai/realtime/websocket' (server) / OpenAIRealtimeWS ('openai/realtime/ws'); browser WebRTC via ephemeral client secrets",
  "agents_sdk": "Separate package `@openai/agents` (https://github.com/openai/openai-agents-js)",
  "logging": "logLevel: 'debug' option or OPENAI_LOG=debug",
  "docs_url": "https://developers.openai.com/api/docs/libraries#install-an-official-sdk",
  "status": [
   "DOCUMENTED",
   "LIVE_VERIFIED"
  ],
  "verification": {
   "method": "sdk_types",
   "verified_at": "2026-09-18",
   "result": "success",
   "request_note": "constants read from node_modules/openai/client.js (DEFAULT_TIMEOUT=600000, maxRetries=2); webhooks.unwrap exercised offline in examples/openai/webhooks/offline_test.ts"
  },
  "sources": [
   {
    "url": "https://developers.openai.com/api/docs/libraries",
    "retrieved_at": "2026-09-19T01:31:00Z"
   },
   {
    "url": "https://github.com/openai/openai-node",
    "retrieved_at": "2026-09-18"
   }
  ],
  "_fragment": "generated/fragments/sdks/openai-sdks.json"
 },
 {
  "provider": "openai",
  "language": "csharp/.net",
  "package": "OpenAI (NuGet)",
  "repo": "https://github.com/openai/openai-dotnet",
  "version_seen": "not pinned in docs (current 2.x line); API surface uses OPENAI001 experimental attribute for Responses",
  "install": "dotnet add package OpenAI",
  "client": "using OpenAI.Responses; ResponsesClient client = new(Environment.GetEnvironmentVariable(\"OPENAI_API_KEY\")!); ResponseResult r = await client.CreateResponseAsync(\"gpt-6-astra\", \"Say hi\");",
  "async": "Async/await APIs (…Async) plus sync twins",
  "streaming": "CreateResponseStreamingAsync(...) returns IAsyncEnumerable<StreamingResponseUpdate>",
  "retries": {
   "default_max_retries": "3 (System.ClientModel pipeline default)",
   "configure": "OpenAIClientOptions.RetryPolicy"
  },
  "timeouts": {
   "default": "System.ClientModel network timeout (100 s default) — set OpenAIClientOptions.NetworkTimeout"
  },
  "raw_response": "ClientResult.GetRawResponse()",
  "request_id": "raw response headers (x-request-id)",
  "pagination": "Collection results expose GetAllValues()/GetPages() patterns",
  "azure": "Azure.AI.OpenAI (Microsoft-maintained) wraps the same client",
  "admin": "Not documented in the admin-apis guide (no version listed)",
  "docs_url": "https://developers.openai.com/api/docs/libraries#install-an-official-sdk",
  "status": [
   "DOCUMENTED",
   "UNVERIFIED"
  ],
  "verification": {
   "method": "docs_only",
   "verified_at": "2026-09-18",
   "result": "not_tested"
  },
  "sources": [
   {
    "url": "https://developers.openai.com/api/docs/libraries",
    "retrieved_at": "2026-09-19T01:31:00Z"
   }
  ],
  "_fragment": "generated/fragments/sdks/openai-sdks.json"
 },
 {
  "provider": "openai",
  "language": "java",
  "package": "com.openai:openai-java (Maven Central)",
  "repo": "https://github.com/openai/openai-java",
  "version_seen": "4.65.0 (libraries page); admin APIs since 4.34.0; labelled beta on the libraries page",
  "install": "<dependency><groupId>com.openai</groupId><artifactId>openai-java</artifactId><version>4.65.0</version></dependency>",
  "client": "OpenAIClient client = OpenAIOkHttpClient.fromEnv(); // OPENAI_API_KEY, OPENAI_ORG_ID, OPENAI_PROJECT_ID; builder().apiKey(...).adminApiKey(...).build()",
  "async": "client.async() returns OpenAIClientAsync (CompletableFuture)",
  "streaming": "client.responses().createStreaming(params) -> StreamResponse<ResponseStreamEvent>",
  "retries": {
   "default_max_retries": 2,
   "configure": "OpenAIOkHttpClient.builder().maxRetries(n)"
  },
  "timeouts": {
   "default": "10 minutes",
   "configure": ".timeout(Duration)"
  },
  "raw_response": "client.responses().withRawResponse().create(params) -> HttpResponseFor<Response>",
  "request_id": "raw response headers",
  "pagination": "page.autoPager() / page.data(); AutoPager iterables",
  "errors": "OpenAIServiceException subclasses: BadRequestException, UnauthorizedException, PermissionDeniedException, NotFoundException, UnprocessableEntityException, RateLimitException(429), InternalServerException(>=500 incl. 503); OpenAIIoException",
  "admin": "client.admin().organization().projects().modelPermissions().update(\"proj_abc\", ModelPermissionUpdateParams...)",
  "azure": "Azure OpenAI client library for Java (Microsoft)",
  "docs_url": "https://developers.openai.com/api/docs/libraries#install-an-official-sdk",
  "status": [
   "DOCUMENTED",
   "BETA",
   "UNVERIFIED"
  ],
  "verification": {
   "method": "docs_only",
   "verified_at": "2026-09-18",
   "result": "not_tested"
  },
  "sources": [
   {
    "url": "https://developers.openai.com/api/docs/libraries",
    "retrieved_at": "2026-09-19T01:31:00Z"
   },
   {
    "url": "https://developers.openai.com/api/docs/guides/admin-apis",
    "retrieved_at": "2026-09-19T01:31:00Z"
   }
  ],
  "_fragment": "generated/fragments/sdks/openai-sdks.json"
 },
 {
  "provider": "openai",
  "language": "go",
  "package": "github.com/openai/openai-go/v3",
  "repo": "https://github.com/openai/openai-go",
  "version_seen": "v3 module (admin APIs since 3.34.0); labelled beta on the libraries page",
  "install": "go get github.com/openai/openai-go/v3",
  "client": "client := openai.NewClient() // OPENAI_API_KEY; option.WithAPIKey(...), option.WithAdminAPIKey(os.Getenv(\"OPENAI_ADMIN_KEY\")), option.WithOrganization, option.WithProject, option.WithBaseURL",
  "async": "context.Context based; goroutines",
  "streaming": "stream := client.Responses.NewStreaming(ctx, params); for stream.Next() { ev := stream.Current() }; stream.Err()",
  "retries": {
   "default_max_retries": 2,
   "configure": "option.WithMaxRetries(n)"
  },
  "timeouts": {
   "default": "none beyond context; option.WithRequestTimeout(d)"
  },
  "raw_response": "var res *http.Response; client.Responses.New(ctx, params, option.WithResponseInto(&res))",
  "request_id": "res.Header.Get(\"x-request-id\")",
  "pagination": "iter := client.FineTuning.Jobs.ListAutoPaging(ctx, params); for iter.Next() {...}",
  "errors": "var apiErr *openai.Error; errors.As(err, &apiErr); apiErr.StatusCode, apiErr.Code, apiErr.Type, apiErr.Param",
  "admin": "client.Admin.Organization.Projects.ModelPermissions.Update(ctx, \"proj_abc\", openai.AdminOrganizationProjectModelPermissionUpdateParams{...})",
  "azure": "azopenai (Microsoft) — github.com/Azure/azure-sdk-for-go/sdk/ai/azopenai",
  "docs_url": "https://developers.openai.com/api/docs/libraries#install-an-official-sdk",
  "status": [
   "DOCUMENTED",
   "BETA",
   "UNVERIFIED"
  ],
  "verification": {
   "method": "docs_only",
   "verified_at": "2026-09-18",
   "result": "not_tested"
  },
  "sources": [
   {
    "url": "https://developers.openai.com/api/docs/libraries",
    "retrieved_at": "2026-09-19T01:31:00Z"
   },
   {
    "url": "https://developers.openai.com/api/docs/guides/admin-apis",
    "retrieved_at": "2026-09-19T01:31:00Z"
   }
  ],
  "_fragment": "generated/fragments/sdks/openai-sdks.json"
 },
 {
  "provider": "openai",
  "language": "ruby",
  "package": "openai (RubyGems)",
  "repo": "https://github.com/openai/openai-ruby",
  "version_seen": "admin APIs since 0.61.0 (admin-apis guide); version not pinned on libraries page",
  "install": "gem \"openai\"  (Gemfile) / gem install openai",
  "client": "openai = OpenAI::Client.new  # OPENAI_API_KEY; OpenAI::Client.new(api_key:, admin_api_key:, webhook_secret:, organization:, project:)",
  "async": "Synchronous; use threads/fibers",
  "streaming": "stream = openai.responses.stream(...); stream.each { |event| ... }",
  "retries": {
   "default_max_retries": 2,
   "configure": "OpenAI::Client.new(max_retries: n)"
  },
  "timeouts": {
   "default": "600 s",
   "configure": "OpenAI::Client.new(timeout: n)"
  },
  "raw_response": "openai.responses.create(..., request_options: {...}); response headers via with_raw_response equivalents",
  "request_id": "x-request-id header",
  "pagination": "page = openai.fine_tuning.jobs.list; page.auto_paging_each { |j| ... }",
  "errors": "OpenAI::Errors::APIError, ::APIStatusError subclasses (RateLimitError 429, InternalServerError 503), OpenAI::Errors::InvalidWebhookSignatureError",
  "webhooks": "client.webhooks.unwrap(request.body, headers) (webhook_secret on the client); event classes OpenAI::Models::Webhooks::ResponseCompletedWebhookEvent ...",
  "data_residency": "client.with_options(data_residency: :us | :eu) selects us./eu.api.openai.com",
  "admin": "openai.admin.organization.invites.create(email:, role: :reader)",
  "docs_url": "https://developers.openai.com/api/docs/libraries#install-an-official-sdk",
  "status": [
   "DOCUMENTED",
   "UNVERIFIED"
  ],
  "verification": {
   "method": "docs_only",
   "verified_at": "2026-09-18",
   "result": "not_tested"
  },
  "sources": [
   {
    "url": "https://developers.openai.com/api/docs/libraries",
    "retrieved_at": "2026-09-19T01:31:00Z"
   },
   {
    "url": "https://developers.openai.com/api/docs/guides/your-data",
    "retrieved_at": "2026-09-19T01:31:00Z"
   }
  ],
  "_fragment": "generated/fragments/sdks/openai-sdks.json"
 },
 {
  "provider": "openai",
  "language": "cli",
  "package": "openai CLI (Homebrew tap openai/tools/openai)",
  "repo": "https://developers.openai.com/api/docs/libraries/openai-cli",
  "version_seen": "not pinned",
  "install": "brew install openai/tools/openai",
  "client": "openai responses create --model gpt-6-astra --input \"...\" --raw-output --transform 'output.#(type==\"message\").content.0.text'",
  "status": [
   "DOCUMENTED",
   "UNVERIFIED"
  ],
  "verification": {
   "method": "docs_only",
   "verified_at": "2026-09-18",
   "result": "not_tested"
  },
  "docs_url": "https://developers.openai.com/api/docs/libraries/openai-cli",
  "sources": [
   {
    "url": "https://developers.openai.com/api/docs/libraries",
    "retrieved_at": "2026-09-19T01:31:00Z"
   }
  ],
  "_fragment": "generated/fragments/sdks/openai-sdks.json"
 },
 {
  "provider": "openai",
  "language": "agents-sdk",
  "package": "openai-agents (PyPI) / @openai/agents (npm)",
  "repo": "https://github.com/openai/openai-agents-python ; https://github.com/openai/openai-agents-js",
  "version_seen": "not pinned in the libraries page",
  "install": "pip install openai-agents  |  npm install @openai/agents",
  "client": "Code-first orchestration on top of the Responses API: agents, tools, handoffs, guardrails, tracing, sandbox execution. Use when you need orchestration; use the plain SDK for direct requests.",
  "status": [
   "DOCUMENTED",
   "UNVERIFIED"
  ],
  "verification": {
   "method": "docs_only",
   "verified_at": "2026-09-18",
   "result": "not_tested"
  },
  "docs_url": "https://developers.openai.com/api/docs/guides/agents/quickstart",
  "sources": [
   {
    "url": "https://developers.openai.com/api/docs/libraries#use-the-agents-sdk",
    "retrieved_at": "2026-09-19T01:31:00Z"
   }
  ],
  "_fragment": "generated/fragments/sdks/openai-sdks.json"
 },
 {
  "provider": "openai",
  "language": "azure-libraries",
  "package": "Azure.AI.OpenAI (.NET), @azure/openai (JS), azure-ai-openai (Java), azopenai (Go)",
  "repo": "https://github.com/Azure/azure-sdk-for-net/tree/main/sdk/openai/Azure.AI.OpenAI",
  "version_seen": "not pinned",
  "install": "see each Azure SDK repo",
  "client": "Microsoft-maintained libraries compatible with both the OpenAI API and Azure OpenAI; the official openai Python/Node SDKs also ship AzureOpenAI classes.",
  "status": [
   "DOCUMENTED",
   "UNVERIFIED"
  ],
  "verification": {
   "method": "docs_only",
   "verified_at": "2026-09-18",
   "result": "not_tested"
  },
  "docs_url": "https://developers.openai.com/api/docs/libraries#azure-openai-libraries",
  "sources": [
   {
    "url": "https://developers.openai.com/api/docs/libraries",
    "retrieved_at": "2026-09-19T01:31:00Z"
   }
  ],
  "_fragment": "generated/fragments/sdks/openai-sdks.json"
 },
 {
  "provider": "xai",
  "language": "python",
  "package": "xai-sdk",
  "official": true,
  "transport": "gRPC (api.x.ai:443) - NOT REST",
  "version_seen": "1.19.0 (installed in .venv; PyPI xai-sdk; Apache-2.0; Python >= 3.10)",
  "install": "pip install xai-sdk  # extras: xai-sdk[telemetry-http], xai-sdk[telemetry-grpc]",
  "dependencies": [
   "grpcio >=1.72.1,<2",
   "protobuf >=5.29.4,<7",
   "googleapis-common-protos",
   "pydantic >=2.5.3,<3",
   "requests",
   "aiohttp",
   "opentelemetry-sdk",
   "typing-extensions"
  ],
  "client": "from xai_sdk import Client, AsyncClient; client = Client()  # reads XAI_API_KEY; Client(api_key=..., management_api_key=..., api_host='api.x.ai' | 'us.api.x.ai', management_api_host='management-api.x.ai', metadata=(...), channel_options=[...], timeout=1620.0)",
  "status": [
   "DOCUMENTED",
   "LIVE_VERIFIED"
  ],
  "source": "https://docs.x.ai/developers/grpc-api-reference",
  "surfaces": {
   "chat": "client.chat.create(model, messages=[system(...), user(...)], tools=[web_search(), x_search(), code_execution(), ...], reasoning_effort=..., service_tier=...) -> chat.sample() / chat.stream() (yields (response, chunk)) / chat.defer() / chat.parse(PydanticModel); response.content, response.reasoning_content, response.usage (incl. cost_in_usd_ticks), response.cost_usd, response.server_side_tool_usage, response.tool_calls; chat.append(response)",
   "image": "client.image.sample(prompt, model='grok-imagine-image-2.0', quality='low', ...) -> .url / .image / .cost_usd",
   "video": "client.video.generate(model='grok-imagine-video-1.5', prompt=...) (async polling) / extend",
   "models": "client.models.list_language_models() / get_language_model(id) / list_image_generation_models() / list_embedding_models()",
   "auth": "client.auth.get_api_key_info() -> ApiKey (redacted_api_key, acls, team_id, blocked/disabled)",
   "tokenizer": "client.tokenizer.tokenize_text(text, model)",
   "batch": "client.batch.* (BatchMgmt service)",
   "files": "client.files.upload/list/retrieve/delete/public urls",
   "collections": "client.collections.* (Documents.Search)",
   "compaction": "chat.compact()/CompactContext",
   "telemetry": "OpenTelemetry tracing built in (xai_sdk.telemetry)"
  },
  "grpc_metadata_added": [
   "xai-sdk-version: python/<ver>",
   "xai-sdk-language: python/<major.minor>"
  ],
  "retries_timeouts": "default RPC timeout 27 min (1620 s); grpc keepalive options set; errors are grpc.RpcError (e.code() == grpc.StatusCode.RESOURCE_EXHAUSTED for 429)",
  "limitations": [
   "code_interpreter and file_search tool aliases are NOT supported in gRPC (use code_execution / collections_search)",
   "no cost_in_usd_ticks shortfall: SDK exposes response.cost_usd",
   "regional endpoint passed as bare host: api_host='us.api.x.ai'"
  ],
  "notes": "Also supports sync (xai_sdk.sync) and async (xai_sdk.aio) modules; proto stubs shipped in xai_sdk/proto/v5 and v6 (services: Auth, BatchMgmt, Chat, Documents, Embedder, Files, Image, Models, Sample, Tokenize, Video). Protos published at github.com/xai-org/xai-proto.",
  "_fragment": "generated/fragments/sdks/xai-sdks.json"
 },
 {
  "provider": "xai",
  "language": "python",
  "package": "openai",
  "official": false,
  "compatibility": "OpenAI-compatible REST surface",
  "version_seen": "docs examples (customLanguage=pythonOpenAISDK)",
  "install": "pip install openai",
  "client": "from openai import OpenAI; client = OpenAI(api_key=os.getenv('XAI_API_KEY'), base_url='https://api.x.ai/v1')  # or https://us.api.x.ai/v1",
  "status": [
   "DOCUMENTED",
   "LIVE_VERIFIED"
  ],
  "source": "https://docs.x.ai/developers/quickstart",
  "surfaces": {
   "chat.completions.create": "model, messages, reasoning_effort, stream + stream_options={include_usage:true} (cost only in final chunk), service_tier, extra_headers={'x-grok-conv-id': ...}",
   "responses.create": "model, input, tools=[{type:'web_search'},{type:'x_search'},{type:'code_interpreter'}], reasoning={effort}, prompt_cache_key, include=['reasoning.encrypted_content'], store, previous_response_id",
   "images.generate": "model='grok-imagine-image-2.0', extra_body={'quality':'low'} (Node SDK accepts quality directly)",
   "models.list": "GET /v1/models works",
   "usage extras": "completion.usage.cost_in_usd_ticks, num_sources_used, reasoning_tokens exposed as extra fields"
  },
  "limitations": [
   "xAI-only fields (quality, prompt_cache_key on chat, x-grok-conv-id) go through extra_body / extra_headers",
   "videos, voice, files public URLs, collections, tokenize-text, /v1/me have no OpenAI-SDK method -> raw HTTP"
  ],
  "notes": "This atlas's live calls used raw HTTPS via scripts/live.py xai_request (same wire format).",
  "_fragment": "generated/fragments/sdks/xai-sdks.json"
 },
 {
  "provider": "xai",
  "language": "typescript",
  "package": "openai (Node)",
  "official": false,
  "compatibility": "OpenAI-compatible REST surface",
  "version_seen": "node_modules/openai 7.18.0 installed (no official xAI Node SDK exists)",
  "install": "npm install openai",
  "client": "new OpenAI({ apiKey: process.env.XAI_API_KEY, baseURL: 'https://api.x.ai/v1' })",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://docs.x.ai/developers/quickstart",
  "surfaces": {
   "chat.completions.create / responses.create / images.generate": "as documented (customLanguage=javascriptOpenAISDK); usage.cost_in_usd_ticks available"
  },
  "limitations": [
   "same gaps as the Python OpenAI client"
  ],
  "notes": "Not executed by this agent.",
  "_fragment": "generated/fragments/sdks/xai-sdks.json"
 },
 {
  "provider": "xai",
  "language": "typescript",
  "package": "@ai-sdk/xai (Vercel AI SDK provider)",
  "official": "maintained by Vercel; featured throughout docs.x.ai (customLanguage=javascriptAISDK)",
  "version_seen": "not installed",
  "install": "npm install ai @ai-sdk/xai",
  "client": "import { xai, createXai } from '@ai-sdk/xai'; createXai({ apiKey, baseURL: 'https://us.api.x.ai/v1' }); generateText({ model: xai.responses('grok-4.6'), prompt })  // xai('grok-4.6') = chat completions, xai.responses() = Responses API",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://docs.x.ai/developers/grok-4-6",
  "limitations": [
   "does not surface cost_in_usd_ticks in response metadata (docs note)",
   "encrypted reasoning content auto-included unless store:false"
  ],
  "notes": "Also Vercel AI Gateway lists Grok models.",
  "_fragment": "generated/fragments/sdks/xai-sdks.json"
 },
 {
  "provider": "xai",
  "language": "any (Anthropic-compatible)",
  "package": "anthropic SDKs via base_url",
  "official": false,
  "compatibility": "POST /v1/messages and legacy POST /v1/complete are 'compatible with the Anthropic API'",
  "version_seen": "n/a",
  "install": "pip install anthropic",
  "client": "Anthropic(base_url='https://api.x.ai', api_key=XAI_API_KEY) - auth: xAI expects Authorization: Bearer; x-api-key acceptance not verified by this agent",
  "status": [
   "DOCUMENTED",
   "UNVERIFIED"
  ],
  "source": "https://docs.x.ai/developers/rest-api-reference/inference/legacy",
  "notes": "Covered by docs/xai/messages-compat.md (another agent).",
  "_fragment": "generated/fragments/sdks/xai-sdks.json"
 },
 {
  "provider": "xai",
  "language": "python / typescript",
  "package": "langchain-xai / @langchain/xai",
  "official": false,
  "compatibility": "community integration announced Nov 2024",
  "install": "pip install langchain-xai | npm i @langchain/xai",
  "client": "ChatXAI(model='grok-4.6')",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://docs.x.ai/developers/release-notes",
  "notes": "https://python.langchain.com/integrations/providers/xai/ , https://js.langchain.com/integrations/chat/xai/",
  "_fragment": "generated/fragments/sdks/xai-sdks.json"
 },
 {
  "provider": "xai",
  "language": "cli",
  "package": "Grok Build CLI",
  "official": true,
  "install": "curl -fsSL https://x.ai/cli/install.sh | bash",
  "client": "interactive TUI, headless scripting, Agent Client Protocol; default model grok-4.6 (grok-build-0.1 for coding agent)",
  "status": [
   "DOCUMENTED",
   "BETA"
  ],
  "source": "https://docs.x.ai/build/overview",
  "notes": "Privacy: /privacy and /settings slash commands; ZDR honoured.",
  "_fragment": "generated/fragments/sdks/xai-sdks.json"
 },
 {
  "provider": "xai",
  "language": "protobuf / any gRPC",
  "package": "xai-org/xai-proto + buf curl",
  "official": true,
  "install": "git clone https://github.com/xai-org/xai-proto.git; buf curl --protocol grpc https://api.x.ai/xai_api.Models/ListLanguageModels -H 'Authorization: Bearer $XAI_API_KEY'",
  "client": "services xai_api.{Chat,Image,Video,BatchMgmt,Models,Auth,Tokenize,Sample} (+ Files, Documents, Embedder in the SDK stubs)",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://docs.x.ai/developers/grpc-api-reference",
  "notes": "gRPC reference pages on docs.x.ai are rendered client-side (llms-full.txt and the .md twins are empty stubs); method list taken from xai_sdk/proto/v6 stubs - see docs/xai/grpc-api.md.",
  "_fragment": "generated/fragments/sdks/xai-sdks.json"
 },
 {
  "provider": "xai",
  "language": "cloud",
  "package": "Google Cloud Vertex AI (Model Garden partner model) / Microsoft Foundry (Azure)",
  "official": "partner",
  "install": "enable in Model Garden / Foundry catalog",
  "client": "OpenAI-compatible endpoints (Chat Completions + Responses) with cloud IAM; billing through GCP / Azure Marketplace",
  "status": [
   "DOCUMENTED"
  ],
  "source": "https://docs.x.ai/developers/community/google-cloud-vertex-ai",
  "notes": "Also https://docs.x.ai/developers/community/microsoft-foundry; model availability and retention terms are set by the cloud.",
  "_fragment": "generated/fragments/sdks/xai-sdks.json"
 }
]