@byte_fluffy/nexra-sdk 0.1.0-alpha.37 → 0.1.0-alpha.38

package/dist/{chunk-ENL3IGRX.js → chunk-M4QBFDQB.js}

@@ -2,7 +2,7 @@ import {
   normalizePublicErrorInput,
   pickPublicErrorFields,
   sortRatioDisplayOrder
-} from "./chunk-AAGTZN2G.js";
+} from "./chunk-SRXAHUYR.js";
 
 // src/catalog/generated/audio.generated.json
 var audio_generated_default = [
@@ -23240,7 +23240,42 @@ var language_generated_default = [
               description: "Gemini contents \u5217\u8868\u3002",
               items: {
                 type: "object",
-                additionalProperties: true
+                additionalProperties: true,
+                properties: {
+                  parts: {
+                    type: "array",
+                    items: {
+                      type: "object",
+                      additionalProperties: true,
+                      properties: {
+                        fileData: {
+                          type: "object",
+                          description: "Video files supplied by HTTP URL must not exceed 15 MB (15,000,000 bytes). Compress larger videos or supply a supported Google Cloud Storage URI.",
+                          additionalProperties: true,
+                          properties: {
+                            mimeType: {
+                              type: "string"
+                            },
+                            fileUri: {
+                              type: "string",
+                              format: "uri"
+                            }
+                          },
+                          "x-resource": {
+                            uriProperty: "fileUri",
+                            mimeTypeProperty: "mimeType",
+                            mimeTypePrefix: "video/",
+                            uriSchemes: [
+                              "http",
+                              "https"
+                            ],
+                            maxBytes: 15e6
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
               },
               "x-ui": {
                 order: 1
@@ -24014,15 +24049,608 @@ var language_generated_default = [
     ]
   },
   {
-    id: "google/gemini-3.6-flash",
+    id: "google/gemini-3.6-flash",
+    contractVersion: 1,
+    developer: "google",
+    displayName: "Gemini 3.6 Flash",
+    summary: "Generate efficient multimodal and agentic responses with Gemini 3.6 Flash using native Gemini contents, tools, and configurable thinking from minimal through high.",
+    kind: "language",
+    family: "Gemini Flash",
+    versionLabel: "3.6",
+    aliases: [],
+    capabilities: {
+      inputModalities: [
+        "text",
+        "image",
+        "video",
+        "audio"
+      ],
+      outputModalities: [
+        "text"
+      ],
+      inputModes: [
+        "text-to-text",
+        "multimodal-to-text"
+      ],
+      features: [
+        "reasoning",
+        "function-calling"
+      ],
+      contextWindowTokens: 1048576,
+      maxOutputTokens: 65536
+    },
+    operations: [
+      {
+        operation: "language.generate",
+        inputModalities: [
+          "text",
+          "image",
+          "video",
+          "audio"
+        ],
+        outputModalities: [
+          "text"
+        ],
+        inputSchema: {
+          type: "object",
+          properties: {
+            audios: {
+              type: "array",
+              items: {
+                oneOf: [
+                  {
+                    type: "string",
+                    format: "uri"
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      url: {
+                        type: "string",
+                        format: "uri"
+                      },
+                      role: {
+                        type: "string",
+                        enum: [
+                          "default"
+                        ]
+                      }
+                    },
+                    required: [
+                      "url"
+                    ],
+                    additionalProperties: false
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      assetId: {
+                        type: "string",
+                        minLength: 1
+                      },
+                      role: {
+                        type: "string",
+                        enum: [
+                          "default"
+                        ]
+                      }
+                    },
+                    required: [
+                      "assetId"
+                    ],
+                    additionalProperties: false
+                  }
+                ]
+              },
+              description: "Audio inputs; assign a role when the model exposes role-specific behavior.",
+              minItems: 1,
+              maxItems: 1,
+              "x-ui": {
+                order: 4,
+                control: "media",
+                roles: [
+                  "default"
+                ],
+                accept: [
+                  "url"
+                ]
+              }
+            },
+            contents: {
+              type: "array",
+              description: "\u9AD8\u7EA7\u7528\u6CD5\uFF1A\u5B8C\u6574 Gemini contents \u5386\u53F2\u3002\u56DE\u4F20 functionResponse \u65F6\u4F7F\u7528\uFF1B\u4F20\u5165\u540E\u4F1A\u8986\u76D6 input \u7684 texts/images/videos/audios \u81EA\u52A8\u7EC4\u88C5\u3002",
+              minItems: 1,
+              items: {
+                type: "object",
+                additionalProperties: true,
+                description: "A provider-native Gemini Content object containing a role and parts."
+              },
+              "x-ui": {
+                order: 1,
+                control: "json"
+              }
+            },
+            function_calling_config: {
+              type: "object",
+              description: "\u7B80\u5199\u5F62\u5F0F\uFF1B\u4F1A\u88AB\u5305\u88C5\u4E3A tool_config.function_calling_config\u3002",
+              "x-ui": {
+                order: 5,
+                control: "json"
+              }
+            },
+            images: {
+              type: "array",
+              items: {
+                oneOf: [
+                  {
+                    type: "string",
+                    format: "uri"
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      url: {
+                        type: "string",
+                        format: "uri"
+                      },
+                      role: {
+                        type: "string",
+                        enum: [
+                          "default"
+                        ]
+                      }
+                    },
+                    required: [
+                      "url"
+                    ],
+                    additionalProperties: false
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      assetId: {
+                        type: "string",
+                        minLength: 1
+                      },
+                      role: {
+                        type: "string",
+                        enum: [
+                          "default"
+                        ]
+                      }
+                    },
+                    required: [
+                      "assetId"
+                    ],
+                    additionalProperties: false
+                  }
+                ]
+              },
+              description: "Image inputs; assign a role when the model exposes role-specific behavior.",
+              minItems: 1,
+              maxItems: 3e3,
+              "x-ui": {
+                order: 2,
+                control: "media",
+                roles: [
+                  "default"
+                ],
+                accept: [
+                  "url"
+                ]
+              }
+            },
+            is_stream: {
+              type: "boolean",
+              description: "Whether to stream response events as they are generated.",
+              "x-ui": {
+                order: 6,
+                control: "switch"
+              }
+            },
+            is_thinking: {
+              type: "boolean",
+              description: "Whether to include thought parts in the response. This does not enable or disable reasoning; Gemini thinking is controlled by thinking_level.",
+              title: "Include thoughts",
+              "x-ui": {
+                order: 7,
+                control: "switch"
+              }
+            },
+            texts: {
+              type: "string",
+              description: "User message or instruction to send to the language model.",
+              minLength: 1,
+              title: "Message",
+              "x-ui": {
+                order: 0,
+                control: "textarea"
+              }
+            },
+            thinking_level: {
+              type: "string",
+              enum: [
+                "minimal",
+                "low",
+                "medium",
+                "high"
+              ],
+              title: "Thinking level",
+              description: "Amount of reasoning the model should perform before returning its response.",
+              "x-ui": {
+                order: 9,
+                control: "segmented"
+              },
+              default: "medium"
+            },
+            tool_config: {
+              type: "object",
+              description: "Gemini ToolConfig\uFF0C\u53EF\u8BBE\u7F6E functionCallingConfig/function_calling_config \u7684 mode\u3001allowedFunctionNames \u7B49\u3002",
+              "x-ui": {
+                order: 10,
+                control: "json"
+              }
+            },
+            tools: {
+              type: "array",
+              description: "Gemini Tool \u6570\u7EC4\uFF0C\u652F\u6301\u5B98\u65B9 REST camelCase\uFF08functionDeclarations\uFF09\u6216 SDK snake_case\uFF08function_declarations\uFF09\u3002",
+              "x-ui": {
+                order: 11,
+                control: "json"
+              }
+            },
+            videos: {
+              type: "array",
+              items: {
+                oneOf: [
+                  {
+                    type: "string",
+                    format: "uri"
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      url: {
+                        type: "string",
+                        format: "uri"
+                      },
+                      role: {
+                        type: "string",
+                        enum: [
+                          "default"
+                        ]
+                      }
+                    },
+                    required: [
+                      "url"
+                    ],
+                    additionalProperties: false
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      assetId: {
+                        type: "string",
+                        minLength: 1
+                      },
+                      role: {
+                        type: "string",
+                        enum: [
+                          "default"
+                        ]
+                      }
+                    },
+                    required: [
+                      "assetId"
+                    ],
+                    additionalProperties: false
+                  }
+                ]
+              },
+              description: "Video inputs; assign a role when the model exposes role-specific behavior.",
+              minItems: 1,
+              maxItems: 10,
+              "x-ui": {
+                order: 3,
+                control: "media",
+                roles: [
+                  "default"
+                ],
+                accept: [
+                  "url"
+                ]
+              }
+            },
+            max_output_tokens: {
+              type: "integer",
+              minimum: 1,
+              maximum: 65536,
+              title: "Maximum output tokens",
+              description: "Maximum number of response and reasoning tokens to generate.",
+              "x-ui": {
+                order: 8,
+                control: "number"
+              }
+            }
+          },
+          additionalProperties: false,
+          anyOf: [
+            {
+              required: [
+                "texts"
+              ]
+            },
+            {
+              required: [
+                "contents"
+              ]
+            }
+          ]
+        },
+        outputSchema: {
+          type: "object",
+          properties: {
+            text: {
+              type: "string",
+              description: "\u6B63\u6587\uFF1B\u6D41\u5F0F NDJSON \u884C\u5185 `response` \u7247\u6BB5\u540C\u7ED3\u6784"
+            },
+            reasoning: {
+              type: "string",
+              description: "\u6DF1\u5EA6\u601D\u8003\uFF08thought\uFF09\u65F6\u51FA\u73B0"
+            },
+            function_calls: {
+              type: "array",
+              items: {
+                type: "object"
+              },
+              description: "Gemini function calling \u8FD4\u56DE\u7684\u51FD\u6570\u8C03\u7528\u6570\u7EC4\uFF1B\u6BCF\u9879\u5305\u542B name\u3001args\uFF0C\u53EF\u80FD\u5305\u542B id"
+            }
+          },
+          additionalProperties: false
+        },
+        metering: {
+          schemaVersion: 1,
+          kind: "token",
+          metrics: [
+            {
+              metric: "requests",
+              requirement: "required"
+            },
+            {
+              metric: "input_tokens",
+              requirement: "required"
+            },
+            {
+              metric: "cached_input_tokens",
+              requirement: "informational"
+            },
+            {
+              metric: "output_tokens",
+              requirement: "required"
+            }
+          ]
+        }
+      }
+    ],
+    endpoints: [
+      {
+        endpointKey: "generate-content",
+        operation: "language.generate",
+        protocol: "gemini-generate-content",
+        method: "POST",
+        path: "/v1beta/models/{model}:generateContent",
+        capabilities: [
+          "reasoning",
+          "sse",
+          "text",
+          "tool_call"
+        ],
+        inputSchema: {
+          type: "object",
+          properties: {
+            contents: {
+              type: "array",
+              minItems: 1,
+              description: "Gemini contents \u5217\u8868\u3002",
+              items: {
+                type: "object",
+                additionalProperties: true
+              },
+              "x-ui": {
+                order: 1
+              }
+            },
+            systemInstruction: {
+              type: "object",
+              additionalProperties: true,
+              "x-ui": {
+                order: 0
+              }
+            },
+            generationConfig: {
+              type: "object",
+              description: "\u6A21\u578B\u751F\u6210\u53C2\u6570\uFF1B\u5DF2\u77E5\u9650\u5236\u7531\u5177\u4F53\u6A21\u578B\u6536\u7A84\u3002",
+              properties: {
+                maxOutputTokens: {
+                  type: "integer",
+                  minimum: 1,
+                  maximum: 65536,
+                  title: "Maximum output tokens",
+                  description: "Maximum number of response and reasoning tokens to generate."
+                },
+                thinkingConfig: {
+                  type: "object",
+                  properties: {
+                    thinkingLevel: {
+                      type: "string",
+                      enum: [
+                        "minimal",
+                        "low",
+                        "medium",
+                        "high"
+                      ],
+                      title: "Thinking level",
+                      description: "Amount of reasoning the model should perform before returning its response."
+                    },
+                    includeThoughts: {
+                      type: "boolean",
+                      description: "Whether to include thought parts in the response. This does not enable or disable reasoning; Gemini thinking is controlled by thinking_level.",
+                      title: "Include thoughts"
+                    }
+                  },
+                  additionalProperties: true
+                }
+              },
+              additionalProperties: true,
+              "x-ui": {
+                order: 4
+              }
+            },
+            tools: {
+              type: "array",
+              items: {
+                type: "object",
+                additionalProperties: true
+              },
+              "x-ui": {
+                order: 2
+              }
+            },
+            toolConfig: {
+              type: "object",
+              additionalProperties: true,
+              "x-ui": {
+                order: 3
+              }
+            }
+          },
+          required: [
+            "contents"
+          ],
+          additionalProperties: true
+        },
+        outputSchema: {
+          type: "object",
+          description: "\u534F\u8BAE\u539F\u751F\u54CD\u5E94\uFF1B\u6D41\u5F0F\u8BF7\u6C42\u8FD4\u56DE\u8BE5\u534F\u8BAE\u5B9A\u4E49\u7684\u4E8B\u4EF6\u6D41\u3002",
+          additionalProperties: true
+        }
+      },
+      {
+        endpointKey: "responses",
+        operation: "language.generate",
+        protocol: "openai-responses",
+        method: "POST",
+        path: "/v1/responses",
+        capabilities: [
+          "reasoning",
+          "sse",
+          "text",
+          "tool_call"
+        ],
+        inputSchema: {
+          type: "object",
+          properties: {
+            model: {
+              type: "string",
+              description: "Nexra \u516C\u5171\u6A21\u578B ID\uFF0C\u5FC5\u987B\u4E0E\u5916\u5C42 modelId \u76F8\u540C\u3002",
+              "x-ui": {
+                order: 0
+              },
+              title: "\u6A21\u578B ID",
+              const: "google/gemini-3.6-flash",
+              examples: [
+                "google/gemini-3.6-flash"
+              ]
+            },
+            input: {
+              description: "Responses \u6587\u672C\u3001\u6D88\u606F\u6216\u8F93\u5165\u9879\u3002",
+              "x-ui": {
+                order: 2
+              }
+            },
+            instructions: {
+              type: "string",
+              description: "\u7CFB\u7EDF\u6216\u5F00\u53D1\u8005\u6307\u4EE4\u3002",
+              "x-ui": {
+                order: 1
+              }
+            },
+            stream: {
+              type: "boolean",
+              description: "\u662F\u5426\u8FD4\u56DE Responses \u7C7B\u578B\u5316 SSE\u3002",
+              "x-ui": {
+                order: 7
+              },
+              default: false
+            },
+            max_output_tokens: {
+              type: "integer",
+              minimum: 1,
+              maximum: 65536,
+              title: "Maximum output tokens",
+              description: "\u672C\u6B21\u751F\u6210\u5141\u8BB8\u7684\u6700\u5927\u8F93\u51FA token \u6570\u3002",
+              "x-ui": {
+                order: 6
+              }
+            },
+            previous_response_id: {
+              type: "string"
+            },
+            metadata: {
+              type: "object",
+              additionalProperties: true
+            },
+            tools: {
+              type: "array",
+              items: {
+                type: "object",
+                additionalProperties: true
+              },
+              "x-ui": {
+                order: 3
+              }
+            },
+            tool_choice: {
+              "x-ui": {
+                order: 4
+              }
+            },
+            reasoning: {
+              type: "object",
+              properties: {},
+              additionalProperties: true,
+              "x-ui": {
+                order: 5
+              }
+            }
+          },
+          required: [
+            "model",
+            "input"
+          ],
+          additionalProperties: true
+        },
+        outputSchema: {
+          type: "object",
+          description: "\u534F\u8BAE\u539F\u751F\u54CD\u5E94\uFF1B\u6D41\u5F0F\u8BF7\u6C42\u8FD4\u56DE\u8BE5\u534F\u8BAE\u5B9A\u4E49\u7684\u4E8B\u4EF6\u6D41\u3002",
+          additionalProperties: true
+        }
+      }
+    ]
+  },
+  {
+    id: "google/gemini-3-8-flash",
     contractVersion: 1,
     developer: "google",
-    displayName: "Gemini 3.6 Flash",
-    summary: "Generate efficient multimodal and agentic responses with Gemini 3.6 Flash using native Gemini contents, tools, and configurable thinking from minimal through high.",
+    displayName: "Gemini 3.8 Flash",
+    summary: "Generate multimodal text responses with Gemini 3.8 Flash using native Gemini contents, tools, and low, medium, or high thinking.",
     kind: "language",
     family: "Gemini Flash",
-    versionLabel: "3.6",
-    aliases: [],
+    versionLabel: "3.8",
+    aliases: [
+      "gemini-3.8-flash",
+      "google/gemini-3.8-flash"
+    ],
     capabilities: {
       inputModalities: [
         "text",
@@ -24235,7 +24863,6 @@ var language_generated_default = [
             thinking_level: {
               type: "string",
               enum: [
-                "minimal",
                 "low",
                 "medium",
                 "high"
@@ -24449,22 +25076,32 @@ var language_generated_default = [
                     thinkingLevel: {
                       type: "string",
                       enum: [
-                        "minimal",
                         "low",
                         "medium",
-                        "high"
+                        "high",
+                        "LOW",
+                        "MEDIUM",
+                        "HIGH"
                       ],
                       title: "Thinking level",
-                      description: "Amount of reasoning the model should perform before returning its response."
+                      description: "Amount of reasoning the model should perform before returning its response.",
+                      default: "medium"
                     },
                     includeThoughts: {
                       type: "boolean",
                       description: "Whether to include thought parts in the response. This does not enable or disable reasoning; Gemini thinking is controlled by thinking_level.",
                       title: "Include thoughts"
-                    }
+                    },
+                    thinkingBudget: false
                   },
                   additionalProperties: true
-                }
+                },
+                temperature: false,
+                topP: false,
+                topK: false,
+                candidateCount: false,
+                frequencyPenalty: false,
+                presencePenalty: false
               },
               additionalProperties: true,
               "x-ui": {
@@ -24522,9 +25159,9 @@ var language_generated_default = [
                 order: 0
               },
               title: "\u6A21\u578B ID",
-              const: "google/gemini-3.6-flash",
+              const: "google/gemini-3-8-flash",
               examples: [
-                "google/gemini-3.6-flash"
+                "google/gemini-3-8-flash"
               ]
             },
             input: {
@@ -24582,7 +25219,25 @@ var language_generated_default = [
             },
             reasoning: {
               type: "object",
-              properties: {},
+              properties: {
+                effort: {
+                  type: "string",
+                  enum: [
+                    "low",
+                    "medium",
+                    "high"
+                  ],
+                  default: "medium"
+                },
+                summary: {
+                  type: "string",
+                  enum: [
+                    "auto",
+                    "concise",
+                    "detailed"
+                  ]
+                }
+              },
               additionalProperties: true,
               "x-ui": {
                 order: 5
@@ -24604,17 +25259,16 @@ var language_generated_default = [
     ]
   },
   {
-    id: "google/gemini-3-8-flash",
+    id: "google/gemini-4-argon",
     contractVersion: 1,
     developer: "google",
-    displayName: "Gemini 3.8 Flash",
-    summary: "Generate multimodal text responses with Gemini 3.8 Flash using native Gemini contents, tools, and low, medium, or high thinking.",
+    displayName: "Gemini 4 Argon",
+    summary: "Generate multimodal text responses with Gemini 4 Argon using native Gemini contents, client-side tools, structured output, and low, medium, or high thinking.",
     kind: "language",
-    family: "Gemini Flash",
-    versionLabel: "3.8",
+    family: "Gemini Argon",
+    versionLabel: "4",
     aliases: [
-      "gemini-3.8-flash",
-      "google/gemini-3.8-flash"
+      "gemini-4-argon"
     ],
     capabilities: {
       inputModalities: [
@@ -24716,7 +25370,7 @@ var language_generated_default = [
             },
             contents: {
               type: "array",
-              description: "\u9AD8\u7EA7\u7528\u6CD5\uFF1A\u5B8C\u6574 Gemini contents \u5386\u53F2\u3002\u56DE\u4F20 functionResponse \u65F6\u4F7F\u7528\uFF1B\u4F20\u5165\u540E\u4F1A\u8986\u76D6 input \u7684 texts/images/videos/audios \u81EA\u52A8\u7EC4\u88C5\u3002",
+              description: "Full Gemini contents history. When provided, it replaces automatic message and media assembly.",
               minItems: 1,
               items: {
                 type: "object",
@@ -24730,7 +25384,7 @@ var language_generated_default = [
             },
             function_calling_config: {
               type: "object",
-              description: "\u7B80\u5199\u5F62\u5F0F\uFF1B\u4F1A\u88AB\u5305\u88C5\u4E3A tool_config.function_calling_config\u3002",
+              description: "Shorthand for tool_config.function_calling_config.",
               "x-ui": {
                 order: 5,
                 control: "json"
@@ -24808,7 +25462,7 @@ var language_generated_default = [
             },
             is_thinking: {
               type: "boolean",
-              description: "Whether to include thought parts in the response. This does not enable or disable reasoning; Gemini thinking is controlled by thinking_level.",
+              description: "Whether to include thought parts in the response. This does not enable or disable reasoning.",
               title: "Include thoughts",
               "x-ui": {
                 order: 7,
@@ -24842,7 +25496,7 @@ var language_generated_default = [
             },
             tool_config: {
               type: "object",
-              description: "Gemini ToolConfig\uFF0C\u53EF\u8BBE\u7F6E functionCallingConfig/function_calling_config \u7684 mode\u3001allowedFunctionNames \u7B49\u3002",
+              description: "Gemini ToolConfig including functionCallingConfig or function_calling_config, mode, and allowedFunctionNames.",
               "x-ui": {
                 order: 10,
                 control: "json"
@@ -24850,7 +25504,7 @@ var language_generated_default = [
             },
             tools: {
               type: "array",
-              description: "Gemini Tool \u6570\u7EC4\uFF0C\u652F\u6301\u5B98\u65B9 REST camelCase\uFF08functionDeclarations\uFF09\u6216 SDK snake_case\uFF08function_declarations\uFF09\u3002",
+              description: "Gemini tools using REST functionDeclarations or SDK function_declarations.",
               "x-ui": {
                 order: 11,
                 control: "json"
@@ -24923,7 +25577,7 @@ var language_generated_default = [
               minimum: 1,
               maximum: 65536,
               title: "Maximum output tokens",
-              description: "Maximum number of response and reasoning tokens to generate.",
+              description: "Maximum response and thinking tokens within the shared input and output context.",
               "x-ui": {
                 order: 8,
                 control: "number"
@@ -24942,6 +25596,29 @@ var language_generated_default = [
                 "contents"
               ]
             }
+          ],
+          allOf: [
+            {
+              if: {
+                properties: {
+                  is_stream: {
+                    const: true
+                  }
+                },
+                required: [
+                  "is_stream"
+                ]
+              },
+              then: {},
+              else: {
+                properties: {
+                  max_output_tokens: {
+                    maximum: 32768,
+                    type: "integer"
+                  }
+                }
+              }
+            }
           ]
         },
         outputSchema: {
@@ -24949,18 +25626,18 @@ var language_generated_default = [
           properties: {
             text: {
               type: "string",
-              description: "\u6B63\u6587\uFF1B\u6D41\u5F0F NDJSON \u884C\u5185 `response` \u7247\u6BB5\u540C\u7ED3\u6784"
+              description: "Response body; each response fragment in streaming NDJSON uses the same structure."
             },
             reasoning: {
               type: "string",
-              description: "\u6DF1\u5EA6\u601D\u8003\uFF08thought\uFF09\u65F6\u51FA\u73B0"
+              description: "Thinking content returned in thought parts."
             },
             function_calls: {
               type: "array",
               items: {
                 type: "object"
               },
-              description: "Gemini function calling \u8FD4\u56DE\u7684\u51FD\u6570\u8C03\u7528\u6570\u7EC4\uFF1B\u6BCF\u9879\u5305\u542B name\u3001args\uFF0C\u53EF\u80FD\u5305\u542B id"
+              description: "Gemini function calls containing name, args, and optionally id."
             }
           },
           additionalProperties: false
@@ -25002,13 +25679,279 @@ var language_generated_default = [
           "text",
           "tool_call"
         ],
+        httpOperations: [
+          {
+            key: "generate",
+            kind: "generate",
+            httpMethod: "POST",
+            pathTemplate: "/v1beta/models/{model}:generateContent",
+            schemaProjection: "request",
+            responseStatus: 200,
+            documentationUrl: "https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/guides/gemini-4-argon",
+            bodyParameters: {
+              type: "object",
+              properties: {
+                contents: {
+                  type: "array",
+                  minItems: 1,
+                  description: "Ordered Gemini contents with roles and parts.",
+                  items: {
+                    type: "object",
+                    additionalProperties: true
+                  },
+                  "x-ui": {
+                    order: 1
+                  }
+                },
+                systemInstruction: {
+                  type: "object",
+                  additionalProperties: true,
+                  "x-ui": {
+                    order: 0
+                  }
+                },
+                generationConfig: {
+                  type: "object",
+                  description: "Generation settings supported by this model.",
+                  properties: {
+                    maxOutputTokens: {
+                      type: "integer",
+                      minimum: 1,
+                      maximum: 32768,
+                      title: "Maximum output tokens",
+                      description: "Maximum response and thinking tokens within the shared input and output context."
+                    },
+                    thinkingConfig: {
+                      type: "object",
+                      properties: {
+                        thinkingLevel: {
+                          type: "string",
+                          enum: [
+                            "LOW",
+                            "MEDIUM",
+                            "HIGH"
+                          ],
+                          title: "Thinking level",
+                          description: "Amount of reasoning the model should perform before returning its response.",
+                          default: "MEDIUM"
+                        },
+                        includeThoughts: {
+                          type: "boolean",
+                          description: "Whether to include thought parts in the response. This does not enable or disable reasoning.",
+                          title: "Include thoughts"
+                        },
+                        thinkingBudget: false
+                      },
+                      additionalProperties: true
+                    },
+                    temperature: false,
+                    topP: false,
+                    topK: false,
+                    candidateCount: false,
+                    frequencyPenalty: false,
+                    presencePenalty: false
+                  },
+                  additionalProperties: true,
+                  "x-ui": {
+                    order: 4
+                  }
+                },
+                tools: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    additionalProperties: true
+                  },
+                  "x-ui": {
+                    order: 2
+                  }
+                },
+                toolConfig: {
+                  type: "object",
+                  additionalProperties: true,
+                  "x-ui": {
+                    order: 3
+                  }
+                },
+                cachedContent: false,
+                continuationToken: false,
+                continuation_token: false,
+                cached_content: false
+              },
+              required: [
+                "contents"
+              ],
+              additionalProperties: true,
+              examples: [
+                {
+                  contents: [
+                    {
+                      role: "user",
+                      parts: [
+                        {
+                          text: "Explain how durable task execution prevents duplicate work."
+                        }
+                      ]
+                    }
+                  ],
+                  generationConfig: {
+                    thinkingConfig: {
+                      thinkingLevel: "MEDIUM"
+                    },
+                    maxOutputTokens: 2048
+                  }
+                }
+              ]
+            }
+          },
+          {
+            key: "stream",
+            kind: "stream",
+            httpMethod: "POST",
+            pathTemplate: "/v1beta/models/{model}:streamGenerateContent",
+            schemaProjection: "request",
+            responseStatus: 200,
+            documentationUrl: "https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/guides/gemini-4-argon",
+            bodyParameters: {
+              type: "object",
+              properties: {
+                contents: {
+                  type: "array",
+                  minItems: 1,
+                  description: "Ordered Gemini contents with roles and parts.",
+                  items: {
+                    type: "object",
+                    additionalProperties: true
+                  },
+                  "x-ui": {
+                    order: 1
+                  }
+                },
+                systemInstruction: {
+                  type: "object",
+                  additionalProperties: true,
+                  "x-ui": {
+                    order: 0
+                  }
+                },
+                generationConfig: {
+                  type: "object",
+                  description: "Generation settings supported by this model.",
+                  properties: {
+                    maxOutputTokens: {
+                      type: "integer",
+                      minimum: 1,
+                      maximum: 65536,
+                      title: "Maximum output tokens",
+                      description: "Maximum response and thinking tokens within the shared input and output context."
+                    },
+                    thinkingConfig: {
+                      type: "object",
+                      properties: {
+                        thinkingLevel: {
+                          type: "string",
+                          enum: [
+                            "LOW",
+                            "MEDIUM",
+                            "HIGH"
+                          ],
+                          title: "Thinking level",
+                          description: "Amount of reasoning the model should perform before returning its response.",
+                          default: "MEDIUM"
+                        },
+                        includeThoughts: {
+                          type: "boolean",
+                          description: "Whether to include thought parts in the response. This does not enable or disable reasoning.",
+                          title: "Include thoughts"
+                        },
+                        thinkingBudget: false
+                      },
+                      additionalProperties: true
+                    },
+                    temperature: false,
+                    topP: false,
+                    topK: false,
+                    candidateCount: false,
+                    frequencyPenalty: false,
+                    presencePenalty: false
+                  },
+                  additionalProperties: true,
+                  "x-ui": {
+                    order: 4
+                  }
+                },
+                tools: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    additionalProperties: true
+                  },
+                  "x-ui": {
+                    order: 2
+                  }
+                },
+                toolConfig: {
+                  type: "object",
+                  additionalProperties: true,
+                  "x-ui": {
+                    order: 3
+                  }
+                },
+                cachedContent: false,
+                continuationToken: false,
+                continuation_token: false,
+                cached_content: false
+              },
+              required: [
+                "contents"
+              ],
+              additionalProperties: true,
+              examples: [
+                {
+                  contents: [
+                    {
+                      role: "user",
+                      parts: [
+                        {
+                          text: "Explain how durable task execution prevents duplicate work."
+                        }
+                      ]
+                    }
+                  ],
+                  generationConfig: {
+                    thinkingConfig: {
+                      thinkingLevel: "MEDIUM"
+                    },
+                    maxOutputTokens: 2048
+                  }
+                }
+              ]
+            },
+            queryParameters: {
+              type: "object",
+              properties: {
+                alt: {
+                  type: "string",
+                  enum: [
+                    "sse"
+                  ],
+                  description: "Use SSE framing for streaming Gemini responses.",
+                  examples: [
+                    "sse"
+                  ]
+                }
+              },
+              additionalProperties: true
+            }
+          }
+        ],
         inputSchema: {
           type: "object",
           properties: {
             contents: {
               type: "array",
               minItems: 1,
-              description: "Gemini contents \u5217\u8868\u3002",
+              description: "Ordered Gemini contents with roles and parts.",
               items: {
                 type: "object",
                 additionalProperties: true
@@ -25026,14 +25969,14 @@ var language_generated_default = [
             },
             generationConfig: {
               type: "object",
-              description: "\u6A21\u578B\u751F\u6210\u53C2\u6570\uFF1B\u5DF2\u77E5\u9650\u5236\u7531\u5177\u4F53\u6A21\u578B\u6536\u7A84\u3002",
+              description: "Generation settings supported by this model.",
               properties: {
                 maxOutputTokens: {
                   type: "integer",
                   minimum: 1,
                   maximum: 65536,
                   title: "Maximum output tokens",
-                  description: "Maximum number of response and reasoning tokens to generate."
+                  description: "Maximum response and thinking tokens within the shared input and output context."
                 },
                 thinkingConfig: {
                   type: "object",
@@ -25041,20 +25984,17 @@ var language_generated_default = [
                     thinkingLevel: {
                       type: "string",
                       enum: [
-                        "low",
-                        "medium",
-                        "high",
                         "LOW",
                         "MEDIUM",
                         "HIGH"
                       ],
                       title: "Thinking level",
                       description: "Amount of reasoning the model should perform before returning its response.",
-                      default: "medium"
+                      default: "MEDIUM"
                     },
                     includeThoughts: {
                       type: "boolean",
-                      description: "Whether to include thought parts in the response. This does not enable or disable reasoning; Gemini thinking is controlled by thinking_level.",
+                      description: "Whether to include thought parts in the response. This does not enable or disable reasoning.",
                       title: "Include thoughts"
                     },
                     thinkingBudget: false
@@ -25089,7 +26029,11 @@ var language_generated_default = [
               "x-ui": {
                 order: 3
               }
-            }
+            },
+            cachedContent: false,
+            continuationToken: false,
+            continuation_token: false,
+            cached_content: false
           },
           required: [
             "contents"
@@ -25098,7 +26042,7 @@ var language_generated_default = [
         },
         outputSchema: {
           type: "object",
-          description: "\u534F\u8BAE\u539F\u751F\u54CD\u5E94\uFF1B\u6D41\u5F0F\u8BF7\u6C42\u8FD4\u56DE\u8BE5\u534F\u8BAE\u5B9A\u4E49\u7684\u4E8B\u4EF6\u6D41\u3002",
+          description: "Protocol-native response; streaming requests return events defined by that protocol.",
           additionalProperties: true
         }
       },
@@ -25124,27 +26068,27 @@ var language_generated_default = [
                 order: 0
               },
               title: "\u6A21\u578B ID",
-              const: "google/gemini-3-8-flash",
+              const: "google/gemini-4-argon",
               examples: [
-                "google/gemini-3-8-flash"
+                "google/gemini-4-argon"
               ]
             },
             input: {
-              description: "Responses \u6587\u672C\u3001\u6D88\u606F\u6216\u8F93\u5165\u9879\u3002",
+              description: "Responses text, messages, or input items.",
               "x-ui": {
                 order: 2
               }
             },
             instructions: {
               type: "string",
-              description: "\u7CFB\u7EDF\u6216\u5F00\u53D1\u8005\u6307\u4EE4\u3002",
+              description: "System or developer instructions.",
               "x-ui": {
                 order: 1
               }
             },
             stream: {
               type: "boolean",
-              description: "\u662F\u5426\u8FD4\u56DE Responses \u7C7B\u578B\u5316 SSE\u3002",
+              description: "Whether to return a typed Responses SSE event stream.",
               "x-ui": {
                 order: 7
               },
@@ -25155,7 +26099,7 @@ var language_generated_default = [
               minimum: 1,
               maximum: 65536,
               title: "Maximum output tokens",
-              description: "\u672C\u6B21\u751F\u6210\u5141\u8BB8\u7684\u6700\u5927\u8F93\u51FA token \u6570\u3002",
+              description: "Maximum response and thinking tokens within the shared input and output context.",
               "x-ui": {
                 order: 6
               }
@@ -25207,17 +26151,49 @@ var language_generated_default = [
               "x-ui": {
                 order: 5
               }
-            }
+            },
+            temperature: false,
+            top_p: false,
+            top_k: false,
+            frequency_penalty: false,
+            presence_penalty: false,
+            seed: false,
+            n: false,
+            prompt_cache_key: false,
+            prompt_cache_retention: false
           },
           required: [
             "model",
             "input"
           ],
-          additionalProperties: true
+          additionalProperties: true,
+          allOf: [
+            {
+              if: {
+                properties: {
+                  stream: {
+                    const: true
+                  }
+                },
+                required: [
+                  "stream"
+                ]
+              },
+              then: {},
+              else: {
+                properties: {
+                  max_output_tokens: {
+                    maximum: 32768,
+                    type: "integer"
+                  }
+                }
+              }
+            }
+          ]
         },
         outputSchema: {
           type: "object",
-          description: "\u534F\u8BAE\u539F\u751F\u54CD\u5E94\uFF1B\u6D41\u5F0F\u8BF7\u6C42\u8FD4\u56DE\u8BE5\u534F\u8BAE\u5B9A\u4E49\u7684\u4E8B\u4EF6\u6D41\u3002",
+          description: "Protocol-native response; streaming requests return events defined by that protocol.",
           additionalProperties: true
         }
       }
@@ -52141,7 +53117,7 @@ var NexraWaitTimeoutError = class extends Error {
 };
 
 // src/generated/version.generated.ts
-var SDK_VERSION = "0.1.0-alpha.37";
+var SDK_VERSION = "0.1.0-alpha.38";
 
 // src/transport.ts
 var DEFAULT_BASE_URL = "https://api.nexra-ai.com/v1";
@@ -52566,16 +53542,38 @@ function getLanguageModelBinding(modelId, options = {}) {
   const protocols = options.protocol ? [options.protocol] : LANGUAGE_PROTOCOLS;
   const endpoint = protocols.flatMap((protocol) => spec.endpoints.filter((candidate) => candidate.operation === "language.generate" && candidate.protocol === protocol && candidate.method === "POST"))[0];
   if (!endpoint) throw new Error(`Nexra language protocol is unavailable: ${modelId}${options.protocol ? ` (${options.protocol})` : ""}`);
-  const fields = schemaObject(endpoint.inputSchema?.properties);
-  const tokenField = endpoint.protocol === "gemini-generate-content" ? schemaObject(schemaObject(fields.generationConfig).properties).maxOutputTokens : endpoint.protocol === "openai-responses" ? fields.max_output_tokens : fields.max_tokens;
-  const limits = [spec.capabilities.maxOutputTokens, schemaObject(tokenField).maximum].filter((value) => typeof value === "number" && Number.isFinite(value) && value > 0);
+  const operation = options.stream === void 0 ? void 0 : endpoint.httpOperations?.find((operation2) => operation2.httpMethod === "POST" && (options.stream ? operation2.kind === "stream" : ["request", "generate"].includes(operation2.kind)));
+  const inputSchema = operation?.bodyParameters ?? endpoint.inputSchema;
+  const schemas = languageCallSchemas(inputSchema, options.stream);
+  const limits = [spec.capabilities.maxOutputTokens, ...schemas.map((schema) => {
+    const fields = schemaObject(schema.properties);
+    return schemaObject(endpoint.protocol === "gemini-generate-content" ? schemaObject(schemaObject(fields.generationConfig).properties).maxOutputTokens : endpoint.protocol === "openai-responses" ? fields.max_output_tokens : fields.max_tokens).maximum;
+  })].filter((value) => typeof value === "number" && Number.isFinite(value) && value > 0);
   return {
     spec,
-    endpoint,
+    endpoint: { ...endpoint, ...inputSchema ? { inputSchema } : {} },
     supportsStreaming: endpoint.capabilities.includes("sse"),
     ...limits.length ? { maxOutputTokens: Math.min(...limits) } : {}
   };
 }
+function languageCallSchemas(schema, stream) {
+  const node = schemaObject(schema);
+  const result = [node];
+  for (const item of Array.isArray(node.allOf) ? node.allOf : []) {
+    const rule = schemaObject(item);
+    if (!rule.if) {
+      result.push(...languageCallSchemas(rule, stream));
+      continue;
+    }
+    const condition = schemaObject(rule.if);
+    const fields = schemaObject(condition.properties);
+    const expected = schemaObject(fields.stream).const;
+    if (stream !== void 0 && Object.keys(condition).every((key) => ["properties", "required"].includes(key)) && Object.keys(fields).length === 1 && typeof expected === "boolean" && (!Array.isArray(condition.required) || condition.required.every((key) => key === "stream"))) {
+      result.push(...languageCallSchemas(stream === expected ? rule.then : rule.else, stream));
+    }
+  }
+  return result;
+}
 function schemaObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -52584,7 +53582,7 @@ function effortValues(field2) {
   return Array.isArray(values) ? values.filter((value) => typeof value === "string") : [];
 }
 function minimumEffort(values) {
-  return ["none", "minimal", "low", "medium", "high", "xhigh", "max"].find((value) => values.includes(value));
+  return ["none", "minimal", "low", "medium", "high", "xhigh", "max"].flatMap((effort) => values.filter((value) => value.toLowerCase() === effort))[0];
 }
 function resolveNexraLanguageReasoning(modelId, options) {
   const binding = getLanguageModelBinding(modelId, options);
@@ -52618,7 +53616,7 @@ function resolveNexraLanguageReasoning(modelId, options) {
   const level = options.enabled ? void 0 : minimumEffort(values);
   const budget = schemaObject(properties.thinkingBudget);
   const canDisable = typeof budget.minimum === "number" && budget.minimum === 0;
-  return { providerOptions: options.enabled ? {} : { google: { thinkingConfig: level ? { thinkingLevel: level } : canDisable ? { thinkingBudget: 0 } : {} } }, canDisable };
+  return { providerOptions: options.enabled ? {} : { google: { thinkingConfig: level ? { thinkingLevel: level.toLowerCase() } : canDisable ? { thinkingBudget: 0 } : {} } }, canDisable };
 }
 function deepFreeze(value) {
   if (value && typeof value === "object" && !Object.isFrozen(value)) {