After the 13 October 2026 general release, how do you validate Gemini 4 Argon function arguments apart from the final JSON?

You ask Argon to look up a match and return the winner, the score, and the scorers. It may call search first, then return JSON. The location string for the tool and the final score object are not the same Schema. Use the wrong one, and the tool is called with the wrong fields, or an unfinished call is stored as the match result.

What the model card says after general availability

As of 2026-10-20, from the release notes and the gemini-4-argon model card:

• Model id: gemini-4-argon. The release note date is 2026-10-13, and the status is general availability. The card's latest update says October 2026.
• Window: context 1,048,576. Synchronous output defaults to 65,536. With long decode, the output cap can reach 1,048,576.
• JSON-related capabilities: Function calling Supported. Structured outputs Supported. The output data type is Text. Caching is implicit only. Explicit caching is not supported.
• Do not reuse the old channel: the Live API is not supported. Image generation and audio generation are not supported either. The earlier note on Gemini 3.8 Live voice function calling does not apply to this model id.

One interaction, two JSON objects

The structured-output page, updated 2026-10-13 UTC, puts the final object in response_format. The Argon REST example posts to v1beta/interactions:

{
  "model": "gemini-4-argon",
  "input": "Search for all details for the latest Euro.",
  "tools": [{"type": "google_search"}, {"type": "url_context"}],
  "response_format": {
    "type": "text",
    "mime_type": "application/json",
    "schema": {
      "type": "object",
      "properties": {
        "winner": {"type": "string"},
        "final_match_score": {"type": "string"},
        "scorers": {"type": "array", "items": {"type": "string"}}
      },
      "required": ["winner", "final_match_score", "scorers"]
    }
  }
}

The SDK reads interaction.output_text. The migration guide says it joins only the consecutive text blocks at the end of the response. Earlier text separated by thoughts, images, audio, or tool calls is left out. Walk steps for anything in the middle.

The step-by-step function-calling example in that migration guide sets the model to gemini-3.8-flash and posts to v1beta2/interactions. As of 2026-10-20 those two pages do not put the same model on the same path. The step fields below follow the Interactions function-calling example. They are not an Argon-only shape. Use the page for the version you actually call.

arguments checks only the tool input

When you must run a tool, the interaction status is requires_action. The documented step:

{
  "type": "function_call",
  "status": "waiting",
  "id": "fc_1",
  "name": "get_weather",
  "arguments": { "location": "Boston, MA" }
}

arguments is checked against the tool's parameters, not against response_format.schema. Return the result with the same id: function_result.call_id matches fc_1, and you send name as well.

While streaming, arguments arrive as arguments deltas. The field is partial_arguments, a string fragment, for example a piece of {"location": "Boston, MA"}. A midpoint can be invalid JSON. Validate the arguments object only after the step is complete.

The function-calling modes page, updated 2026-10-15 UTC, describes VALIDATED. It is the default when built-in tools or structured outputs are also enabled. The model predicts either function calls or natural language, and the page says it ensures function-schema adherence. That page does not name gemini-4-argon. Even if the API claims the arguments match the schema, the final JSON is a separate check.

The final JSON waits for completed

After you send the tool result, the next interaction in the example has status completed. The text sits in model_output.content with type text. The SDK collects it as output_text. Under structured output, that string is what you JSON.parse and check against schema.

The docs split the two jobs:

• Structured Outputs: the format of the final answer.
• Function Calling: a request that you do something mid-conversation. A tool round can sit before the final answer.

There is no final text during requires_action. Running output_text through the match schema treats an empty string, or an incomplete join, as the result. Read the status first, then choose which object to check.

The subset, and where the docs disagree

The structured-output page lists string, number, integer, boolean, object, and array. Null is {"type":["string","null"]}. An object may set properties, required, and additionalProperties (a boolean or a schema). A string may set enum and format (date-time, date, time). A number may set minimum, maximum, and enum. An array may set items, prefixItems, minItems, and maxItems. The official match schema does not set additionalProperties. When it is omitted, extra fields are allowed under the JSON Schema default. To reject extra keys, add false on your local contract. That local contract is stricter than the request.

The same page says the output is syntactically valid JSON and that values still need a check in your application. A very large or deeply nested schema may be rejected. Not every JSON Schema feature is supported.

The combination, as of 2026-10-20, is not one sentence:

• Model card: Function calling and Structured outputs are both Supported.
• Structured-output page: the preview line says Gemini 3 only, and the prose says Gemini 3 can combine this with built-in tools and function calling. The Python, JavaScript, Java, Go, and REST samples in that section set model to gemini-4-argon.
• Function-calling page (2026-10-15): “Function calling with Structured output” says Gemini 3 only. It does not name Argon.
• Tools page (2026-10-14): Gemini 4 and Gemini 3 can combine built-in tools with custom tools, and structured outputs with tools is described for both lines.

Until those sentences match, treat “structured output together with tools” as preview. Validate both JSON objects locally. The function-calling page says a Gemini 3 history you edit by hand must send thought_signature back. The Argon model card does not say that. Do not copy the Gemini 3 signature rule onto gemini-4-argon.

How to check it in JSON Toolbox

The two schemas below are local shapes. They are not a response_format to send to the API. The subset page does not list const, so do not paste the first schema into the request as-is.

{
  "call_schema": {
    "type": "object",
    "properties": {
      "type": { "const": "function_call" },
      "id": { "type": "string", "minLength": 1 },
      "name": { "const": "get_weather" },
      "arguments": {
        "type": "object",
        "properties": { "location": { "type": "string" } },
        "required": ["location"],
        "additionalProperties": false
      }
    },
    "required": ["type", "id", "name", "arguments"],
    "additionalProperties": true
  },
  "final_schema": {
    "type": "object",
    "properties": {
      "winner": { "type": "string" },
      "final_match_score": { "type": "string" },
      "scorers": { "type": "array", "items": { "type": "string" } }
    },
    "required": ["winner", "final_match_score", "scorers"],
    "additionalProperties": false
  },
  "ok_call": {
    "type": "function_call",
    "status": "waiting",
    "id": "fc_1",
    "name": "get_weather",
    "arguments": { "location": "Boston, MA" }
  },
  "ok_final": {
    "winner": "Example FC",
    "final_match_score": "2-1",
    "scorers": ["A. Example"]
  },
  "extra_field": {
    "winner": "Example FC",
    "final_match_score": "2-1",
    "scorers": ["A. Example"],
    "note": "not in the contract"
  },
  "partial": {
    "type": "arguments",
    "partial_arguments": "{\"location\":"
  }
}

1. Paste the four samples into JSON format. ok_call, ok_final, and extra_field parse. The string in partial.partial_arguments does not parse on its own.
2. Use JSON → Schema on ok_final, then add required and additionalProperties: false.
3. In Schema validator, ok_call should pass call_schema. ok_final and partial should fail it.
4. ok_final should pass final_schema. extra_field and ok_call should fail it. Field notes for the final object can go to structured output. Tool arguments go to Function Calling.

The data stays in the browser. First reject “a function call stored as the match result,” then subscribe to the Argon interaction.

FAQ

If output_text is already JSON, do you still validate it locally?

Yes. The docs promise syntax. A value can still be the wrong fact, and the official sample does not close extra fields for you.

Can you read the final JSON while the status is requires_action?

No. Run arguments first and return a function_result with call_id. Read output_text after the status is completed.

Can a streamed partial_arguments value pass a Schema check?

No. It is a string fragment. Wait until arguments is an object.

Do the docs treat structured output plus function calling as generally available?

As of 2026-10-20 they do not line up. The model card says Supported. Some combination paragraphs say Gemini 3 only, the tools page says Gemini 4 and Gemini 3, and the samples use gemini-4-argon. Treat it as preview and validate both locally.

Is this the same note as the Gemini 4 release-date piece?

No. That one is the pre-launch forecast: when Gemini 4 ships. This note is only the two JSON objects after general availability.

Summary

As of 2026-10-20, gemini-4-argon went generally available on 2026-10-13. The model card marks function calling and structured output as supported, and the Live API as not supported. Tool input is function_call.arguments. The final JSON is output_text after completed. Do not schema-check partial_arguments. The combination docs are not one sentence yet, so keep both local contracts. Next, reject ok_call as a match result, then decide whether the request goes to v1beta or v1beta2.

Related tools

Related articles