Gemini 3 Pro function calling fails with missing thought_signature after multiple tool uses

[nklisch]

When using Gemini 3 Pro (gemini-3-pro-preview) with ADK JS 0.3.0 and @google/genai 1.41.0, multi-turn function calling fails with
a 400 error after 3-4 tool calls. The API reports a missing thought_signature on a functionCall content block.

Error

{
"error": {
"code": 400,
"message": "Unable to submit request because function call getRecentSleep in the 4. content block is missing a
thought_signature."
}
}

Environment

• @google/adk: 0.3.0
• @google/genai: 1.41.0
• Model: gemini-3-pro-preview
• Backend: Vertex AI (GOOGLE_GENAI_USE_VERTEXAI=true)
• Session service: InMemorySessionService
• Thinking config: { thinkingLevel: "HIGH" } (also reproduces with default/no explicit config)

Steps to Reproduce

1. Create an LlmAgent with gemini-3-pro-preview and multiple FunctionTools
2. Send a prompt that triggers 2+ sequential tool calls
3. On the 3rd-4th tool call, the API returns a 400 about a missing thought_signature

Expected Behavior

ADK JS should preserve thoughtSignature fields from model responses and include them in subsequent requests, maintaining the
model's reasoning context across multi-turn function calling.

Context

Gemini 3 enforces strict validation on thought signatures during function calling (unlike 2.5 where it was optional). The Thought
Signatures docs state official SDKs handle this automatically, but ADK JS appears to drop them when building conversation history.

Fixed in other libraries:

• ADK Python: #2565, #3705 — fixed in v1.20.0
• Vercel AI SDK: Gemini 3: Function call is missing a thought_signature in functionCall parts vercel/ai#10344 — fixed in PR #10361
• LiveKit agents-js: @livekit/agents-plugin-google: Gemini 3 Flash function calling fails - missing thought_signature support livekit/agents-js#920 — fixed in PR #921

[Varun-S10]

Hi @nklisch, We have tried to reproduce this issue, and it's working on our end. To help us investigate further, could you please share a minimal reproducible code snippet? This would be very helpful.

[nklisch]

The below should trigger it. When I ran it it did. Basically the function signatures are being dropped causing corruption, silent 400 retries -

google_llm.js streaming accumulation (lines 108-117) collects thought text into a plain string and reconstructs it as { text, thought: true } -- dropping thoughtSignature. The corrupted history causes Gemini 3 to reject subsequent calls with:

400: "function call `X` in the N. content block is missing a `thought_signature`"

Any agent with 3+ tool calls in SSE streaming mode hits this. The first function call retains its signature; all others are stripped. ADK catches the 400 internally and retries, silently resending the full conversation history (including tool payloads) -- a single user message can cost 3-4x the expected tokens. Non-streaming mode is unaffected.

To test, copy my snippet below into a stand alone script. You need these env set:

GOOGLE_GENAI_USE_VERTEXAI=true GOOGLE_CLOUD_PROJECT=<project> GOOGLE_CLOUD_LOCATION=global
# or
GOOGLE_API_KEY=<key>

Output

-> [1] getBusinessOverview()     -- thoughtSignature=YES
-> [2] getOrderHistory()         -- thoughtSignature=MISSING
-> [3] getProductReviews()       -- thoughtSignature=MISSING
-> [4] getInventoryStatus()      -- thoughtSignature=MISSING
-> [5] getCustomerSegments()     -- thoughtSignature=MISSING
-> [6] getMarketingPerformance() -- thoughtSignature=MISSING

400: "function call `getOrderHistory` in the 4. content block
      is missing a `thought_signature`"

SESSION AUDIT:
  functionCall parts with thoughtSignature:    1
  functionCall parts WITHOUT thoughtSignature: 5

Environment

@google/adk 0.3.0, @google/genai 1.41.0, gemini-3-flash-preview / gemini-3-pro-preview, Vertex AI

/**
 * Repro: ADK JS 0.3.0 SSE streaming drops `thoughtSignature` → Gemini 3 400
 *
 * Root cause: google_llm.js streaming accumulation (lines 108-117) collects
 * streamed thought text into a plain string, then reconstructs it as
 * `{ text, thought: true }` — dropping the `thoughtSignature` field. When
 * the corrupted history is sent on the next API call, Gemini 3 rejects:
 *
 *   400 "function call `X` in the N. content block is missing a `thought_signature`"
 *
 * What this script does:
 *   1. Creates an agent with 6 tools that return realistic-volume data (~8-20KB)
 *   2. Sends a prompt that triggers all 6 tool calls (SSE streaming mode)
 *   3. Uses a plugin to log what ADK sends/receives — showing signatures vanish
 *   4. Sends a follow-up message, replaying the corrupted history → 400 error
 *   5. Audits session storage to prove thoughtSignature was stripped
 *
 * Environment:
 *   @google/adk: 0.3.0
 *   @google/genai: 1.41.0
 *   Model: gemini-3-flash-preview or gemini-3-pro-preview
 *   Backend: Vertex AI
 *
 * Setup:
 *   npm install @google/adk@0.3.0 @google/genai@1.41.0 zod tsx
 *
 * Run (Vertex AI):
 *   GOOGLE_GENAI_USE_VERTEXAI=true \
 *   GOOGLE_CLOUD_PROJECT=<project> \
 *   GOOGLE_CLOUD_LOCATION=global \
 *   npx tsx repro-thought-signature.ts
 *
 * Run (AI Studio):
 *   GOOGLE_API_KEY=<key> npx tsx repro-thought-signature.ts
 *
 * Override model:
 *   MODEL=gemini-3-pro-preview npx tsx repro-thought-signature.ts
 *
 * Expected: All functionCall parts retain `thoughtSignature` in session history.
 * Actual:   1st functionCall keeps signature; all others are stripped.
 *           Turn 2 replays corrupted history → 400 INVALID_ARGUMENT.
 */

import {
  type Event,
  BasePlugin,
  FunctionTool,
  InMemorySessionService,
  LlmAgent,
  Runner,
  StreamingMode,
} from "@google/adk";
import { z } from "zod";

// ── Instrumentation plugin ──────────────────────────────────────────────
// Logs what ADK sends to the API (beforeModel) and what it yields back
// (afterModel). This is the evidence trail: you'll see `sig=YES` on the
// first functionCall and `sig=NO` on all subsequent ones.

let modelCallNum = 0;

function describeParts(parts: unknown[]): string[] {
  return parts.map((part) => {
    const p = part as Record<string, unknown>;
    const sig = "thoughtSignature" in p;
    const sigLabel = sig
      ? `sig=YES(${String(p.thoughtSignature).slice(0, 16)}…)`
      : "sig=NO";

    if ("thought" in p && p.thought)
      return `thought(${String(p.text ?? "").length}ch) ${sigLabel}`;
    if ("functionCall" in p) {
      const name = (p.functionCall as Record<string, unknown>).name;
      return `functionCall:${name} ${sigLabel}`;
    }
    if ("functionResponse" in p) {
      const name = (p.functionResponse as Record<string, unknown>).name;
      return `functionResponse:${name}`;
    }
    if ("text" in p) return `text(${String(p.text).length}ch)`;
    return `unknown(${Object.keys(p)})`;
  });
}

class InstrumentationPlugin extends BasePlugin {
  constructor() {
    super("instrumentation");
  }

  async beforeModelCallback({
    llmRequest,
  }: {
    callbackContext: unknown;
    llmRequest: Record<string, unknown>;
  }) {
    modelCallNum++;
    const contents = llmRequest.contents as
      | Array<{ role: string; parts: unknown[] }>
      | undefined;
    if (!contents) return undefined;

    console.log(`\n══ MODEL CALL #${modelCallNum} — sending ${contents.length} content blocks ══`);
    for (let i = 0; i < contents.length; i++) {
      const { role, parts } = contents[i];
      for (const desc of describeParts(parts ?? [])) {
        console.log(`  [${i}] ${role} ${desc}`);
      }
    }
    return undefined;
  }

  async afterModelCallback({
    llmResponse,
  }: {
    callbackContext: unknown;
    llmResponse: Record<string, unknown>;
  }) {
    const content = llmResponse.content as
      | { role: string; parts: unknown[] }
      | undefined;
    if (!content?.parts?.length) return undefined;

    const label = llmResponse.partial ? "partial" : "FINAL";
    for (const desc of describeParts(content.parts)) {
      // Skip partial text chunks (noisy); show everything else
      if (label === "partial" && desc.startsWith("text(")) continue;
      console.log(`  ← [${label}] ${desc}`);
    }
    return undefined;
  }
}

// ── Mock tools with realistic data volumes ──────────────────────────────
// The data volume matters: small stubs don't cause the model to "think"
// between tool calls, so the streaming thought accumulation code path
// (where the bug lives) is never exercised.

function makeBusinessOverview() {
  return {
    period: "2026-01-17 to 2026-02-15",
    revenue: {
      total: 48750.32, previousPeriod: 52100.18, changePercent: -6.4,
      daily: Array.from({ length: 30 }, (_, i) => ({
        date: new Date(2026, 1, 15 - i).toISOString().split("T")[0],
        revenue: 1200 + Math.sin(i * 0.5) * 400 + (i % 7 === 0 ? 800 : 0),
        orders: 8 + Math.round(Math.sin(i * 0.5) * 3),
        returns: i % 5 === 0 ? 2 : 0,
        newCustomers: 2 + (i % 4), returningCustomers: 5 + (i % 3),
        averageOrderValue: 130 + (i % 5) * 8,
        conversionRate: 2.8 + (i % 4) * 0.3,
        cartAbandonmentRate: 68 + (i % 6) * 1.5,
      })),
    },
    topProducts: Array.from({ length: 10 }, (_, i) => ({
      sku: `SKU-${1000 + i * 10}`, name: `Product ${i + 1}`,
      category: ["Electronics", "Clothing", "Home", "Books", "Sports"][i % 5],
      unitsSold: 45 - i * 3, revenue: 4500 - i * 350,
      avgRating: 4.5 - (i % 3) * 0.3, reviewCount: 28 - i * 2,
    })),
    categoryBreakdown: [
      { category: "Electronics", revenue: 18500, orders: 95, aov: 194.7, returnRate: 3.2, margin: 22.5 },
      { category: "Clothing", revenue: 12300, orders: 110, aov: 111.8, returnRate: 8.1, margin: 45.2 },
      { category: "Home & Garden", revenue: 9800, orders: 72, aov: 136.1, returnRate: 2.8, margin: 35.0 },
      { category: "Books", revenue: 4200, orders: 40, aov: 105.0, returnRate: 1.2, margin: 40.0 },
      { category: "Sports", revenue: 3950, orders: 25, aov: 158.0, returnRate: 5.5, margin: 30.0 },
    ],
    customerMetrics: {
      totalActive: 1842, newThisPeriod: 156, churnRate: 4.2,
      averageLifetimeValue: 385.20, repeatPurchaseRate: 38.5,
      npsScore: 42, satisfactionScore: 4.1,
    },
  };
}

function makeOrderHistory() {
  const statuses = ["delivered", "shipped", "processing", "returned", "cancelled"];
  return {
    count: 20,
    orders: Array.from({ length: 20 }, (_, i) => {
      const date = new Date(2026, 1, 15 - i * 2);
      const items = Array.from({ length: 2 + (i % 3) }, (_, j) => ({
        sku: `SKU-${1000 + i * 10 + j}`,
        name: `${["Electronics", "Clothing", "Home", "Books", "Sports"][j % 5]} Item ${j + 1}`,
        quantity: 1 + (j % 3), unitPrice: 19.99 + i * 7.5 + j * 12.3,
        discount: j % 2 === 0 ? 10 : 0, tax: 2.4 + i * 0.3,
      }));
      return {
        orderId: `ORD-2026-${String(1000 + i).padStart(5, "0")}`,
        placedAt: date.toISOString(), status: statuses[i % 5],
        subtotal: items.reduce((s, it) => s + it.unitPrice * it.quantity, 0),
        shippingCost: 5.99 + (i % 3) * 2, items,
        shipping: {
          carrier: ["UPS", "FedEx", "USPS", "DHL"][i % 4],
          trackingNumber: `TRK${900000 + i}`,
          address: { city: ["SF", "LA", "NYC", "Chicago", "Austin"][i % 5], state: ["CA", "CA", "NY", "IL", "TX"][i % 5] },
        },
        payment: { method: i % 2 === 0 ? "credit_card" : "paypal", last4: `${4000 + i}` },
      };
    }),
  };
}

function makeProductReviews() {
  const sentiments = ["positive", "neutral", "negative"];
  return {
    count: 25,
    reviews: Array.from({ length: 25 }, (_, i) => ({
      reviewId: `REV-${5000 + i}`,
      productSku: `SKU-${1000 + (i % 10) * 10}`,
      productName: `Product ${(i % 10) + 1}`,
      rating: 1 + (i % 5),
      body: `Detailed review #${i + 1}. Quality: ${sentiments[i % 3]}. Shipping: ${3 + (i % 5)} days. Would ${i % 3 === 2 ? "not " : ""}recommend. Packaging: ${i % 2 === 0 ? "excellent" : "adequate"}. Support: ${i % 3 === 0 ? "responsive" : "slow"}. Price-to-value: ${i % 2 === 0 ? "excellent" : "fair"} vs competitors. ${i % 4 === 0 ? "Exceeded" : "Met"} expectations overall.`,
      sentiment: sentiments[i % 3],
      verifiedPurchase: i % 3 !== 2,
      helpfulVotes: i * 3,
      postedAt: new Date(2026, 1, 15 - i).toISOString(),
      tags: ["quality", "shipping", "value", "support", "packaging"].slice(0, 1 + (i % 5)),
    })),
  };
}

function makeInventoryData() {
  return {
    count: 30,
    inventory: Array.from({ length: 30 }, (_, i) => ({
      sku: `SKU-${1000 + i * 10}`, productName: `Product ${i + 1}`,
      category: ["Electronics", "Clothing", "Home", "Books", "Sports"][i % 5],
      warehouse: ["WH-WEST", "WH-EAST", "WH-CENTRAL"][i % 3],
      quantityOnHand: 50 + i * 8, quantityReserved: 5 + (i % 10),
      quantityAvailable: 45 + i * 8 - (i % 10),
      reorderPoint: 20, leadTimeDays: 3 + (i % 7),
      unitCost: 8.5 + i * 2.3, sellingPrice: 19.99 + i * 4.5,
      supplier: `Supplier-${(i % 5) + 1}`,
      status: i % 8 === 0 ? "low_stock" : i % 15 === 0 ? "out_of_stock" : "in_stock",
      lastSoldAt: new Date(2026, 1, 15 - (i % 3)).toISOString(),
    })),
    alerts: [
      { sku: "SKU-1000", type: "low_stock", message: "Below reorder point", warehouse: "WH-WEST" },
      { sku: "SKU-1080", type: "low_stock", message: "Below reorder point", warehouse: "WH-EAST" },
      { sku: "SKU-1150", type: "out_of_stock", message: "No stock available", warehouse: "WH-CENTRAL" },
    ],
  };
}

function makeCustomerSegments() {
  return {
    segments: [
      { name: "VIP", count: 125, avgSpend: 850, avgOrders: 8.2, retention: 92, topCategory: "Electronics", ltv: 2400 },
      { name: "Regular", count: 680, avgSpend: 320, avgOrders: 3.5, retention: 65, topCategory: "Clothing", ltv: 850 },
      { name: "Occasional", count: 450, avgSpend: 120, avgOrders: 1.8, retention: 35, topCategory: "Books", ltv: 280 },
      { name: "At-Risk", count: 230, avgSpend: 85, avgOrders: 1.2, retention: 15, topCategory: "Home", ltv: 150 },
      { name: "New", count: 156, avgSpend: 95, avgOrders: 1.0, retention: null, topCategory: "Sports", ltv: null },
    ],
    cohortAnalysis: Array.from({ length: 6 }, (_, i) => ({
      cohort: new Date(2025, 8 + i, 1).toISOString().split("T")[0],
      initialSize: 120 + i * 15,
      month1Retention: 85 - i * 2, month2Retention: 65 - i * 3,
      month3Retention: 50 - i * 4, avgRevenuePerUser: 140 + i * 20,
    })),
    rfmDistribution: {
      champions: 95, loyalCustomers: 180, potentialLoyalists: 220,
      recentCustomers: 156, promising: 130, needsAttention: 290,
      aboutToSleep: 145, atRisk: 230, cantLoseThem: 45, lost: 150,
    },
  };
}

function makeMarketingPerformance() {
  const names = ["Spring Sale", "Email Blast", "Social Push", "Retargeting", "Flash Sale", "Loyalty Reward", "New Arrival", "Clearance"];
  const channels = ["email", "social", "paid_search", "display", "email", "email", "social", "paid_search"];
  return {
    campaigns: Array.from({ length: 8 }, (_, i) => ({
      campaignId: `CMP-${2000 + i}`, name: names[i], channel: channels[i],
      status: i < 5 ? "active" : "completed",
      startDate: new Date(2026, 1, 1 + i * 3).toISOString().split("T")[0],
      budget: 500 + i * 250, spent: 450 + i * 220,
      impressions: 15000 + i * 5000, clicks: 450 + i * 120,
      conversions: 12 + i * 3, revenue: 1800 + i * 450,
      ctr: (3.0 + (i % 3) * 0.5).toFixed(1),
      roas: (3.2 + i * 0.4).toFixed(1), cpa: (35 - i * 2).toFixed(2),
    })),
    channelSummary: [
      { channel: "email", revenue: 12500, cost: 1200, roas: 10.4, conversions: 85 },
      { channel: "social", revenue: 8200, cost: 3500, roas: 2.3, conversions: 42 },
      { channel: "paid_search", revenue: 15800, cost: 4800, roas: 3.3, conversions: 95 },
      { channel: "display", revenue: 3200, cost: 2100, roas: 1.5, conversions: 18 },
    ],
  };
}

// ── Pre-generate data and register tools ────────────────────────────────

const toolData = {
  getBusinessOverview: makeBusinessOverview(),
  getOrderHistory: makeOrderHistory(),
  getProductReviews: makeProductReviews(),
  getInventoryStatus: makeInventoryData(),
  getCustomerSegments: makeCustomerSegments(),
  getMarketingPerformance: makeMarketingPerformance(),
};

const tools = [
  new FunctionTool({
    name: "getBusinessOverview",
    description: "Revenue trends, top products, category breakdown, customer metrics (last 30 days).",
    parameters: z.object({ period: z.string().optional() }),
    execute: async () => toolData.getBusinessOverview,
  }),
  new FunctionTool({
    name: "getOrderHistory",
    description: "Recent orders with line items, shipping, payment, and fulfillment status.",
    parameters: z.object({ limit: z.number().optional(), status: z.string().optional() }),
    execute: async () => toolData.getOrderHistory,
  }),
  new FunctionTool({
    name: "getProductReviews",
    description: "Product reviews with ratings, sentiment analysis, and tags.",
    parameters: z.object({ productSku: z.string().optional(), minRating: z.number().optional() }),
    execute: async () => toolData.getProductReviews,
  }),
  new FunctionTool({
    name: "getInventoryStatus",
    description: "Inventory levels across warehouses with reorder alerts and stock status.",
    parameters: z.object({ warehouse: z.string().optional(), status: z.string().optional() }),
    execute: async () => toolData.getInventoryStatus,
  }),
  new FunctionTool({
    name: "getCustomerSegments",
    description: "Customer segmentation with RFM analysis and cohort retention.",
    parameters: z.object({ segment: z.string().optional() }),
    execute: async () => toolData.getCustomerSegments,
  }),
  new FunctionTool({
    name: "getMarketingPerformance",
    description: "Marketing campaign performance with ROAS, CPA, and channel breakdown.",
    parameters: z.object({ channel: z.string().optional() }),
    execute: async () => toolData.getMarketingPerformance,
  }),
];

// ── Agent + Runner ──────────────────────────────────────────────────────

const SYSTEM_PROMPT = `You are an expert e-commerce business analyst. Help business owners understand store performance through data analysis and actionable recommendations.

## How You Work

- Data-driven and precise. Always reference specific numbers from the tools.
- Structure analysis with sections and bullet points.
- Highlight positive trends and areas of concern.
- Provide actionable recommendations based on data.

## Using Tools

Use tools proactively to gather comprehensive data before providing analysis. Always call getBusinessOverview first, then drill into specific areas.

## Analysis Framework

For a full business review:
1. Overview dashboard for the big picture
2. Orders for purchasing patterns
3. Reviews for customer satisfaction signals
4. Inventory for supply chain health
5. Customer segments for retention opportunities
6. Marketing for ROI optimization

Cross-reference data across tools — e.g., if a category shows declining revenue, check if it correlates with negative reviews or inventory stockouts.`;

const model = process.env.MODEL ?? "gemini-3-flash-preview";

const agent = new LlmAgent({
  name: "analyst",
  model,
  instruction: SYSTEM_PROMPT,
  tools,
  generateContentConfig: {
    thinkingConfig: { thinkingLevel: "HIGH" },
  },
});

const sessionService = new InMemorySessionService();
const runner = new Runner({
  appName: "repro",
  agent,
  sessionService,
  plugins: [new InstrumentationPlugin()],
});

// ── Main ────────────────────────────────────────────────────────────────

async function main() {
  const session = await sessionService.createSession({
    appName: "repro",
    userId: "user",
  });

  console.log("ADK JS 0.3.0 — thoughtSignature streaming bug repro");
  console.log(`Model: ${model} | Stream: SSE | Thinking: HIGH | Tools: 6`);
  console.log(`Data sizes: ${Object.entries(toolData).map(([k, v]) => `${k}=${(JSON.stringify(v).length / 1024).toFixed(1)}KB`).join(", ")}\n`);

  let toolCallCount = 0;
  const errors: string[] = [];

  function processEvent(event: Event) {
    // Detect 400 errors from ADK's internal error handling
    const e = event as unknown as Record<string, unknown>;
    if (e.errorCode || e.errorMessage) {
      const msg = String(e.errorMessage ?? "");
      if (msg.includes("thought_signature")) {
        errors.push(msg);
        console.error(`\n  ✗ 400 from API: ${msg.slice(0, 200)}`);
      }
    }

    if (!event.content?.parts) return;
    for (const part of event.content.parts) {
      const p = part as Record<string, unknown>;
      if ("functionCall" in p) {
        toolCallCount++;
        const fc = p.functionCall as Record<string, unknown>;
        const sig = "thoughtSignature" in p;
        console.log(`  → [${toolCallCount}] ${fc.name}() — thoughtSignature=${sig ? "YES ✓" : "MISSING ✗"}`);
      }
      if ("functionResponse" in p) {
        console.log(`  ← ${(p.functionResponse as Record<string, unknown>).name} returned`);
      }
      if ("text" in p && !("thought" in p) && !event.partial) {
        console.log(`\n  [final answer: ${String(p.text).length} chars]`);
      }
    }
  }

  try {
    // ── Turn 1: trigger many tool calls ──
    console.log("━━ TURN 1: full business review (triggers 4-6 tool calls) ━━");

    for await (const event of runner.runAsync({
      userId: "user",
      sessionId: session.id,
      newMessage: {
        role: "user",
        parts: [{ text: "Revenue is down 6% this month and I'm worried. Do a full business health check — pull orders, reviews, inventory, customer segments, and marketing data. Tell me what's wrong and what to fix." }],
      },
      runConfig: { streamingMode: StreamingMode.SSE },
    })) {
      processEvent(event);
    }
    console.log(`\n✓ Turn 1 done — ${toolCallCount} tool calls\n`);

    // ── Turn 2: replay corrupted history → 400 ──
    console.log("━━ TURN 2: follow-up replays corrupted history → expect 400 ━━");

    for await (const event of runner.runAsync({
      userId: "user",
      sessionId: session.id,
      newMessage: {
        role: "user",
        parts: [{ text: "Drill deeper into the reviews — what are customers most unhappy about? Cross-reference with inventory to see if stockouts are causing negative reviews." }],
      },
      runConfig: { streamingMode: StreamingMode.SSE },
    })) {
      processEvent(event);
    }
    console.log(`\n✓ Turn 2 done\n`);
  } catch (err: unknown) {
    const e = err as Error;
    console.error(`\n✗ Uncaught error after ${toolCallCount} tool calls:`);
    console.error(`  ${e.message?.slice(0, 300)}\n`);
  }

  if (errors.length > 0) {
    console.log(`\n⚠ ${errors.length} thought_signature 400 error(s) detected during run.`);
    console.log("Root cause: google_llm.js streaming accumulation drops thoughtSignature");
    console.log("  Line 109: thoughtText += firstPart.text       (only captures text)");
    console.log("  Line 117: { text: thoughtText, thought: true } (signature gone)\n");
  }

  // ── Session audit: prove data loss regardless of 400 ──
  console.log("══ SESSION AUDIT ══");
  const s = await sessionService.getSession({ appName: "repro", userId: "user", sessionId: session.id });
  let withSig = 0;
  let withoutSig = 0;
  for (const evt of s?.events ?? []) {
    for (const part of (evt as Event).content?.parts ?? []) {
      const p = part as Record<string, unknown>;
      if ("functionCall" in p) {
        if ("thoughtSignature" in p) withSig++;
        else withoutSig++;
      }
    }
  }
  console.log(`  functionCall parts with thoughtSignature:    ${withSig}`);
  console.log(`  functionCall parts WITHOUT thoughtSignature: ${withoutSig}`);
  if (withoutSig > 0) {
    console.log(`\n  ⚠ ${withoutSig}/${withSig + withoutSig} functionCall parts had thoughtSignature stripped.`);
    console.log("  This corrupts the session history and causes 400 on subsequent API calls.");
  }
}

main();

[Varun-S10]

Hi @nklisch, Thank you for sharing the code snippet. We have reproduced the issue, and we will be escalating it to our team for further investigation.

Hi @tpryan, I would like to escalate this issue. Please find the reproducible code in the comment above.

[Varun-S10]

Hi @cornellgit, I would like to escalate this issue. Please find the reproducible code in the comment above.

[grillorafael]

I have updated to 4.0.0 and I am still having this issue