@code-yeongyu/senpi-ai 2026.9.30 → 2026.10.1

package/dist/api/context-room.d.ts

@@ -1,4 +1,4 @@
-import type { Api, Context, Model } from "../types.ts";
+import type { Api, Model, TranscriptContext } from "../types.ts";
 export declare const CONTEXT_SAFETY_TOKENS = 4096;
 /** Tokens always left for the answer when a thinking budget shares the response ceiling. */
 export declare const MIN_ANSWER_TOKENS = 1024;
@@ -16,5 +16,5 @@ export declare class ContextWindowExhaustedError extends Error {
  * {@link MIN_ANSWER_TOKENS}: such a request can only return a truncated tool call or an
  * empty "length" stop while still billing the whole prompt.
  */
-export declare function clampMaxTokensToContext(model: Model<Api>, context: Context, maxTokens: number): number;
+export declare function clampMaxTokensToContext(model: Model<Api>, context: TranscriptContext, maxTokens: number): number;
 //# sourceMappingURL=context-room.d.ts.map

package/dist/api/cursor-agent.js

@@ -28,6 +28,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { providerHeadersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { getCurrentSystemPrompt, getCurrentTools } from "../utils/transcript.js";
 import { deterministicUuid } from "./cursor-agent/deterministic-id.js";
 import { armExecHeartbeat } from "./cursor-agent/exec-lifecycle.js";
 import { buildMcpStateResult, buildNeutralHookResult, buildPiBashError, buildPiBashResult, buildPiEditError, buildPiEditRejected, buildPiEditResult, buildPiFindError, buildPiFindResult, buildPiGrepError, buildPiGrepResult, buildPiLsError, buildPiLsResult, buildPiReadError, buildPiReadResult, buildPiWriteError, buildPiWriteRejected, buildPiWriteResult, } from "./cursor-agent/exec-modern.js";
@@ -474,6 +475,7 @@ export function mapH2TransportError(error, baseUrl) {
 }
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const requestView = toCursorRequestView(context);
     (async () => {
         const output = {
             role: "assistant",
@@ -591,7 +593,7 @@ export const stream = (model, context, options) => {
                 attemptPinnedStore = blobStore;
                 blobStore.beginRequestPins();
                 const cachedState = conversationStateCache.get(conversationId);
-                const { requestBytes, conversationState, requestedModel, modelDetails } = await buildGrpcRequest(model, context, options, {
+                const { requestBytes, conversationState, requestedModel, modelDetails } = await buildGrpcRequest(model, requestView, options, {
                     conversationId,
                     blobStore,
                     conversationState: cachedState,
@@ -605,7 +607,7 @@ export const stream = (model, context, options) => {
                 // This request's working set is pinned now, so the process ceiling can
                 // reclaim from cold conversations without touching what it needs.
                 enforceConversationTotalBlobLimit();
-                const requestContextTools = buildMcpToolDefinitions(context.tools);
+                const requestContextTools = buildMcpToolDefinitions(requestView.tools);
                 const baseUrl = model.baseUrl || CURSOR_API_URL;
                 const requestPath = "/agent.v1.AgentService/Run";
                 // Caller headers are additive, and are spread FIRST so the protocol
@@ -2960,7 +2962,7 @@ export function processInteractionUpdate(update, output, stream, state, usageSta
             type: "toolCall",
             id: scmCall?.args?.toolCallId || update.message.value.callId || randomUUID(),
             name: "connect_scm",
-            arguments: repository ? { owner: repository.owner, repo: repository.repo } : {},
+            arguments: (repository ? { owner: repository.owner, repo: repository.repo } : {}),
             [kStreamingBlockIndex]: output.content.length,
             [kStreamingBlockKind]: "connect-scm",
             [kStreamingEnvelopeId]: update.message.value.callId || undefined,
@@ -3656,11 +3658,18 @@ function extractImages(content) {
         },
     }));
 }
-async function buildGrpcRequest(model, context, options, state) {
+function toCursorRequestView(context) {
+    return {
+        systemPrompt: getCurrentSystemPrompt(context.messages),
+        messages: context.messages.filter((message) => message.role !== "system"),
+        tools: getCurrentTools(context.messages),
+    };
+}
+async function buildGrpcRequest(model, request, options, state) {
     const blobStore = state.blobStore;
-    const systemPromptIds = buildCursorSystemPromptJsons(context.systemPrompt, model.id).map((json) => storeCursorBlob(blobStore, new TextEncoder().encode(json)));
-    const activeUserMessageIndex = context.messages.length - 1;
-    const activeMessage = context.messages[activeUserMessageIndex];
+    const systemPromptIds = buildCursorSystemPromptJsons(request.systemPrompt, model.id).map((json) => storeCursorBlob(blobStore, new TextEncoder().encode(json)));
+    const activeUserMessageIndex = request.messages.length - 1;
+    const activeMessage = request.messages[activeUserMessageIndex];
     const activeUserMessage = activeMessage?.role === "user" ? activeMessage : undefined;
     let userContent;
     let userText = "";
@@ -3691,11 +3700,11 @@ async function buildGrpcRequest(model, context, options, state) {
     // Build conversation turns from prior messages, excluding only the active
     // user message when the request is sending one. Resume actions must
     // preserve trailing tool results.
-    const turns = buildConversationTurns(context.messages, blobStore, activeUserMessage ? activeUserMessageIndex : -1);
+    const turns = buildConversationTurns(request.messages, blobStore, activeUserMessage ? activeUserMessageIndex : -1);
     // Cursor's server uses `rootPromptMessagesJson` (not `turns[]`) to build
     // the actual model prompt; without it multi-turn conversations lose prior
     // context.
-    const rootPromptMessagesJson = buildRootPromptMessagesJson(context.messages, systemPromptIds, blobStore, activeUserMessage ? activeUserMessageIndex : -1);
+    const rootPromptMessagesJson = buildRootPromptMessagesJson(request.messages, systemPromptIds, blobStore, activeUserMessage ? activeUserMessageIndex : -1);
     // Preserve cached non-history state fields (todos, file states, summaries)
     // when the system prompt is unchanged; otherwise start fresh.
     const cachedPromptHead = state.conversationState?.rootPromptMessagesJson?.slice(0, systemPromptIds.length) ?? [];
@@ -3752,7 +3761,7 @@ async function buildGrpcRequest(model, context, options, state) {
     const requestBytes = toBinary(AgentClientMessageSchema, clientMessage);
     log("info", "builtRunRequest", {
         bytes: requestBytes.length,
-        tools: context.tools?.length ?? 0,
+        tools: request.tools.length,
     });
     return { requestBytes, blobStore, conversationState, requestedModel, modelDetails };
 }

package/dist/api/devin-agent/request.d.ts

@@ -2,15 +2,15 @@
  * Builds the Cascade `GetChatMessage` request from senpi's provider-neutral
  * context.
  *
- * Cascade has no system role: the system prompt travels in the top-level
- * `prompt` field, and history is a flat list of `ChatMessagePrompt` entries
- * whose `source` carries the role. Message ids must be UUID-shaped; they are
- * derived deterministically from the conversation id and the entry index so a
- * retried turn re-sends the same ids instead of forking the server-side
- * transcript, while a native Devin turn is replayed under the id the server
- * minted for it.
+ * Cascade has no system role: the system prompt (replayed from the transcript's
+ * system messages) travels in the top-level `prompt` field, and history is a
+ * flat list of `ChatMessagePrompt` entries whose `source` carries the role.
+ * Message ids must be UUID-shaped; they are derived deterministically from the
+ * conversation id and the entry index so a retried turn re-sends the same ids
+ * instead of forking the server-side transcript, while a native Devin turn is
+ * replayed under the id the server minted for it.
  */
-import type { Context, Message, Model } from "../../types.ts";
+import type { Message, Model, TranscriptContext } from "../../types.ts";
 import { type ChatMessagePrompt, type GetChatMessageRequest } from "./gen/cascade_pb.ts";
 /** Cascade's own stop vocabulary; the server echoes these as STOP_PATTERN. */
 export declare const DEVIN_DEFAULT_STOP_PATTERNS: readonly ["<|user|>", "<|bot|>", "<|context_request|>", "<|endoftext|>", "<|end_of_turn|>"];
@@ -20,7 +20,7 @@ export interface DevinModelAssignment {
 }
 export interface DevinChatRequestInput {
     model: Model<"devin-agent">;
-    context: Context;
+    context: TranscriptContext;
     apiKey: string | undefined;
     userJwt?: string;
     cascadeId: string;

package/dist/api/devin-agent/request.js

@@ -2,15 +2,16 @@
  * Builds the Cascade `GetChatMessage` request from senpi's provider-neutral
  * context.
  *
- * Cascade has no system role: the system prompt travels in the top-level
- * `prompt` field, and history is a flat list of `ChatMessagePrompt` entries
- * whose `source` carries the role. Message ids must be UUID-shaped; they are
- * derived deterministically from the conversation id and the entry index so a
- * retried turn re-sends the same ids instead of forking the server-side
- * transcript, while a native Devin turn is replayed under the id the server
- * minted for it.
+ * Cascade has no system role: the system prompt (replayed from the transcript's
+ * system messages) travels in the top-level `prompt` field, and history is a
+ * flat list of `ChatMessagePrompt` entries whose `source` carries the role.
+ * Message ids must be UUID-shaped; they are derived deterministically from the
+ * conversation id and the entry index so a retried turn re-sends the same ids
+ * instead of forking the server-side transcript, while a native Devin turn is
+ * replayed under the id the server minted for it.
  */
 import { create } from "@bufbuild/protobuf";
+import { getCurrentSystemPrompt, getCurrentTools } from "../../utils/transcript.js";
 import { deterministicUuid } from "../cursor-agent/deterministic-id.js";
 import { CacheControlType, ChatMessagePromptSchema, ChatMessageRequestType, ChatMessageSource, ChatToolCallSchema, ChatToolDefinitionSchema, CompletionConfigurationSchema, ConversationalPlannerMode, GetChatMessageRequestSchema, ImageDataSchema, PromptCacheOptionsSchema, } from "./gen/cascade_pb.js";
 import { devinCliMetadata } from "./metadata.js";
@@ -29,17 +30,20 @@ const MIN_TEMPERATURE = 0.0001;
 export function buildDevinChatRequest(input) {
     const temperature = Math.max(input.temperature ?? DEFAULT_TEMPERATURE, MIN_TEMPERATURE);
     const stopPatterns = [...DEVIN_DEFAULT_STOP_PATTERNS, ...(input.stopSequences ?? [])];
+    const { messages } = input.context;
+    // History ids derive from the entry index, so system messages leave the list before mapping.
+    const history = messages.filter((message) => message.role !== "system");
     return create(GetChatMessageRequestSchema, {
         metadata: devinCliMetadata(input.apiKey, input.userJwt ?? ""),
-        prompt: input.context.systemPrompt ?? "",
-        chatMessagePrompts: mapHistory(input.context.messages, input.cascadeId, input.model),
+        prompt: getCurrentSystemPrompt(messages),
+        chatMessagePrompts: mapHistory(history, input.cascadeId, input.model),
         requestType: ChatMessageRequestType.CASCADE,
         plannerMode: ConversationalPlannerMode.DEFAULT,
         chatModelUid: input.assignment?.modelUid ?? input.model.upstreamModelId ?? input.model.id,
         ...(input.assignment ? { modelAssignmentJwt: input.assignment.assignmentJwt } : {}),
         cascadeId: input.cascadeId,
         executionId: crypto.randomUUID(),
-        tools: (input.context.tools ?? []).map(toolDefinition),
+        tools: getCurrentTools(messages).map(toolDefinition),
         toolChoice: { choice: { case: "optionName", value: "auto" } },
         systemPromptCacheOptions: create(PromptCacheOptionsSchema, { type: CacheControlType.EPHEMERAL }),
         disableParallelToolCalls: input.model.compat?.supportsParallelToolCalls !== true,

package/dist/api/google-generative-ai.js

@@ -1,23 +1,19 @@
-import { GoogleGenAI, ThinkingLevel as GoogleGenAIThinkingLevel, } from "@google/genai";
+import { GoogleGenAI, } from "@google/genai";
 import { calculateCost, clampThinkingLevel } from "../models.js";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { providerHeadersToRecord } from "../utils/headers.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { convertMessages, convertTools, isThinkingPart, mapStopReason, resolveGoogleFunctionCallingMode, resolveGoogleThinkingLevel, retainThoughtSignature, retryGoogleRequest, supportsGoogleStrictToolSampling, toProviderNativeContent, } from "./google-shared.js";
+import { getSystemMessageText } from "../utils/text.js";
+import { collapseSystemMessages, getCurrentTools, getInitialSystemMessage } from "../utils/transcript.js";
+import { convertMessages, convertTools, getDisabledGoogleThinkingConfig, isThinkingPart, mapStopReason, resolveGoogleFunctionCallingMode, resolveGoogleThinkingLevel, retainThoughtSignature, retryGoogleRequest, supportsGoogleStrictToolSampling, toGoogleSdkThinkingLevel, toGoogleThinkingLevel, toProviderNativeContent, usesGoogleThinkingLevel, } from "./google-shared.js";
 import { applyExtraBody, buildBaseOptions, GOOGLE_RESERVED_BODY_KEYS } from "./simple-options.js";
-const THINKING_LEVEL_MAP = {
-    THINKING_LEVEL_UNSPECIFIED: GoogleGenAIThinkingLevel.THINKING_LEVEL_UNSPECIFIED,
-    MINIMAL: GoogleGenAIThinkingLevel.MINIMAL,
-    LOW: GoogleGenAIThinkingLevel.LOW,
-    MEDIUM: GoogleGenAIThinkingLevel.MEDIUM,
-    HIGH: GoogleGenAIThinkingLevel.HIGH,
-};
 // Counter for generating unique tool call IDs
 let toolCallCounter = 0;
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const normalizedContext = collapseSystemMessages(context);
     (async () => {
         const output = {
             role: "assistant",
@@ -45,7 +41,7 @@ export const stream = (model, context, options) => {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
             const client = createClient(model, apiKey, providerHeadersToRecord(options?.headers));
-            let params = buildParams(model, context, options);
+            let params = buildParams(model, normalizedContext, options);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
                 params = nextParams;
@@ -58,6 +54,7 @@ export const stream = (model, context, options) => {
             const blocks = output.content;
             const blockIndex = () => blocks.length - 1;
             for await (const chunk of googleStream) {
+                await options?.onProviderStreamEvent?.(chunk, model);
                 // @google/genai documents GenerateContentResponse.responseId as an output-only field
                 // used to identify each response. Keep the first non-empty one from the stream.
                 output.responseId ||= chunk.responseId;
@@ -281,13 +278,12 @@ export const streamSimple = (model, context, options) => {
         return stream(model, context, { ...base, thinking: { enabled: false } });
     }
     const resolvedLevel = resolveGoogleThinkingLevel(model, clampedReasoning);
-    const googleModel = model;
-    if (isGemini3ProModel(googleModel) || isGemini3FlashModel(googleModel) || isGemma4Model(googleModel)) {
+    if (usesGoogleThinkingLevel(model)) {
         return stream(model, context, {
             ...base,
             thinking: {
                 enabled: true,
-                level: getThinkingLevel(resolvedLevel, googleModel),
+                level: toGoogleThinkingLevel(resolvedLevel),
             },
         });
     }
@@ -295,7 +291,7 @@ export const streamSimple = (model, context, options) => {
         ...base,
         thinking: {
             enabled: true,
-            budgetTokens: getGoogleBudget(googleModel, resolvedLevel, options.thinkingBudgets),
+            budgetTokens: getGoogleBudget(model, resolvedLevel, options.thinkingBudgets),
         },
     });
 };
@@ -316,6 +312,8 @@ function createClient(model, apiKey, optionsHeaders) {
 }
 function buildParams(model, context, options = {}) {
     const contents = convertMessages(model, context, { preserveThinking: options.thinking?.enabled === true });
+    const initialSystemMessage = getInitialSystemMessage(context.messages);
+    const currentTools = getCurrentTools(context.messages);
     const generationConfig = {};
     if (options.temperature !== undefined) {
         generationConfig.temperature = options.temperature;
@@ -324,15 +322,15 @@ function buildParams(model, context, options = {}) {
         generationConfig.maxOutputTokens = options.maxTokens;
     }
     const supportsStrictMode = supportsGoogleStrictToolSampling(model.id);
-    const functionCallingMode = context.tools?.length
-        ? resolveGoogleFunctionCallingMode(context.tools, options.toolChoice, supportsStrictMode)
+    const functionCallingMode = currentTools.length > 0
+        ? resolveGoogleFunctionCallingMode(currentTools, options.toolChoice, supportsStrictMode)
         : undefined;
+    const systemInstruction = initialSystemMessage ? getSystemMessageText(initialSystemMessage) : "";
     const config = {
         ...(Object.keys(generationConfig).length > 0 && generationConfig),
-        ...(context.systemPrompt && { systemInstruction: sanitizeSurrogates(context.systemPrompt) }),
-        ...(context.tools &&
-            context.tools.length > 0 && {
-            tools: convertTools(context.tools, false, supportsStrictMode),
+        ...(systemInstruction && { systemInstruction: sanitizeSurrogates(systemInstruction) }),
+        ...(currentTools.length > 0 && {
+            tools: convertTools(currentTools, false, supportsStrictMode),
         }),
         ...(functionCallingMode !== undefined && {
             toolConfig: { functionCallingConfig: { mode: functionCallingMode } },
@@ -341,7 +339,7 @@ function buildParams(model, context, options = {}) {
     if (options.thinking?.enabled && model.reasoning) {
         const thinkingConfig = { includeThoughts: true };
         if (options.thinking.level !== undefined) {
-            thinkingConfig.thinkingLevel = THINKING_LEVEL_MAP[options.thinking.level];
+            thinkingConfig.thinkingLevel = toGoogleSdkThinkingLevel(options.thinking.level);
         }
         else if (options.thinking.budgetTokens !== undefined) {
             thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
@@ -349,7 +347,7 @@ function buildParams(model, context, options = {}) {
         config.thinkingConfig = thinkingConfig;
     }
     else if (model.reasoning && options.thinking && !options.thinking.enabled) {
-        config.thinkingConfig = getDisabledThinkingConfig(model);
+        config.thinkingConfig = getDisabledGoogleThinkingConfig(model);
     }
     if (options.signal) {
         if (options.signal.aborted) {
@@ -365,64 +363,6 @@ function buildParams(model, context, options = {}) {
     };
     return params;
 }
-function isGemma4Model(model) {
-    return /gemma-?4/.test(model.id.toLowerCase());
-}
-function isGemini3ProModel(model) {
-    return /gemini-3(?:\.\d+)?-pro/.test(model.id.toLowerCase());
-}
-function isGemini3FlashModel(model) {
-    const id = model.id.toLowerCase();
-    return /gemini-3(?:\.\d+)?-flash/.test(id) || id === "gemini-flash-latest" || id === "gemini-flash-lite-latest";
-}
-function getDisabledThinkingConfig(model) {
-    // Google docs: Gemini 3.1 Pro cannot disable thinking, and Gemini 3 Flash / Flash-Lite
-    // do not support full thinking-off either. For Gemini 3 models, use the lowest supported
-    // thinkingLevel without includeThoughts so hidden thinking remains invisible to pi.
-    if (isGemini3ProModel(model)) {
-        return { thinkingLevel: GoogleGenAIThinkingLevel.LOW };
-    }
-    if (isGemini3FlashModel(model)) {
-        return { thinkingLevel: GoogleGenAIThinkingLevel.MINIMAL };
-    }
-    if (isGemma4Model(model)) {
-        return { thinkingLevel: GoogleGenAIThinkingLevel.MINIMAL };
-    }
-    // Gemini 2.x supports disabling via thinkingBudget = 0.
-    return { thinkingBudget: 0 };
-}
-function getThinkingLevel(effort, model) {
-    if (isGemini3ProModel(model)) {
-        switch (effort) {
-            case "minimal":
-            case "low":
-                return "LOW";
-            case "medium":
-            case "high":
-                return "HIGH";
-        }
-    }
-    if (isGemma4Model(model)) {
-        switch (effort) {
-            case "minimal":
-            case "low":
-                return "MINIMAL";
-            case "medium":
-            case "high":
-                return "HIGH";
-        }
-    }
-    switch (effort) {
-        case "minimal":
-            return "MINIMAL";
-        case "low":
-            return "LOW";
-        case "medium":
-            return "MEDIUM";
-        case "high":
-            return "HIGH";
-    }
-}
 function getGoogleBudget(model, level, customBudgets) {
     if (customBudgets?.[level] !== undefined) {
         return customBudgets[level];

package/dist/api/google-shared.d.ts

@@ -1,8 +1,8 @@
 /**
  * Shared utilities for Google Generative AI and Google Vertex providers.
  */
-import { type Content, FinishReason, FunctionCallingConfigMode, type Part } from "@google/genai";
-import type { Context, Model, ModelThinkingLevel, ProviderNativeContent, StopReason, StreamOptions, ThinkingLevel, Tool } from "../types.ts";
+import { type Content, FinishReason, FunctionCallingConfigMode, ThinkingLevel as GoogleSdkThinkingLevel, type Part, type ThinkingConfig } from "@google/genai";
+import type { Model, ProviderNativeContent, StopReason, StreamOptions, ThinkingLevel, Tool, TranscriptContext } from "../types.ts";
 type GoogleApiType = "google-generative-ai" | "google-vertex";
 /**
  * Thinking level for Gemini 3 models.
@@ -11,7 +11,16 @@ type GoogleApiType = "google-generative-ai" | "google-vertex";
 export type GoogleApiThinkingLevel = "THINKING_LEVEL_UNSPECIFIED" | "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
 export type ResolvedGoogleThinkingLevel = Exclude<ThinkingLevel, "xhigh" | "max">;
 /** Resolve a supported pi level or model-specific Google mapping to a standard Google level. */
-export declare function resolveGoogleThinkingLevel<T extends GoogleApiType>(model: Model<T>, level: ModelThinkingLevel): ResolvedGoogleThinkingLevel;
+export declare function resolveGoogleThinkingLevel<T extends GoogleApiType>(model: Model<T>, level: ThinkingLevel): ResolvedGoogleThinkingLevel;
+/**
+ * Whether this model uses Gemini's discrete `thinkingLevel` control instead of
+ * the token-based `thinkingBudget` control. Supported levels come from the
+ * model's `thinkingLevelMap`; this only selects the Google wire format.
+ */
+export declare function usesGoogleThinkingLevel<T extends GoogleApiType>(model: Model<T>): boolean;
+export declare function toGoogleThinkingLevel(level: ResolvedGoogleThinkingLevel): GoogleApiThinkingLevel;
+export declare function toGoogleSdkThinkingLevel(level: GoogleApiThinkingLevel): GoogleSdkThinkingLevel;
+export declare function getDisabledGoogleThinkingConfig<T extends GoogleApiType>(model: Model<T>): ThinkingConfig;
 /**
  * Determines whether a streamed Gemini `Part` should be treated as "thinking".
  *
@@ -45,7 +54,7 @@ export declare function requiresToolCallId(modelId: string): boolean;
 /**
  * Convert internal messages to Gemini Content[] format.
  */
-export declare function convertMessages<T extends GoogleApiType>(model: Model<T>, context: Context, options?: {
+export declare function convertMessages<T extends GoogleApiType>(model: Model<T>, context: TranscriptContext, options?: {
     preserveThinking?: boolean;
 }): Content[];
 export declare function toProviderNativeContent(part: Part): ProviderNativeContent;

package/dist/api/google-shared.js

@@ -1,16 +1,23 @@
 /**
  * Shared utilities for Google Generative AI and Google Vertex providers.
  */
-import { FinishReason, FunctionCallingConfigMode } from "@google/genai";
+import { FinishReason, FunctionCallingConfigMode, ThinkingLevel as GoogleSdkThinkingLevel, } from "@google/genai";
+import { clampThinkingLevel } from "../models.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { normalizeToolCallId } from "../utils/tool-call-id.js";
+import { collapseSystemMessages, withoutInitialSystemMessage } from "../utils/transcript.js";
 import { getJsonSchemaToolParameters, resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { transformMessages } from "./transform-messages.js";
+const GOOGLE_SDK_THINKING_LEVEL_MAP = {
+    THINKING_LEVEL_UNSPECIFIED: GoogleSdkThinkingLevel.THINKING_LEVEL_UNSPECIFIED,
+    MINIMAL: GoogleSdkThinkingLevel.MINIMAL,
+    LOW: GoogleSdkThinkingLevel.LOW,
+    MEDIUM: GoogleSdkThinkingLevel.MEDIUM,
+    HIGH: GoogleSdkThinkingLevel.HIGH,
+};
 /** Resolve a supported pi level or model-specific Google mapping to a standard Google level. */
 export function resolveGoogleThinkingLevel(model, level) {
-    if (level === "off")
-        return "high";
     const mapped = model.thinkingLevelMap?.[level];
     const resolvedLevel = typeof mapped === "string" ? mapped.toLowerCase() : level;
     switch (resolvedLevel) {
@@ -23,6 +30,47 @@ export function resolveGoogleThinkingLevel(model, level) {
             throw new Error(`Unsupported Google thinking level mapping for ${model.provider}/${model.id}: ${level} -> ${String(mapped)}`);
     }
 }
+/**
+ * Whether this model uses Gemini's discrete `thinkingLevel` control instead of
+ * the token-based `thinkingBudget` control. Supported levels come from the
+ * model's `thinkingLevelMap`; this only selects the Google wire format.
+ */
+export function usesGoogleThinkingLevel(model) {
+    const id = model.id.toLowerCase();
+    return (
+    // Match Gemini 3 Pro/Flash IDs with or without a minor version, such as
+    // gemini-3-flash-preview, gemini-3.1-pro-preview, and gemini-3.8-flash.
+    /gemini-3(?:\.\d+)?-(?:pro|flash)/.test(id) ||
+        id === "gemini-flash-latest" ||
+        id === "gemini-flash-lite-latest" ||
+        // Match both hosted Gemma 4 naming forms: gemma-4-* and gemma4-*.
+        /gemma-?4/.test(id));
+}
+export function toGoogleThinkingLevel(level) {
+    switch (level) {
+        case "minimal":
+            return "MINIMAL";
+        case "low":
+            return "LOW";
+        case "medium":
+            return "MEDIUM";
+        case "high":
+            return "HIGH";
+    }
+}
+export function toGoogleSdkThinkingLevel(level) {
+    return GOOGLE_SDK_THINKING_LEVEL_MAP[level];
+}
+export function getDisabledGoogleThinkingConfig(model) {
+    if (!usesGoogleThinkingLevel(model))
+        return { thinkingBudget: 0 };
+    const fallback = clampThinkingLevel(model, "off");
+    if (fallback === "off")
+        return { thinkingBudget: 0 };
+    const resolvedLevel = resolveGoogleThinkingLevel(model, fallback);
+    const apiLevel = toGoogleThinkingLevel(resolvedLevel);
+    return { thinkingLevel: toGoogleSdkThinkingLevel(apiLevel) };
+}
 /**
  * Determines whether a streamed Gemini `Part` should be treated as "thinking".
  *
@@ -111,13 +159,15 @@ function appendContent(contents, content) {
  * Convert internal messages to Gemini Content[] format.
  */
 export function convertMessages(model, context, options = {}) {
+    // Gemini has no mid-conversation system messages; the leading prompt is sent as systemInstruction.
+    const conversation = withoutInitialSystemMessage(collapseSystemMessages(context).messages);
     const contents = [];
     const normalizeId = (id) => {
         if (!requiresToolCallId(model.id))
             return id;
         return normalizeToolCallId(id);
     };
-    const transformedMessages = transformMessages(context.messages, model, normalizeId, {
+    const transformedMessages = transformMessages(conversation, model, normalizeId, {
         preserveThinking: options.preserveThinking,
     });
     for (const msg of transformedMessages) {