Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Fit OpenRouter's default max_tokens to the context window, and show "full" when a conversation overflows (#83989)

Paolo Rascunà827ad127db7a
diff --git a/docs/ai/providers.md b/docs/ai/providers.md
index 71864cf3334..809e8d76153 100644
--- a/docs/ai/providers.md
+++ b/docs/ai/providers.md
@@ -175,10 +175,10 @@ Credentials:
Supported models:
-| Model | Model ID |
-| --------------- | ----------------- |
-| DeepSeek Flash | `deepseek-flash` |
-| DeepSeek V4 Pro | `deepseek-v4-pro` |
+| Model | Model ID | Context window (tokens) |
+| --------------- | ----------------- | ----------------------- |
+| DeepSeek Flash | `deepseek-flash` | 1,048,576 |
+| DeepSeek V4 Pro | `deepseek-v4-pro` | 1,048,576 |
Credentials:
diff --git a/frontend/src/metabase/metabot/components/MetabotChat/MetabotChatMessage.tsx b/frontend/src/metabase/metabot/components/MetabotChat/MetabotChatMessage.tsx
index 4a13d4d297b..65ab4cf66e4 100644
--- a/frontend/src/metabase/metabot/components/MetabotChat/MetabotChatMessage.tsx
+++ b/frontend/src/metabase/metabot/components/MetabotChat/MetabotChatMessage.tsx
@@ -22,6 +22,7 @@ import {
getIncompleteTurnMessage,
getIncompleteTurnReason,
isChainOfThoughtMessage,
+ isContextFullError,
isTextPart,
} from "metabase/metabot/state";
import { useDispatch } from "metabase/redux";
@@ -766,7 +767,9 @@ export const Messages = ({
conversationId={conversationId}
isStreaming={isDoingScience && isLastMessage}
onRetry={
- isLastMessage && onRetryMessage
+ isLastMessage &&
+ onRetryMessage &&
+ !isContextFullError(message)
? () => onRetryMessage(message.id)
: undefined
}
diff --git a/frontend/src/metabase/metabot/constants.ts b/frontend/src/metabase/metabot/constants.ts
index f5baf46797f..9beced17f29 100644
--- a/frontend/src/metabase/metabot/constants.ts
+++ b/frontend/src/metabase/metabot/constants.ts
@@ -4,6 +4,10 @@ import { isEmbedding } from "metabase/embedding/config";
export const CONTEXT_WINDOW_WARNING_PERCENT = 90;
+// The server sends this error code when it judges that a rejected turn did
+// not fit the model's context window.
+export const CONTEXT_FULL_ERROR_CODE = "ai_provider_context_full";
+
export const FIXED_METABOT_ENTITY_IDS = {
DEFAULT: "metabotmetabotmetabot" as const,
EMBEDDED: "embeddedmetabotmetabo" as const,
diff --git a/frontend/src/metabase/metabot/state/actions.ts b/frontend/src/metabase/metabot/state/actions.ts
index 45424c03deb..b63d3e3dc53 100644
--- a/frontend/src/metabase/metabot/state/actions.ts
+++ b/frontend/src/metabase/metabot/state/actions.ts
@@ -64,7 +64,11 @@ import type {
MetabotUserChatMessage,
SlashCommand,
} from "./types";
-import { createMessageId, parseSlashCommand } from "./utils";
+import {
+ createMessageId,
+ getServerErrorDisplay,
+ parseSlashCommand,
+} from "./utils";
export const {
addAgentTextDelta,
@@ -717,22 +721,7 @@ export const sendAgentRequest = createAsyncThunk<
shouldRetry: true,
serverStarted,
error: streamedError,
- display: isMatching(
- {
- type: P.union(
- "ai_usage_limit_reached",
- "ai_provider_billing",
- "ai_provider_rate_limit",
- "ai_provider_auth",
- "ai_provider_unavailable",
- ),
- message: P.string,
- },
- streamedError,
- )
- ? // special case where we want to show the returned error from the backend
- { type: "message" as const, message: streamedError.message }
- : undefined,
+ display: getServerErrorDisplay(streamedError),
});
}
diff --git a/frontend/src/metabase/metabot/state/reducer.ts b/frontend/src/metabase/metabot/state/reducer.ts
index 341dd27b1af..d7730658005 100644
--- a/frontend/src/metabase/metabot/state/reducer.ts
+++ b/frontend/src/metabase/metabot/state/reducer.ts
@@ -52,7 +52,11 @@ import type {
MetabotToolCall,
MetabotUserTextChatMessage,
} from "./types";
-import { createMessageId, hasInProgressMessage } from "./utils";
+import {
+ createMessageId,
+ hasInProgressMessage,
+ withServerErrorDisplay,
+} from "./utils";
const isLocationChange = (
action: UnknownAction,
@@ -405,7 +409,9 @@ export const metabot = createSlice({
castDraft(createConversation({ conversationId }));
convo.messages = castDraft(
- messages.map((t) => ({ ...t, parts: [...t.parts] })),
+ messages.map((message) =>
+ withServerErrorDisplay({ ...message, parts: [...message.parts] }),
+ ),
);
convo.state = snapshotState ?? {};
convo.activeToolCalls = activeToolCalls ?? [];
diff --git a/frontend/src/metabase/metabot/state/selectors.ts b/frontend/src/metabase/metabot/state/selectors.ts
index 38a5ffebae9..211578cb518 100644
--- a/frontend/src/metabase/metabot/state/selectors.ts
+++ b/frontend/src/metabase/metabot/state/selectors.ts
@@ -6,6 +6,7 @@ import { getSetting } from "metabase/settings";
import * as Urls from "metabase/urls";
import {
+ CONTEXT_FULL_ERROR_CODE,
CONTEXT_WINDOW_WARNING_PERCENT,
FIXED_METABOT_ENTITY_IDS,
} from "../constants";
@@ -257,10 +258,21 @@ export const getContextUsagePercent = createSelector(
getContextWindowPercentUsage,
);
+export const isContextFullError = (message: MetabotMessage | undefined) =>
+ message?.status.type === "errored" &&
+ message.status.error.type === CONTEXT_FULL_ERROR_CODE;
+
export const getLongChatNotice = createSelector(
- [getContextUsage, getContextUsagePercent],
- (contextUsage, percentUsage): MetabotLongChatNoticeVariant | undefined => {
- if (isContextWindowFull(contextUsage)) {
+ [getMessages, getContextUsage, getContextUsagePercent],
+ (
+ messages,
+ contextUsage,
+ percentUsage,
+ ): MetabotLongChatNoticeVariant | undefined => {
+ if (
+ isContextWindowFull(contextUsage) ||
+ isContextFullError(messages.at(-1))
+ ) {
return "full";
}
return percentUsage >= CONTEXT_WINDOW_WARNING_PERCENT
diff --git a/frontend/src/metabase/metabot/state/selectors.unit.spec.ts b/frontend/src/metabase/metabot/state/selectors.unit.spec.ts
index 11a455f6595..2c608acfd1b 100644
--- a/frontend/src/metabase/metabot/state/selectors.unit.spec.ts
+++ b/frontend/src/metabase/metabot/state/selectors.unit.spec.ts
@@ -187,6 +187,31 @@ describe("metabot selectors", () => {
).toBeUndefined();
});
+ const errored = (errorType: string) =>
+ createMockMetabotMessage({
+ status: { type: "errored", error: { type: errorType } },
+ });
+
+ it("reports full when the last turn failed because the context is full", () => {
+ const state = setup([shortMessage, errored("ai_provider_context_full")]);
+ expect(getLongChatNotice(state, "omnibot")).toBe("full");
+ });
+
+ it("shows nothing when the last turn failed for another reason", () => {
+ const state = setup([shortMessage, errored("ai_provider_billing")]);
+ expect(getLongChatNotice(state, "omnibot")).toBeUndefined();
+ });
+
+ it("shows nothing when only an earlier turn failed because the context is full", () => {
+ const state = setup([
+ shortMessage,
+ errored("ai_provider_context_full"),
+ shortMessage,
+ usage(10000),
+ ]);
+ expect(getLongChatNotice(state, "omnibot")).toBeUndefined();
+ });
+
describe("getContextUsagePercent", () => {
it("reports the last observed usage as a share of the window, 0-100", () => {
const state = setup([shortMessage, usage(CONTEXT_WINDOW / 4)]);
diff --git a/frontend/src/metabase/metabot/state/utils.ts b/frontend/src/metabase/metabot/state/utils.ts
index e9053abc760..3d22ffa689c 100644
--- a/frontend/src/metabase/metabot/state/utils.ts
+++ b/frontend/src/metabase/metabot/state/utils.ts
@@ -1,10 +1,14 @@
import { nanoid } from "@reduxjs/toolkit";
-import { match } from "ts-pattern";
+import { P, isMatching, match } from "ts-pattern";
import { t } from "ttag";
+import { CONTEXT_FULL_ERROR_CODE } from "../constants";
+
import type {
MetabotAgentChainOfThoughtMessage,
MetabotAgentTextChatMessage,
+ MetabotAgentTurnDisplayError,
+ MetabotAgentTurnError,
MetabotGeneratedCardPart,
MetabotIncompleteMessageStatus,
MetabotIncompleteReason,
@@ -38,6 +42,39 @@ export const isGeneratedCardPart = (
part.part.type === "data-generated_entity" &&
part.part.data.type === "card";
+// The error codes whose server-written message the chat shows as is.
+const SERVER_MESSAGE_ERROR_CODES = [
+ "ai_usage_limit_reached",
+ "ai_provider_billing",
+ "ai_provider_rate_limit",
+ "ai_provider_auth",
+ "ai_provider_unavailable",
+ CONTEXT_FULL_ERROR_CODE,
+] as const;
+
+export const getServerErrorDisplay = (
+ error: MetabotAgentTurnError,
+): MetabotAgentTurnDisplayError | undefined =>
+ isMatching(
+ { type: P.union(...SERVER_MESSAGE_ERROR_CODES), message: P.string },
+ error,
+ )
+ ? { type: "message", message: error.message }
+ : undefined;
+
+export const withServerErrorDisplay = (
+ message: MetabotMessage,
+): MetabotMessage =>
+ message.status.type === "errored" && !message.status.display
+ ? {
+ ...message,
+ status: {
+ ...message.status,
+ display: getServerErrorDisplay(message.status.error),
+ },
+ }
+ : message;
+
export const hasInProgressMessage = (messages: MetabotMessage[]): boolean =>
messages.some((message) => message.status.type === "in_progress");
diff --git a/frontend/src/metabase/metabot/state/utils.unit.spec.ts b/frontend/src/metabase/metabot/state/utils.unit.spec.ts
new file mode 100644
index 00000000000..4354a41348a
--- /dev/null
+++ b/frontend/src/metabase/metabot/state/utils.unit.spec.ts
@@ -0,0 +1,32 @@
+import { getServerErrorDisplay } from "./utils";
+
+describe("getServerErrorDisplay", () => {
+ it.each([
+ "ai_usage_limit_reached",
+ "ai_provider_billing",
+ "ai_provider_rate_limit",
+ "ai_provider_auth",
+ "ai_provider_unavailable",
+ "ai_provider_context_full",
+ ])("shows the server message for %s", (type) => {
+ expect(getServerErrorDisplay({ type, message: "copy" })).toEqual({
+ type: "message",
+ message: "copy",
+ });
+ });
+
+ it("shows nothing for an unknown code", () => {
+ expect(
+ getServerErrorDisplay({
+ type: "java.lang.RuntimeException",
+ message: "boom",
+ }),
+ ).toBeUndefined();
+ });
+
+ it("shows nothing without a message", () => {
+ expect(
+ getServerErrorDisplay({ type: "ai_provider_context_full" }),
+ ).toBeUndefined();
+ });
+});
diff --git a/frontend/src/metabase/metabot/tests/errors.unit.spec.tsx b/frontend/src/metabase/metabot/tests/errors.unit.spec.tsx
index d4641977299..43e0ff37380 100644
--- a/frontend/src/metabase/metabot/tests/errors.unit.spec.tsx
+++ b/frontend/src/metabase/metabot/tests/errors.unit.spec.tsx
@@ -1,7 +1,7 @@
import userEvent from "@testing-library/user-event";
import fetchMock from "fetch-mock";
-import { within } from "__support__/ui";
+import { screen, within } from "__support__/ui";
import { METABOT_ERR_MSG } from "metabase/metabot/constants";
import {
@@ -153,6 +153,75 @@ describe("metabot > errors", () => {
]);
});
+ it("should show the full-chat notice for ai_provider_context_full errors", async () => {
+ setup();
+ mockAgentEndpoint({
+ events: [
+ {
+ type: "error",
+ errorText:
+ "This conversation has reached its maximum length and can't continue. Please start a new chat.",
+ },
+ {
+ type: "finish",
+ finishReason: "error",
+ messageMetadata: { errorCode: "ai_provider_context_full" },
+ },
+ ],
+ });
+
+ await enterChatMessage("Who is your favorite?");
+
+ await assertConversation([
+ ["user", "Who is your favorite?"],
+ ["agent", /This conversation has reached its maximum length/],
+ ]);
+ const notice = await screen.findByTestId("metabot-long-chat-notice");
+ expect(notice).toHaveTextContent(/This chat has reached the/);
+ expect(
+ within(notice).getByTestId("metabot-long-chat-new-chat"),
+ ).toBeInTheDocument();
+ expect(screen.queryByTestId("metabot-chat-input")).not.toBeInTheDocument();
+ });
+
+ it("should not offer a retry for ai_provider_context_full errors", async () => {
+ setup();
+ mockAgentEndpoint({
+ events: [
+ {
+ type: "error",
+ errorText:
+ "This conversation has reached its maximum length and can't continue. Please start a new chat.",
+ },
+ {
+ type: "finish",
+ finishReason: "error",
+ messageMetadata: { errorCode: "ai_provider_context_full" },
+ },
+ ],
+ });
+
+ await enterChatMessage("Who is your favorite?");
+
+ expect(
+ await screen.findByTestId("metabot-long-chat-notice"),
+ ).toBeInTheDocument();
+ expect(
+ screen.queryByTestId("metabot-chat-message-retry"),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should offer a retry for other errors", async () => {
+ setup();
+ mockAgentEndpoint({ events: erroredResponse });
+
+ await enterChatMessage("Who is your favorite?");
+
+ expect(
+ await screen.findByTestId("metabot-chat-message-retry"),
+ ).toBeInTheDocument();
+ });
+
it("should mask streamed errors with a generic message", async () => {
setup();
mockAgentEndpoint({ events: erroredResponse });
diff --git a/frontend/src/metabase/metabot/tests/reducer.unit.spec.ts b/frontend/src/metabase/metabot/tests/reducer.unit.spec.ts
index e34f068d28e..fd5846db071 100644
--- a/frontend/src/metabase/metabot/tests/reducer.unit.spec.ts
+++ b/frontend/src/metabase/metabot/tests/reducer.unit.spec.ts
@@ -1,6 +1,7 @@
import { configureStore } from "@reduxjs/toolkit";
import { createDraft } from "immer";
+import { createMockMetabotMessage } from "__support__/server-mocks";
import {
type MetabotState,
metabotActions,
@@ -157,6 +158,29 @@ describe("metabot reducer", () => {
expect(store.getState().metabot.conversations[abandoned]).toBeDefined();
});
+
+ it("rebuilds the display of a server-coded error from a snapshot", () => {
+ const store = createTestStore();
+ const conversationId = testConversationId("omnibot");
+ const error = { type: "ai_provider_context_full", message: "full" };
+ store.dispatch(
+ metabotActions.setConversationSnapshot({
+ conversationId,
+ messages: [
+ createMockMetabotMessage({
+ role: "agent",
+ status: { type: "errored", error },
+ }),
+ ],
+ }),
+ );
+
+ expect(convoForAgent(store, "omnibot").messages[0].status).toEqual({
+ type: "errored",
+ error,
+ display: { type: "message", message: "full" },
+ });
+ });
});
describe("location changes", () => {
diff --git a/frontend/src/metabase/metabot/tests/ui.unit.spec.tsx b/frontend/src/metabase/metabot/tests/ui.unit.spec.tsx
index d2cf4cf6cbb..90c38049a9b 100644
--- a/frontend/src/metabase/metabot/tests/ui.unit.spec.tsx
+++ b/frontend/src/metabase/metabot/tests/ui.unit.spec.tsx
@@ -5,6 +5,7 @@ import { assocIn } from "icepick";
import {
createMockMetabotConversationDetail,
+ createMockMetabotMessage,
createMockMetabotTextMessage,
setupGetMetabotConversationEndpoint,
setupGetMetabotConversationEndpointError,
@@ -749,6 +750,57 @@ describe("metabot > ui", () => {
).not.toBeInTheDocument();
});
+ it("keeps a loaded conversation full when its last turn did not fit the context window", async () => {
+ const FULL_CONVERSATION_ID = "44444444-4444-4444-4444-444444444444";
+ const COPY =
+ "This conversation has reached its maximum length and can't continue. Please start a new chat.";
+ setupGetMetabotConversationEndpoint(
+ createMockMetabotConversationDetail({
+ conversation_id: FULL_CONVERSATION_ID,
+ title: "Too long",
+ messages: [
+ createMockMetabotTextMessage("user", "How many orders?"),
+ createMockMetabotMessage({
+ role: "agent",
+ status: {
+ type: "errored",
+ error: { type: "ai_provider_context_full", message: COPY },
+ },
+ }),
+ ],
+ }),
+ );
+ setup({
+ conversations: [
+ createMockMetabotConversation({
+ conversation_id: FULL_CONVERSATION_ID,
+ title: "Too long",
+ }),
+ ],
+ });
+
+ await selectPastConversation("Too long");
+
+ await assertConversation([
+ ["user", "How many orders?"],
+ ["agent", /This conversation has reached its maximum length/],
+ ]);
+ expect(
+ screen.queryByText(/Something went wrong/),
+ ).not.toBeInTheDocument();
+ const notice = await screen.findByTestId("metabot-long-chat-notice");
+ expect(notice).toHaveTextContent(/This chat has reached the/);
+ expect(
+ within(notice).getByTestId("metabot-long-chat-new-chat"),
+ ).toBeInTheDocument();
+ expect(
+ screen.queryByTestId("metabot-chat-input"),
+ ).not.toBeInTheDocument();
+ expect(
+ screen.queryByTestId("metabot-chat-message-retry"),
+ ).not.toBeInTheDocument();
+ });
+
it("positions a loaded conversation before the next frame", async () => {
jest.spyOn(window, "requestAnimationFrame").mockReturnValue(1);
jest
diff --git a/src/metabase/cmd/ai_provider_dox.clj b/src/metabase/cmd/ai_provider_dox.clj
index 554ab221715..e55ec3eaefc 100644
--- a/src/metabase/cmd/ai_provider_dox.clj
+++ b/src/metabase/cmd/ai_provider_dox.clj
@@ -165,8 +165,8 @@
(defn- known-models-table
"A `{model-id {:display-name ... :context-window ...}}` allow-list as a table, ordered by model ID."
[models]
- ;; the context window column is dropped when nothing in the table publishes one — DeepSeek would otherwise get a
- ;; column of dashes, which reads as missing data rather than as a column that doesn't apply
+ ;; Drop the context window column when no model in the table has a window. A column of only dashes reads as
+ ;; missing data, not as a column that does not apply.
(let [sorted (sort-by key models)
windows? (some (comp :context-window val) sorted)
row (fn [[model-id {:keys [display-name context-window]}]]
diff --git a/src/metabase/metabot/agent/core.clj b/src/metabase/metabot/agent/core.clj
index 35fa67a4d25..572128fcbf5 100644
--- a/src/metabase/metabot/agent/core.clj
+++ b/src/metabase/metabot/agent/core.clj
@@ -560,7 +560,8 @@
{:type :text, :id (str (random-uuid)), :text message})
(defn- error-part [^Exception e]
- {:type :error, :error (or (self/provider-error e)
+ {:type :error, :error (or (self/context-overflow-error e)
+ (self/provider-error e)
{:message (.getMessage e), :type (str (type e)), :data (ex-data e)})})
(defn- accumulate-usage-xf
diff --git a/src/metabase/metabot/persistence.clj b/src/metabase/metabot/persistence.clj
index ed5190b1367..a842974d1ef 100644
--- a/src/metabase/metabot/persistence.clj
+++ b/src/metabase/metabot/persistence.clj
@@ -648,13 +648,21 @@
(and (= :assistant (:role m))
(some? (:error m))))
+(defn- context-full-row?
+ "Whether the errored assistant `row` is a turn the provider rejected as too long for the context window."
+ [row]
+ (= self.core/context-full-error-code (:error-code (decode-error (:error row)))))
+
(defn- drop-errored-pairs
- "Strip errored assistant rows and the preceding user prompt."
+ "Strip errored assistant rows and the user prompt before each, except a context-full turn.
+
+ A context-full turn stays, so a reloaded conversation still reads as full."
[messages]
(reduce (fn [acc msg]
(cond
(not (errored-agent-row? msg)) (conj acc msg)
- (= :user (:role (peek acc))) (pop acc)
+ (context-full-row? msg) (conj acc msg)
+ (= :user (:role (peek acc))) (pop acc)
:else acc))
[]
messages))
@@ -699,6 +707,17 @@
variant it cannot model."
#{"length" "content-filter" "tool-calls"})
+(defn- error->client-error
+ "The stored error as the client reads it: a stored `:error-code` is also its `:type`.
+
+ {:error-code \"ai_provider_context_full\" :message \"m\"}
+ => {:error-code \"ai_provider_context_full\" :message \"m\" :type \"ai_provider_context_full\"}
+
+ The live stream hands the client the same code as `error.type` (`finish.messageMetadata.errorCode`)."
+ [error]
+ (cond-> error
+ (and (map? error) (:error-code error)) (assoc :type (:error-code error))))
+
(defn- row->status
"The message's status, from its own `finished` / `error` / `finish_reason` / `context_window_full` columns.
@@ -714,7 +733,7 @@
{:type "in_progress"}
(some? (:error row))
- {:type "errored" :error (decode-error (:error row))}
+ {:type "errored" :error (error->client-error (decode-error (:error row)))}
(and (contains? row :finished) (not (true? (:finished row))))
{:type "aborted"}
@@ -750,7 +769,7 @@
(defn messages->client-messages
"Convert a seq of `MetabotMessage` model instances into their client shape, one
- per row. Errored pairs are dropped unless `:include-errored? true`."
+ per row. Errored pairs are dropped, except context-full turns, unless `:include-errored? true`."
([messages] (messages->client-messages messages nil))
([messages {:keys [include-errored?]}]
(mapv message->client-message
diff --git a/src/metabase/metabot/schema.clj b/src/metabase/metabot/schema.clj
index 63fa0902749..8c79fe6bb50 100644
--- a/src/metabase/metabot/schema.clj
+++ b/src/metabase/metabot/schema.clj
@@ -209,7 +209,7 @@
["errored"
[:map
[:type [:= "errored"]]
- ;; the decoded `error` column, or its raw text when it isn't JSON
+ ;; the decoded `error` column, or its raw text when it isn't JSON; a stored error-code is also its type
[:error [:or
:string
[:map
diff --git a/src/metabase/metabot/self.clj b/src/metabase/metabot/self.clj
index d29f92cc2a4..13cb81cf1c0 100644
--- a/src/metabase/metabot/self.clj
+++ b/src/metabase/metabot/self.clj
@@ -376,6 +376,61 @@
(or (some-> status (>= 500)) (provider-unavailable-error-types error-type))
:unavailable))
+(def ^:private context-overflow-message
+ "The overflow 400 text of providers that send no structured code for it.
+
+ Probed 2026-10-09 (https://github.com/metabase/metabase/pull/83989): OpenRouter \"This endpoint's maximum context
+ length is 200000 tokens\", DeepSeek \"This model's maximum context length is 1048576 tokens\", Mistral \"Prompt
+ 1000015 > 262144 maximum context length\", Moonshot \"exceeded model token limit: 262144\". Documented: Moonshot
+ \"Input token length too long\" and \"prompt tokens + max_tokens exceeds the model specification\"
+ (https://platform.kimi.ai/docs/api/errors), Anthropic \"prompt is too long\"
+ (https://platform.claude.com/docs/en/build-with-claude/context-windows). Probed 2026-10-13: OpenRouter relays an
+ upstream overflow as that upstream's own text, \"prompt is too long: 250027 tokens > 200000 maximum\". Gemini on
+ Vertex: \"The input token count exceeds the maximum number of tokens allowed 1048576.\" with `INVALID_ARGUMENT`."
+ (re-pattern (str/join "|" ["maximum context length" ; OpenRouter, DeepSeek, Mistral
+ "exceeded model token limit" ; Moonshot
+ "token length too long" ; Moonshot
+ "exceeds the model specification" ; Moonshot
+ "prompt is too long" ; Anthropic; OpenRouter relaying it
+ "input token count exceeds the maximum"]))) ; Gemini
+
+(defn- context-overflow-object?
+ "True when a provider's `error` object says the prompt does not fit the model's context window.
+
+ Reads the object of a 400 body or of an error streamed after a 200."
+ [{:keys [message code metadata]}]
+ (or ;; https://openrouter.ai/docs/api_reference/errors-and-debugging ("Typed error codes")
+ (= "context_length_exceeded" (:error_type metadata))
+ ;; https://docs.z.ai/api-reference/api-code (1261 "Prompt too long")
+ (= "1261" (str code))
+ (boolean (re-find context-overflow-message (str message)))
+ ;; OpenRouter sends an upstream's overflow as "Provider returned error", with no `error_type`. The upstream's own
+ ;; body is a JSON string in `metadata.raw` (probed 2026-10-13, https://github.com/metabase/metabase/pull/83989).
+ (boolean (re-find context-overflow-message (str (:raw metadata))))))
+
+(defn- context-overflow?
+ "True when a provider API error's ex-data is a 400 for a prompt that does not fit the model's context window."
+ [{:keys [status body]}]
+ (and (= status 400)
+ ;; Mistral puts its error at the top level, not under `error`.
+ (context-overflow-object? (or (:error body) body))))
+
+(defn- context-full-error
+ "The user-facing `{:message :error-code}` for a conversation too long for the model's context window."
+ []
+ {:error-code core/context-full-error-code
+ :message (tru "This conversation has reached its maximum length and can''t continue. Please start a new chat.")})
+
+(defn context-overflow-error
+ "A user-facing `{:message :error-code}` for a request too long for the model's context window, or nil.
+
+ Returns the map when the provider rejected the request because the conversation does not fit the window.
+ Unlike [[provider-error]], this also applies on the managed provider: the conversation is full, not the account."
+ [e]
+ (let [data (ex-data e)]
+ (when (and (:api-error data) (context-overflow? data))
+ (context-full-error))))
+
(defn provider-error
"A user-facing `{:message :error-code}` for a provider failure we can explain better than the generic error, or nil.
Takes a provider API exception, or the failure's `provider`, `status` and `error` as [[provider-failure]] reads them.
@@ -410,12 +465,23 @@
(tru "{0} is having problems right now. Try again in a few minutes." provider-name)
(tru "The AI provider is having problems right now. Please try again in a few minutes."))}))))))
+(defn- streamed-error
+ "The user-facing `{:message :error-code}` for an `error` object streamed after a 200, or nil.
+
+ A context overflow gets [[context-full-error]]; there is no status to check. OpenRouter sends every failure after
+ its 200 inside the stream, with a typed `error.metadata.error_type`
+ (https://openrouter.ai/docs/api_reference/errors-and-debugging)."
+ [provider error]
+ (if (context-overflow-object? error)
+ (context-full-error)
+ (provider-error provider nil error)))
+
(defn- provider-error-xf
- "Transducer that replaces the error on a streamed `:error` part with [[provider-error]]'s, when it has one."
+ "Transducer that replaces the error on a streamed `:error` part with [[streamed-error]]'s, when it has one."
[provider]
(map (fn [part]
(if-let [error (when (= :error (:type part))
- (provider-error provider nil (:error part)))]
+ (streamed-error provider (:error part)))]
(assoc part :error error)
part))))
diff --git a/src/metabase/metabot/self/adapter.clj b/src/metabase/metabot/self/adapter.clj
index a77b0d2ae64..a4702755c73 100644
--- a/src/metabase/metabot/self/adapter.clj
+++ b/src/metabase/metabot/self/adapter.clj
@@ -68,8 +68,8 @@
[:error-msg fn?]]])
(def SupportedModels
- "An adapter's allow-list of the models it offers in the picker, keyed by model id. A provider that
- publishes no context window for a model (DeepSeek) records only the display name."
+ "An adapter's allow-list of the models it offers in the picker, keyed by model id.
+ `:context-window` is optional: a model with no known window records only the display name."
[:map-of :string [:map {:closed false, ::mr/deliberately-open true
:description "an allow-list entry; providers add their own flags"}
[:display-name :string]
diff --git a/src/metabase/metabot/self/core.clj b/src/metabase/metabot/self/core.clj
index 6d0d1b5a40f..0fd7e708a6e 100644
--- a/src/metabase/metabot/self/core.clj
+++ b/src/metabase/metabot/self/core.clj
@@ -295,13 +295,16 @@
A constant rather than a setting: the output distribution is the same on every instance, telemetry records no
finish reason so a lowered value would truncate tool calls invisibly, and some surfaces deliberately send no cap
(see the OpenAI builder, and Google Model Garden endpoints, which reach the vLLM builder with no context window)
- or send it only when it fits the context window (see the vLLM builder), so one global knob would mislead.
-
- Where a provider counts the cap against the context window, the cap also takes room from the prompt. Mistral
- (https://docs.mistral.ai/api/endpoint/chat) and Moonshot (https://platform.kimi.ai/docs/api/chat) reject a
- request whose prompt plus cap exceeds the window, and both send this cap on every request: on a 262,144-token
- window a prompt over 230,144 tokens fails while the context meter shows about 88%. The agent loop resends the
- full history and does not compact it, so a long enough conversation reaches this limit."
+ or send it only when it fits the context window (see the vLLM and OpenRouter builders), so one global knob would
+ mislead.
+
+ Some providers document that the cap takes room from the prompt. Mistral documents a 400 when the prompt plus
+ `max_tokens` exceeds the window (https://docs.mistral.ai/api/endpoint/chat). But a probe on mistral-medium-3-5
+ with a 240,000-token prompt and this cap got no 400: it got a 504 after about 5 minutes (probed 2026-10-09,
+ https://github.com/metabase/metabase/pull/83989). Moonshot documents the error for `max_completion_tokens`
+ (https://platform.kimi.ai/docs/api/chat), which Metabot sends (https://github.com/metabase/metabase/pull/83984).
+ The agent loop resends the full history and does not compact it, so a long enough conversation reaches the
+ window."
32000)
(defn mkid
@@ -464,8 +467,8 @@
;; Provider adapters emit AI SDK v5 error chunks (`{:type :error :errorText "..."}`). The rest of the
;; pipeline — `format-error-line` and `metabot.persistence`'s turn finalize — keys off an internal
;; `{:error {:message ...}}` part instead, so translate here. Internally-generated error parts (usage
- ;; limits, agent-loop exceptions) and Claude's error chunks, which keep the provider's own error
- ;; object, already carry an `:error` map; pass those through unchanged.
+ ;; limits, agent-loop exceptions) and the error chunks of Claude and Chat Completions, which keep the
+ ;; provider's own error object, already carry an `:error` map; pass those through unchanged.
:error (if (:error chunk)
chunk
{:type :error :error {:message (:errorText chunk)}})
@@ -622,6 +625,13 @@
(json/encode (schema.v2/check-ui-message-chunk "SSE event" payload))
"\n"))
+(def context-full-error-code
+ "The error code of a turn the provider rejected because the conversation does not fit the context window.
+
+ One name for the value the `error` column stores, the `finish` event streams as `messageMetadata.errorCode`,
+ and the client reads back as `error.type`."
+ "ai_provider_context_full")
+
(defn format-error-line
"An `:error` part's AI SDK `error` SSE event line."
[{:keys [error]}]
diff --git a/src/metabase/metabot/self/deepseek.clj b/src/metabase/metabot/self/deepseek.clj
index 313d7115074..4434556e241 100644
--- a/src/metabase/metabot/self/deepseek.clj
+++ b/src/metabase/metabot/self/deepseek.clj
@@ -52,8 +52,16 @@
(def supported-models
"DeepSeek models offered in the Metabot model picker, keyed by model id.
`list-models` returns the intersection of this map with the `/models` catalog."
- {"deepseek-flash" {:display-name "DeepSeek Flash"}
- "deepseek-v4-pro" {:display-name "DeepSeek V4 Pro"}})
+ ;; Both models answer an overflow with "This model's maximum context length is 1048576 tokens" (probed
+ ;; 2026-10-09, https://github.com/metabase/metabase/pull/83989). DeepSeek's docs state "1M"
+ ;; (https://api-docs.deepseek.com/quick_start/pricing/).
+ {"deepseek-flash" {:display-name "DeepSeek Flash" :context-window 1048576}
+ "deepseek-v4-pro" {:display-name "DeepSeek V4 Pro" :context-window 1048576}})
+
+(mu/defn context-window-tokens :- [:maybe :int]
+ "The input context window for `model`, or nil when it isn't one we know."
+ [model :- [:maybe :string]]
+ (get-in supported-models [model :context-window]))
(def ^:private thinking-enabled-payload
"Sent whenever thinking is allowed. Explicit rather than omitted: DeepSeek ignores an
diff --git a/src/metabase/metabot/self/openai/chat_completions.clj b/src/metabase/metabot/self/openai/chat_completions.clj
index bcc660c0202..62a1729cca8 100644
--- a/src/metabase/metabot/self/openai/chat_completions.clj
+++ b/src/metabase/metabot/self/openai/chat_completions.clj
@@ -259,6 +259,14 @@
(not-empty arguments) (conj {:type :tool-input-delta :toolCallId id :inputTextDelta arguments})
true (conj {:type :tool-input-available :toolCallId id :toolName name})))))
+(defn- error-chunk
+ "The AI SDK `:error` chunk for `error-text`, with the provider's `error` object when it sent one.
+
+ The object keeps fields that the text loses, such as OpenRouter's `metadata.error_type`."
+ [error error-text]
+ (cond-> {:type :error :errorText error-text}
+ (map? error) (assoc :error (assoc error :message error-text))))
+
(defn chat-completions->aisdk-chunks-xf
"Translates Chat Completions streaming chunks into AI SDK v5 protocol chunks.
@@ -421,7 +429,7 @@
:raw-finish-reason @stop-reason)))
;; An error in the stream, e.g. a failure partway through generation
error-text (-> (close!)
- (rf {:type :error :errorText error-text}))))))))))
+ (rf (error-chunk error error-text)))))))))))
;;; Request body
diff --git a/src/metabase/metabot/self/openrouter.clj b/src/metabase/metabot/self/openrouter.clj
index 3c0232efa53..2b6c28e2380 100644
--- a/src/metabase/metabot/self/openrouter.clj
+++ b/src/metabase/metabot/self/openrouter.clj
@@ -14,6 +14,7 @@
[metabase.metabot.self.core :as core]
[metabase.metabot.self.openai.chat-completions :as chat-completions]
[metabase.util.i18n :refer [tru]]
+ [metabase.util.json :as json]
[metabase.util.malli :as mu]))
(set! *warn-on-reflection* true)
@@ -261,6 +262,34 @@
(reasoning-mandatory? model) body
:else (assoc body :reasoning {:enabled false}))))))
+(defn- estimated-prompt-tokens
+ "The estimated prompt tokens of the Chat Completions `body`: its JSON `messages` and `tools` in characters,
+ divided by 4 and rounded up. For example, 700,000 characters of JSON give 175,000.
+
+ OpenRouter's own admission check estimates tokens as characters ÷ 4 (probed in
+ https://github.com/metabase/metabase/pull/82436), and it rejects a request whose prompt plus `max_tokens` exceeds
+ the context length (https://openrouter.ai/docs/api-reference/parameters)."
+ [body]
+ (quot (+ (count (json/encode (select-keys body [:messages :tools]))) 3)
+ 4))
+
+(defn- without-unfitting-default-cap
+ "Remove the default `:max_tokens` from `body` when it does not fit the context window of `model`.
+
+ For example, on Claude Haiku 4.5, a prompt estimated at 175,000 tokens plus the 32,000 default exceeds the
+ 200,000 window, so the body gets no cap.
+
+ Only the default cap is removed: a caller's `max-tokens` is always sent. A model with no known window keeps the
+ default. The bound is inclusive: an estimate plus cap equal to the window keeps the cap."
+ [body max-tokens model]
+ (let [window (context-window-tokens model)]
+ (cond-> body
+ (and (nil? max-tokens)
+ window
+ (> (+ (estimated-prompt-tokens body) (:max_tokens body 0)) window))
+ ;; With no cap, OpenRouter uses its own per-endpoint default (64000 measured on claude-haiku-4.5).
+ (dissoc :max_tokens))))
+
(mu/defn openrouter-request-body
"Build the Chat Completions request body for an LLM request.
@@ -275,13 +304,15 @@
builder instead would apply these OpenRouter-specific rules to every Chat Completions adapter, including vLLM,
whose model names are customer-chosen free text.
- A caller that names no `:max-tokens` gets [[core/chat-max-output-tokens]]."
+ A caller that names no `:max-tokens` gets [[core/chat-max-output-tokens]], but only when it fits the context
+ window with the prompt (see [[without-unfitting-default-cap]])."
[{:keys [model system max-tokens] :as opts
:or {model default-model}} :- core/LLMRequestOpts]
;; `openai/*` models get the default too: the rate-limit metering that keeps
;; [[metabase.metabot.self.openai/openai-request-body]] from sending one is OpenAI's and Azure's, and uncapped,
;; OpenRouter substitutes a per-endpoint default (probed 2026-09-17 on deepseek/deepseek-v4-pro: 16384 on one
- ;; endpoint, 32768 on another).
+ ;; endpoint, 32768 on another). The fit check runs last, on the final body: the forced-call floor in
+ ;; [[with-reasoning-directive]] needs a `:max_tokens` to raise.
(-> (cond-> (chat-completions/request-body
(assoc opts :model model :max-tokens (or max-tokens core/chat-max-output-tokens)))
(and system (anthropic-model? model))
@@ -292,7 +323,8 @@
(not (supports-required-tool-choice? model))
required-tool-choice->auto)
- (with-reasoning-directive (assoc opts :model model))))
+ (with-reasoning-directive (assoc opts :model model))
+ (without-unfitting-default-cap max-tokens model)))
(mu/defn openrouter-raw
"Perform a streaming request to the Chat Completions API.
diff --git a/src/metabase/metabot/self/registry.clj b/src/metabase/metabot/self/registry.clj
index 1995250572f..06d1ff02b01 100644
--- a/src/metabase/metabot/self/registry.clj
+++ b/src/metabase/metabot/self/registry.clj
@@ -96,6 +96,7 @@
"deepseek" {:stream #'deepseek/deepseek
:list-models #'deepseek/list-models
:supported-models #'deepseek/supported-models
+ :context-window #'deepseek/context-window-tokens
:reasoning? #'deepseek/streams-reasoning?}
"google" {:stream #'google/google
:list-models #'google/list-models
diff --git a/src/metabase/metabot/self/zai.clj b/src/metabase/metabot/self/zai.clj
index 2651ae57e40..192f8ab92d5 100644
--- a/src/metabase/metabot/self/zai.clj
+++ b/src/metabase/metabot/self/zai.clj
@@ -136,10 +136,15 @@
(def ^:private stop-reasons
"Z.AI signals a filtered response with `sensitive` rather than OpenAI's `content_filter`, and reports an upstream
- failure as a finish reason instead of an error event."
+ failure as a finish reason instead of an error event.
+
+ Z.AI also lists `model_context_window_exceeded` with no description
+ (https://docs.z.ai/api-reference/llm/chat-completion). It maps to `length`, as Anthropic's reason of the same name
+ does in `metabase.metabot.self.claude`, so a stop at the context window reads as an incomplete turn."
(assoc chat-completions/stop-reasons
- "sensitive" "content-filter"
- "network_error" "error"))
+ "sensitive" "content-filter"
+ "network_error" "error"
+ "model_context_window_exceeded" "length"))
(defn zai->aisdk-chunks-xf
"Translates Z.AI Chat Completions streaming chunks into AI SDK v5 protocol chunks.
diff --git a/src/metabase/slackbot/streaming.clj b/src/metabase/slackbot/streaming.clj
index a4924d83a0f..7197d95516a 100644
--- a/src/metabase/slackbot/streaming.clj
+++ b/src/metabase/slackbot/streaming.clj
@@ -26,6 +26,7 @@
[metabase.slackbot.query :as slackbot.query]
[metabase.system.core :as system]
[metabase.util :as u]
+ [metabase.util.i18n :refer [tru]]
[metabase.util.json :as json]
[metabase.util.log :as log]
[metabase.util.string :as u.str])
@@ -249,6 +250,10 @@
"ai_provider_billing" "ai_provider_rate_limit" "ai_provider_auth" "ai_provider_unavailable"} code)
(:message error)
+ ;; Not the web copy in `:message`: in Slack, the user continues in a new thread, not a new chat.
+ (= code self.core/context-full-error-code)
+ (tru "This conversation has reached its maximum length and can''t continue. Please start a new thread.")
+
(provider-config-error-codes code)
"The AI provider isn't configured correctly. Ask your Metabase admin to check the AI settings."
diff --git a/test/metabase/metabot/agent/core_test.clj b/test/metabase/metabot/agent/core_test.clj
index a1195f458cf..9ee68561d18 100644
--- a/test/metabase/metabot/agent/core_test.clj
+++ b/test/metabase/metabot/agent/core_test.clj
@@ -1098,6 +1098,140 @@
(is (=? [{:error {:error-code "ai_provider_unavailable" :message #"The AI provider is having problems .*"}}]
(mt/as-admin (error-parts "metabase/anthropic/claude-sonnet-4-6" claude-fn))))))))
+(defn- rethrown-api-error!
+ "What an adapter throws when `provider` answers with HTTP `status` and the JSON `body`."
+ [provider status body]
+ (mt/with-log-level [metabase.metabot.self.core :fatal]
+ (try
+ (self.core/rethrow-api-error! provider
+ (constantly "API error")
+ (ex-info "clj-http error"
+ {:status status
+ :headers {"content-type" "application/json"}
+ :body (json/encode body)}))
+ (catch clojure.lang.ExceptionInfo e
+ e))))
+
+(def ^:private context-full-copy
+ "This conversation has reached its maximum length and can't continue. Please start a new chat.")
+
+(defn- agent-loop-error-parts!
+ "The `:error` parts of an agent loop on `model-ref` whose provider call throws `e`."
+ [model-ref e]
+ (mt/with-temporary-setting-values [llm-providers llm.tu/default-connections
+ llm-metabot-provider model-ref]
+ (mt/with-dynamic-fn-redefs [openrouter/openrouter (fn [_] (throw e))
+ claude/claude (fn [_] (throw e))]
+ (mt/with-log-level [metabase.metabot.agent.core :fatal]
+ (filterv #(= :error (:type %))
+ (run-agent-loop {:messages [{:role :user :content "Hi"}]
+ :state {}
+ :profile-id :embedding_next
+ :context {}}))))))
+
+(def ^:private openrouter-overflow-body
+ "OpenRouter's 400 body for a request over the window (probed 2026-10-09,
+ https://github.com/metabase/metabase/pull/83989)."
+ {:error {:message (str "This endpoint's maximum context length is 200000 tokens. However, you requested about "
+ "200001 tokens (1 of text input, 200000 in the output).")
+ :code 400
+ :metadata {:provider_name nil}}})
+
+(def ^:private openrouter-relayed-overflow-body
+ "OpenRouter's 400 body when every upstream refused a prompt over the window (probed 2026-10-13,
+ https://github.com/metabase/metabase/pull/83989). The overflow text is only in the upstream's own body, a JSON
+ string in `metadata.raw`."
+ {:error {:message "Provider returned error"
+ :code 400
+ :metadata {:raw (str "{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\","
+ "\"message\":\"prompt is too long: 250027 tokens > 200000 maximum\"},"
+ "\"request_id\":\"req_011\"}")
+ :provider_name "Azure"
+ :is_byok false
+ :previous_errors [{:code 400
+ :message "Provider returned error"
+ :provider_name "Amazon Bedrock"
+ :raw "{\"message\":\"prompt is too long: 250027 tokens > 200000 maximum\"}"}]}}})
+
+(deftest agent-loop-context-overflow-error-part-test
+ (testing "a 400 for a request over the window becomes a \"full\" error part with the web copy"
+ (doseq [[model-ref provider body]
+ [["openrouter/anthropic/claude-haiku-4.5" "openrouter" openrouter-overflow-body]
+ ["openrouter/anthropic/claude-haiku-4.5" "openrouter" openrouter-relayed-overflow-body]
+ ;; https://platform.claude.com/docs/en/build-with-claude/context-windows
+ ["anthropic/claude-sonnet-4-6" "anthropic"
+ {:type "error"
+ :error {:type "invalid_request_error"
+ :message "prompt is too long: 208310 tokens > 200000 maximum"}}]]]
+ (testing provider
+ (let [e (rethrown-api-error! provider 400 body)
+ parts [{:type :error
+ :error {:error-code "ai_provider_context_full" :message context-full-copy}}]]
+ (is (= parts (mt/as-admin (agent-loop-error-parts! model-ref e))))
+ (is (= parts (mt/with-current-user (mt/user->id :rasta)
+ (agent-loop-error-parts! model-ref e)))))))))
+
+(defn- openrouter-midstream-error-chunks
+ "OpenRouter's documented mid-stream error event carrying `error`, after a first chunk of text.
+
+ The event is the Chat Completions example at https://openrouter.ai/docs/api_reference/errors-and-debugging, with
+ its `model`, `provider` and `error` values replaced."
+ [error]
+ [{:id "gen-abc123"
+ :object "chat.completion.chunk"
+ :created 1234567890
+ :model "anthropic/claude-haiku-4.5"
+ :choices [{:index 0 :delta {:role "assistant" :content "Here's what I fou"} :finish_reason nil}]}
+ {:id "gen-abc123"
+ :object "chat.completion.chunk"
+ :created 1234567890
+ :model "anthropic/claude-haiku-4.5"
+ :provider "Anthropic"
+ :error error
+ :choices [{:index 0 :delta {:content ""} :finish_reason "error"}]}])
+
+(defn- agent-loop-streamed-error-parts!
+ "The `:error` parts of an agent loop on OpenRouter whose stream sends the raw Chat Completions `chunks`."
+ [chunks]
+ (mt/with-temporary-setting-values [llm-providers llm.tu/default-connections
+ llm-metabot-provider "openrouter/anthropic/claude-haiku-4.5"]
+ (mt/with-dynamic-fn-redefs [openrouter/openrouter (fn [_]
+ (eduction (openrouter/openrouter->aisdk-chunks-xf) chunks))]
+ (filterv #(= :error (:type %))
+ (run-agent-loop {:messages [{:role :user :content "Hi"}]
+ :state {}
+ :profile-id :embedding_next
+ :context {}})))))
+
+(deftest agent-loop-streamed-context-overflow-error-part-test
+ (testing "an overflow OpenRouter streams after its 200 becomes a \"full\" error part with the web copy"
+ (let [chunks (openrouter-midstream-error-chunks {:code 400
+ :message "Provider returned error"
+ :metadata {:error_type "context_length_exceeded"}})
+ errors [{:error-code "ai_provider_context_full" :message context-full-copy}]]
+ (is (= errors (map :error (mt/as-admin (agent-loop-streamed-error-parts! chunks)))))
+ (is (= errors (map :error (mt/with-current-user (mt/user->id :rasta)
+ (agent-loop-streamed-error-parts! chunks)))))))
+ (testing "any other streamed error keeps no error code"
+ (let [error {:code 400 :message "string too long" :metadata {:error_type "string_too_long"}}]
+ (is (= [error]
+ (map :error (mt/as-admin (agent-loop-streamed-error-parts! (openrouter-midstream-error-chunks error)))))))))
+
+(deftest agent-loop-other-400s-keep-the-generic-error-part-test
+ (testing "a 400 that is not a context overflow keeps the generic error part"
+ (doseq [[model-ref provider body]
+ [["openrouter/anthropic/claude-haiku-4.5" "openrouter"
+ {:error {:code 400 :message "string too long" :metadata {:error_type "string_too_long"}}}]
+ ["openrouter/anthropic/claude-haiku-4.5" "openrouter"
+ {:error {:code 400 :message "Bad request"}}]]]
+ (testing (str provider " " (pr-str body))
+ (let [e (rethrown-api-error! provider 400 body)]
+ (is (= [{:type :error
+ :error {:message (ex-message e)
+ :type (str (type e))
+ :data (ex-data e)}}]
+ (mt/as-admin (agent-loop-error-parts! model-ref e)))))))))
+
;;; ===================== Prometheus Metrics Tests =====================
(deftest run-agent-loop-prometheus-test
diff --git a/test/metabase/metabot/api_test.clj b/test/metabase/metabot/api_test.clj
index 7fff1c3eb0d..a210cac603d 100644
--- a/test/metabase/metabot/api_test.clj
+++ b/test/metabase/metabot/api_test.clj
@@ -229,6 +229,48 @@
(testing "a Slack thread does not"
(is (false? (offered? thread)))))))))))
+(deftest native-agent-streaming-context-overflow-error-test
+ (testing "an OpenRouter 400 for a request over the window streams the \"full\" copy and error code"
+ (mt/with-temporary-setting-values [llm.settings/llm-providers llm.tu/default-connections
+ metabot.settings/llm-metabot-provider test-provider]
+ (binding [scope/*current-user-metabot-permissions* scope/all-yes-permissions]
+ (let [conversation-id (str (random-uuid))
+ ;; OpenRouter's 400 body for a request over the window (probed 2026-10-09,
+ ;; https://github.com/metabase/metabase/pull/83989).
+ e (ex-info "OpenRouter API error (HTTP 400)"
+ {:api-error true
+ :status 400
+ :provider "openrouter"
+ :body {:error {:message "This endpoint's maximum context length is 200000 tokens."
+ :code 400
+ :metadata {:provider_name nil}}}})]
+ (mt/with-dynamic-fn-redefs [openrouter/openrouter (fn [_] (throw e))
+ conversation-title/ensure-title! (constantly {:status :ready
+ :title "Orders by Month"})]
+ (mt/with-model-cleanup [:model/MetabotMessage
+ [:model/MetabotConversation :created_at]]
+ (let [response (mt/with-log-level [metabase.metabot.agent.core :fatal]
+ (mt/user-http-request :rasta :post 202 "metabot/agent-streaming"
+ {:message "Test full context"
+ :context {}
+ :conversation_id conversation-id
+ :state {}}))
+ events (->> (str/split-lines response)
+ (filter #(str/starts-with? % "data: "))
+ (remove #(= "data: [DONE]" %))
+ (mapv #(json/decode+kw (subs % 6))))]
+ (is (=? {:errorText "This conversation has reached its maximum length and can't continue. Please start a new chat."}
+ (u/seek #(= "error" (:type %)) events)))
+ (is (=? {:finishReason "error"
+ :messageMetadata {:errorCode "ai_provider_context_full"}}
+ (u/seek #(= "finish" (:type %)) events)))
+ (testing "the conversation endpoint keeps the turn, so a reload still reads as full"
+ (is (=? [{:role "user"}
+ {:role "agent"
+ :status {:type "errored" :error {:type "ai_provider_context_full" :message string?}}}]
+ (:messages (mt/user-http-request :rasta :get 200
+ (str "metabot/conversations/" conversation-id))))))))))))))
+
(def ^:private openrouter-error-chunks
"Raw OpenRouter chunks for a generation the upstream model abandoned: OpenRouter reports that as
`finish_reason \"error\"` rather than as an error event."
@@ -280,6 +322,60 @@
(:messages (mt/user-http-request :rasta :get 200
(str "metabot/conversations/" conversation-id)))))))))))))))
+(def ^:private openrouter-midstream-overflow-chunks
+ "Raw OpenRouter chunks for an overflow streamed after the 200: a first chunk of text, then OpenRouter's documented
+ mid-stream error event.
+
+ The event is the Chat Completions example at https://openrouter.ai/docs/api_reference/errors-and-debugging, with
+ `error.code` 400, `error.message` \"Provider returned error\" and `error.metadata.error_type`
+ \"context_length_exceeded\" in place of the example's rate-limit values."
+ [{:id "gen-abc123"
+ :object "chat.completion.chunk"
+ :created 1234567890
+ :model "anthropic/claude-haiku-4.5"
+ :choices [{:index 0 :delta {:role "assistant" :content "Here's what I fou"} :finish_reason nil}]}
+ {:id "gen-abc123"
+ :object "chat.completion.chunk"
+ :created 1234567890
+ :model "anthropic/claude-haiku-4.5"
+ :provider "Anthropic"
+ :error {:code 400 :message "Provider returned error" :metadata {:error_type "context_length_exceeded"}}
+ :choices [{:index 0 :delta {:content ""} :finish_reason "error"}]}])
+
+(deftest native-agent-streaming-openrouter-midstream-context-overflow-test
+ (testing "an overflow OpenRouter streams after its 200 streams the \"full\" copy and error code"
+ (mt/with-temporary-setting-values [llm.settings/llm-providers llm.tu/default-connections
+ metabot.settings/llm-metabot-provider test-provider]
+ (binding [scope/*current-user-metabot-permissions* scope/all-yes-permissions]
+ (let [conversation-id (str (random-uuid))]
+ (mt/with-dynamic-fn-redefs [openrouter/openrouter (fn [_]
+ (eduction (openrouter/openrouter->aisdk-chunks-xf)
+ openrouter-midstream-overflow-chunks))
+ conversation-title/ensure-title! (constantly {:status :ready
+ :title "Orders by Month"})]
+ (mt/with-model-cleanup [:model/MetabotMessage
+ [:model/MetabotConversation :created_at]]
+ (let [response (mt/user-http-request :rasta :post 202 "metabot/agent-streaming"
+ {:message "Test full context"
+ :context {}
+ :conversation_id conversation-id
+ :state {}})
+ events (->> (str/split-lines response)
+ (filter #(str/starts-with? % "data: "))
+ (remove #(= "data: [DONE]" %))
+ (mapv #(json/decode+kw (subs % 6))))]
+ (is (=? {:errorText "This conversation has reached its maximum length and can't continue. Please start a new chat."}
+ (u/seek #(= "error" (:type %)) events)))
+ (is (=? {:finishReason "error"
+ :messageMetadata {:errorCode "ai_provider_context_full"}}
+ (u/seek #(= "finish" (:type %)) events)))
+ (testing "the conversation endpoint keeps the turn, so a reload still reads as full"
+ (is (=? [{:role "user"}
+ {:role "agent"
+ :status {:type "errored" :error {:type "ai_provider_context_full" :message string?}}}]
+ (:messages (mt/user-http-request :rasta :get 200
+ (str "metabot/conversations/" conversation-id))))))))))))))
+
(deftest emits-title-event-inline-when-ready-during-stream-test
(testing "when the title becomes ready while streaming, the real title event is injected inline before the finish event"
(let [conversation-id (str (random-uuid))
diff --git a/test/metabase/metabot/persistence_test.clj b/test/metabase/metabot/persistence_test.clj
index dbf841fc306..4575bec6a89 100644
--- a/test/metabase/metabot/persistence_test.clj
+++ b/test/metabase/metabot/persistence_test.clj
@@ -971,6 +971,19 @@
(is (= {:type "errored" :error {:message "boom"}} (:status message)))
(is (not-any? annotated? (:parts message))))))
+(deftest ^:parallel message->client-message-error-code-test
+ (testing "a stored error code is also the client's `error.type`, as on the live stream"
+ (is (= {:type "errored"
+ :error {:error-code "ai_provider_context_full" :message "m" :type "ai_provider_context_full"}}
+ (:status (client-message
+ {:role :assistant :finished true :data []
+ :error (json/encode {:error-code "ai_provider_context_full" :message "m"})})))))
+ (testing "an error without a code keeps its stored type"
+ (is (= {:type "errored" :error {:message "boom" :type "java.lang.RuntimeException"}}
+ (:status (client-message
+ {:role :assistant :finished true :data []
+ :error (json/encode {:message "boom" :type "java.lang.RuntimeException"})}))))))
+
(deftest ^:parallel message->client-message-incomplete-status-test
(testing "a turn that stopped early reloads as incomplete, carrying the reason"
(doseq [reason ["length" "content-filter" "tool-calls"]]
@@ -1034,7 +1047,25 @@
{:type "errored" :error {:message "boom"}}
{:type "done"}
{:type "done"}]
- (mapv :status result))))))
+ (mapv :status result)))))
+ (testing "a context-full turn stays, so a reloaded conversation still reads as full"
+ (let [result (metabot-persistence/messages->client-messages
+ [{:id 1 :role :user :data [{:type "text" :text "first"}]}
+ {:id 2 :role :assistant :data [{:type "text" :text "first reply"}]}
+ {:id 3 :role :user :data [{:type "text" :text "too long"}]}
+ {:id 4 :role :assistant :finished true :data []
+ :error (json/encode {:error-code "ai_provider_context_full" :message "full"})}])]
+ (is (= ["1" "2" "3" "4"] (mapv :id result)))
+ (is (=? {:type "errored" :error {:type "ai_provider_context_full" :message "full"}}
+ (:status (peek result))))))
+ (testing "an errored turn with another code is still dropped"
+ (is (= ["1" "2"]
+ (mapv :id (metabot-persistence/messages->client-messages
+ [{:id 1 :role :user :data [{:type "text" :text "first"}]}
+ {:id 2 :role :assistant :data [{:type "text" :text "first reply"}]}
+ {:id 3 :role :user :data [{:type "text" :text "broken"}]}
+ {:id 4 :role :assistant :finished true :data []
+ :error (json/encode {:error-code "ai_provider_unavailable" :message "m"})}]))))))
(defn- start-and-finalize!
"Run start-turn! then finalize-assistant-turn! with a one-text-part body (as :rasta).
diff --git a/test/metabase/metabot/self/google_test.clj b/test/metabase/metabot/self/google_test.clj
index 875b8b9a743..2833dfd315c 100644
--- a/test/metabase/metabot/self/google_test.clj
+++ b/test/metabase/metabot/self/google_test.clj
@@ -6,6 +6,7 @@
[clojure.test :refer :all]
[metabase.llm.provider :as llm.provider]
[metabase.llm.settings :as llm.settings]
+ [metabase.metabot.self :as self]
[metabase.metabot.self.core :as self.core]
[metabase.metabot.self.debug :as debug]
[metabase.metabot.self.google :as google]
@@ -863,6 +864,29 @@
:headers {"content-type" "application/json"}
:body body}))))
+(def ^:private context-overflow-body
+ "Google's 400 for an input over the model's context window, probed 2026-10-13 on gemini-3.5-flash
+ (https://github.com/metabase/metabase/pull/83989)."
+ (json/encode {:error {:code 400
+ :message "The input token count exceeds the maximum number of tokens allowed 1048576."
+ :status "INVALID_ARGUMENT"}}))
+
+(deftest google-context-overflow-is-full-test
+ (testing "Google's 400 for an input over the context window makes the conversation \"full\""
+ (mt/with-temporary-setting-values [llm.settings/llm-google-oauth-access-token "ya29.pasted-access-token"
+ llm.settings/llm-google-service-account-key nil
+ llm.settings/llm-google-project-id "my-project"
+ llm.settings/llm-google-location nil]
+ (mt/with-dynamic-fn-redefs [http/request (stub-error (atom []) 400 context-overflow-body)]
+ (let [e (try
+ (into [] (google {:model "google/gemini-3.5-flash"
+ :input [{:role :user :content "hi"}]}))
+ (catch clojure.lang.ExceptionInfo e
+ e))]
+ (is (=? {:status 400} (ex-data e)))
+ (is (= self.core/context-full-error-code
+ (:error-code (self/context-overflow-error e)))))))))
+
(deftest list-models-anthropic-empty-body-probe-test
(testing "an anthropic model is probed by posting an empty body to its own streamRawPredict route"
(mt/with-temporary-setting-values [llm.settings/llm-google-oauth-access-token "ya29.pasted-access-token"
diff --git a/test/metabase/metabot/self/openai/chat_completions_test.clj b/test/metabase/metabot/self/openai/chat_completions_test.clj
index 8d438345a03..1296700e44b 100644
--- a/test/metabase/metabot/self/openai/chat_completions_test.clj
+++ b/test/metabase/metabot/self/openai/chat_completions_test.clj
@@ -893,17 +893,45 @@
:choices [{:index 0 :delta {:role "assistant" :content "Hel"} :finish_reason nil}]}
error-chunk]))))
(testing "without emitting any chunk of a half-streamed tool call"
- (is (= [{:type :start :messageId "chatcmpl-5"}
- {:type :error :errorText message}]
- (into [] xf
- [{:id "chatcmpl-5"
- :model "kimi-k2.6"
- :choices [{:index 0
- :delta {:tool_calls [{:index 0
- :id "call-1"
- :type "function"
- :function {:name "search" :arguments "{\"query\": \"rev"}}]}}]}
- error-chunk]))))))))
+ (is (=? [{:type :start :messageId "chatcmpl-5"}
+ {:type :error :errorText message}]
+ (into [] xf
+ [{:id "chatcmpl-5"
+ :model "kimi-k2.6"
+ :choices [{:index 0
+ :delta {:tool_calls [{:index 0
+ :id "call-1"
+ :type "function"
+ :function {:name "search" :arguments "{\"query\": \"rev"}}]}}]}
+ error-chunk]))))))))
+
+(def ^:private openrouter-midstream-overflow-chunk
+ "OpenRouter's documented mid-stream error event for a context overflow.
+
+ The event is the Chat Completions example at https://openrouter.ai/docs/api_reference/errors-and-debugging, with
+ `error.code` 400, `error.message` \"Provider returned error\" and `error.metadata.error_type`
+ \"context_length_exceeded\" in place of the example's rate-limit values."
+ {:id "gen-abc123"
+ :object "chat.completion.chunk"
+ :created 1234567890
+ :model "anthropic/claude-haiku-4.5"
+ :provider "Anthropic"
+ :error {:code 400 :message "Provider returned error" :metadata {:error_type "context_length_exceeded"}}
+ :choices [{:index 0 :delta {:content ""} :finish_reason "error"}]})
+
+(deftest ^:parallel chunks-xf-streamed-error-keeps-the-error-object-test
+ (testing "an error object sent partway through a stream rides on the error chunk, with its typed fields"
+ (is (= [{:type :error
+ :errorText "Provider returned error"
+ :error {:code 400
+ :message "Provider returned error"
+ :metadata {:error_type "context_length_exceeded"}}}]
+ (filterv #(= :error (:type %)) (into [] (openrouter/openrouter->aisdk-chunks-xf)
+ [openrouter-midstream-overflow-chunk])))))
+ (testing "an error finish reason with no error object carries only the text"
+ (is (= [{:type :error :errorText "The model provider failed to complete the response"}]
+ (filterv #(= :error (:type %)) (into [] (openrouter/openrouter->aisdk-chunks-xf)
+ [{:choices [{:index 0 :delta {} :finish_reason "error"}]}]))))))
;;; ──────────────────────────────────────────────────────────────────
;;; Error finish reason tests
diff --git a/test/metabase/metabot/self/openrouter_test.clj b/test/metabase/metabot/self/openrouter_test.clj
index 640f20fb920..d995dd75cf0 100644
--- a/test/metabase/metabot/self/openrouter_test.clj
+++ b/test/metabase/metabot/self/openrouter_test.clj
@@ -9,7 +9,8 @@
[metabase.metabot.self.openrouter :as openrouter]
[metabase.metabot.test-util :as metabot.tu]
[metabase.premium-features.core :as premium-features]
- [metabase.test :as mt]))
+ [metabase.test :as mt]
+ [metabase.util.json :as json]))
(set! *warn-on-reflection* true)
@@ -306,6 +307,92 @@
{:choices [{:delta {} :finish_reason "stop"}]
:usage {:prompt_tokens 8 :completion_tokens 1 :total_tokens 9}}])))))
+;;; ──────────────────────────────────────────────────────────────────
+;;; Default cap fit check
+;;; ──────────────────────────────────────────────────────────────────
+
+;; Claude Haiku 4.5 has a 200,000-token window. With the 32,000 default cap, the largest prompt
+;; estimate that fits is 168,000 tokens, which is 672,000 characters of JSON at 4 characters a token.
+
+(def ^:private haiku "anthropic/claude-haiku-4.5")
+
+(def ^:private stub-tool
+ {:tool-name "get_thing"
+ :doc "Get a thing."
+ :schema [:=> [:cat [:map [:id :int]]] :any]
+ :fn identity})
+
+(defn- letters
+ "A string of `n` ASCII letters, which JSON encodes with no escapes."
+ [n]
+ (String. (char-array n \a)))
+
+(defn- prompt-json-length
+ "The number of characters in the JSON of the `messages` and `tools` of `body`."
+ [body]
+ (count (json/encode (select-keys body [:messages :tools]))))
+
+(defn- padded-content
+ "A user message text that makes the JSON of the `messages` and `tools` of the body for `opts` `n` characters long."
+ [opts n]
+ (let [base (prompt-json-length (openrouter/openrouter-request-body
+ (assoc opts :input [{:role :user :content ""}])))]
+ (letters (- n base))))
+
+(defn- body-with-json-length
+ "The request body for `opts`, with one user message padded so the JSON of its `messages` and `tools` is `n`
+ characters long."
+ [opts n]
+ (let [opts (merge {:model haiku} opts)
+ body (openrouter/openrouter-request-body
+ (assoc opts :input [{:role :user :content (padded-content opts n)}]))]
+ (is (= n (prompt-json-length body)) "calibration")
+ body))
+
+(deftest ^:parallel request-body-drops-default-cap-when-prompt-does-not-fit-test
+ (testing "an estimated 168,001-token prompt plus the 32,000 default cap exceeds Haiku 4.5's 200,000 window"
+ (is (not (contains? (body-with-json-length {} (* 4 168001)) :max_tokens)))))
+
+(deftest ^:parallel request-body-keeps-default-cap-when-prompt-fits-test
+ (is (= 32000 (:max_tokens (body-with-json-length {} (* 4 150000))))))
+
+(deftest ^:parallel request-body-always-sends-caller-cap-test
+ (testing "a caller cap is sent even when the prompt does not fit with it"
+ (is (= 512 (:max_tokens (body-with-json-length {:max-tokens 512} (* 4 200000)))))))
+
+(deftest ^:parallel request-body-keeps-default-cap-for-unknown-window-test
+ (testing "a model with no catalog window keeps the default cap"
+ (is (= 32000 (:max_tokens (body-with-json-length {:model "some-vendor/unknown-model"} (* 4 200000)))))))
+
+(deftest ^:parallel request-body-fit-check-runs-after-the-forced-call-floor-test
+ (testing "a forced call on a mandatory-reasoning model is fit-checked after its max_tokens floor"
+ (let [body (body-with-json-length {:model "openai/gpt-5.4-pro"
+ :schema {:type "object" :properties {:answer {:type "string"}}}}
+ (* 4 900000))]
+ (is (not (contains? body :max_tokens))))))
+
+(deftest ^:parallel request-body-anthropic-system-counts-toward-the-fit-test
+ (testing "the system prompt counts toward the estimate"
+ (let [body (openrouter/openrouter-request-body {:model haiku
+ :system (letters (* 4 168001))
+ :input [{:role :user :content "hi"}]})]
+ (is (not (contains? body :max_tokens))))))
+
+(deftest ^:parallel request-body-default-cap-fit-boundary-test
+ (testing "below the boundary: estimate 167,999"
+ (is (= 32000 (:max_tokens (body-with-json-length {} 671996)))))
+ (testing "at the boundary: estimate 168,000, so estimate plus cap equals the window"
+ (is (= 32000 (:max_tokens (body-with-json-length {} 672000)))))
+ (testing "above the boundary: 672,001 characters round up to an estimate of 168,001"
+ (is (not (contains? (body-with-json-length {} 672001) :max_tokens))))
+ (testing "tools count: the at-boundary message plus one tool does not fit"
+ (let [content (padded-content {:model haiku} 672000)
+ body (openrouter/openrouter-request-body {:model haiku
+ :input [{:role :user :content content}]
+ :tools [stub-tool]})]
+ (is (< 672000 (prompt-json-length body)))
+ (is (not (contains? body :max_tokens))))))
+
;;; ──────────────────────────────────────────────────────────────────
;;; Streaming chunk conversion tests
;;; ──────────────────────────────────────────────────────────────────
diff --git a/test/metabase/metabot/self/zai_test.clj b/test/metabase/metabot/self/zai_test.clj
index 832e9d82abc..297178ad036 100644
--- a/test/metabase/metabot/self/zai_test.clj
+++ b/test/metabase/metabot/self/zai_test.clj
@@ -230,6 +230,27 @@
{:choices [{:delta {} :finish_reason "stop"}]
:usage {:prompt_tokens 8 :completion_tokens 1 :total_tokens 9}}])))))
+(deftest ^:parallel zai-context-window-exceeded-is-a-length-stop-test
+ (letfn [(usage-chunk [finish-reason]
+ (->> (into [] (zai/zai->aisdk-chunks-xf)
+ [{:id "20260723-3"
+ :model "glm-5.2"
+ :choices [{:delta {:role "assistant" :content "Partial"}}]}
+ {:choices [{:delta {} :finish_reason finish-reason}]
+ :usage {:prompt_tokens 199000 :completion_tokens 1000 :total_tokens 200000}}])
+ (filter #(= :usage (:type %)))
+ first))]
+ (testing "a stop at the context window reads as a length stop, so the \"full\" path can run"
+ (is (=? {:finish-reason "length" :raw-finish-reason "model_context_window_exceeded"}
+ (usage-chunk "model_context_window_exceeded"))))
+ (testing "the other Z.AI finish reasons keep their mapping"
+ (are [raw finish-reason] (=? {:finish-reason finish-reason :raw-finish-reason raw}
+ (usage-chunk raw))
+ "length" "length"
+ "stop" "stop"
+ "sensitive" "content-filter"
+ "network_error" "error"))))
+
(deftest ^:parallel zai-whole-tool-call-conv-test
(testing "a tool call arriving whole in one delta (tool_stream false) is mapped correctly"
(is (=? [{:type :start}
diff --git a/test/metabase/metabot/self_test.clj b/test/metabase/metabot/self_test.clj
index be0a9bfdc6c..b078b22b38d 100644
--- a/test/metabase/metabot/self_test.clj
+++ b/test/metabase/metabot/self_test.clj
@@ -127,7 +127,7 @@
(is (ifn? (registry/required provider :list-models)) provider))))
(testing "a capability a provider does not have is absent, not a default"
(is (nil? (registry/optional "vllm" :supported-models)))
- (is (nil? (registry/optional "deepseek" :context-window)))
+ (is (nil? (registry/optional "vllm" :context-window)))
(is (some? (registry/optional "anthropic" :supported-models))))
(testing "the registry covers exactly the provider types the platform knows about"
(is (= (set (map :type (llm.provider/provider-types)))
@@ -1368,6 +1368,8 @@
"google/google/gemini-3.6-flash" 1048576 ; publisher-qualified model reaches Google adapter
"zai/glm-5.3" 1048576 ; Z.AI direct
"openrouter/z-ai/glm-5.3" 1048576 ; OpenRouter serving limit
+ "deepseek/deepseek-v4-pro" 1048576 ; DeepSeek direct, probed overflow message
+ "deepseek/deepseek-flash" 1048576 ; DeepSeek direct, probed overflow message
"azure/openai/my-deployment" nil ; unmatched deployment
"anthropic/some-future-model" nil ; unknown model
"unknown" nil))) ; no such connection
@@ -2800,6 +2802,89 @@
(is (=? {:error-code "ai_provider_unavailable" :message #"The AI provider is having problems.*"}
(mt/as-admin (self/provider-error (provider-api-error! "anthropic" 529 {})))))))))
+(defn- openrouter-relayed-error-body
+ "OpenRouter's 400 body when every upstream refused the request with the JSON string `raw`.
+
+ Shape probed 2026-10-13 (https://github.com/metabase/metabase/pull/83989): OpenRouter's own message is generic, and
+ the upstream's body is only in `metadata.raw`."
+ [raw]
+ {:error {:message "Provider returned error"
+ :code 400
+ :metadata {:raw raw
+ :provider_name "Azure"
+ :is_byok false
+ :previous_errors [{:code 400
+ :message "Provider returned error"
+ :provider_name "Amazon Bedrock"
+ :raw raw}]}}})
+
+(deftest context-overflow-error-test
+ (testing "a 400 for a prompt that does not fit the window is a \"full\" error"
+ ;; Bodies probed 2026-10-09 (https://github.com/metabase/metabase/pull/83989), unless a row names a doc.
+ (are [provider body]
+ (= "ai_provider_context_full"
+ (:error-code (self/context-overflow-error (provider-api-error! provider 400 body))))
+ "openrouter" {:error {:message (str "This endpoint's maximum context length is 200000 tokens. However, you "
+ "requested about 200001 tokens (1 of text input, 200000 in the output).")
+ :code 400
+ :metadata {:provider_name nil}}}
+ ;; https://openrouter.ai/docs/api-reference/errors
+ "openrouter" {:error {:message "Provider returned error"
+ :code 400
+ :metadata {:error_type "context_length_exceeded"}}}
+ "deepseek" {:error {:message (str "This model's maximum context length is 1048576 tokens. However, you "
+ "requested 1048600 tokens (1016600 in the messages, 32000 in the completion).")
+ :type "invalid_request_error"
+ :param nil
+ :code "invalid_request_error"}}
+ "mistral" {:object "error"
+ :message "Prompt 1000015 > 262144 maximum context length"
+ :type "invalid_request_prompt_too_long"
+ :param nil
+ :code "3059"
+ :raw_status_code 400}
+ "moonshot" {:error {:message "Invalid request: Your request exceeded model token limit: 262144 (requested: 1000008)"
+ :type "invalid_request_error"}}
+ ;; https://platform.kimi.ai/docs/api/errors
+ "moonshot" {:error {:message "Input token length too long" :type "invalid_request_error"}}
+ "moonshot" {:error {:message "prompt tokens + max_tokens exceeds the model specification"
+ :type "invalid_request_error"}}
+ ;; https://platform.claude.com/docs/en/build-with-claude/context-windows
+ "anthropic" {:type "error"
+ :error {:type "invalid_request_error" :message "prompt is too long: 208310 tokens > 200000 maximum"}}
+ ;; https://docs.z.ai/api-reference/api-code
+ "zai" {:error {:code "1261" :message "Prompt too long"}}
+ ;; probed 2026-10-13 on Vertex, gemini-3.5-flash
+ "google" {:error {:code 400
+ :message "The input token count exceeds the maximum number of tokens allowed 1048576."
+ :status "INVALID_ARGUMENT"}}
+ "openrouter" (openrouter-relayed-error-body
+ "{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\",\"message\":\"prompt is too long: 250027 tokens > 200000 maximum\"}}"))))
+
+(deftest context-overflow-error-other-failure-test
+ (testing "any other failure is not a \"full\" error"
+ (are [status body]
+ (nil? (self/context-overflow-error (provider-api-error! "openrouter" status body)))
+ 400 {:error {:code 400 :message "Bad request"}}
+ 400 {:error {:code 400 :message "string too long" :metadata {:error_type "string_too_long"}}}
+ 400 (openrouter-relayed-error-body
+ "{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\",\"message\":\"tools.0: Input should be a valid dictionary\"}}")
+ 400 anthropic-credit-balance-body
+ ;; Gemini's INVALID_ARGUMENT for a bad `maxOutputTokens`, probed 2026-10-13 on Vertex, gemini-3.5-flash
+ 400 {:error {:code 400
+ :message (str "Unable to submit request because it has a maxOutputTokens value of 70000 but the "
+ "supported range is from 1 (inclusive) to 65537 (exclusive). Update the value and "
+ "try again.")
+ :status "INVALID_ARGUMENT"}}
+ 429 {:error {:code 429 :message "This endpoint's maximum context length is 200000 tokens."}}
+ 500 {:error {:code 500 :message "This endpoint's maximum context length is 200000 tokens."}})))
+
+(deftest context-overflow-error-not-api-error-test
+ (testing "an exception that is not a provider API error"
+ (is (nil? (self/context-overflow-error
+ (ex-info "boom" {:status 400
+ :body {:error {:message "This endpoint's maximum context length is 200000 tokens."}}}))))))
+
(deftest known-models-normalization-test
(testing "adapters that key model id to a map are passed through"
(let [models (self/known-models "anthropic")]
diff --git a/test/metabase/slackbot/streaming_test.clj b/test/metabase/slackbot/streaming_test.clj
index 617dd67c192..d70158c8ae7 100644
--- a/test/metabase/slackbot/streaming_test.clj
+++ b/test/metabase/slackbot/streaming_test.clj
@@ -397,6 +397,13 @@
(let [text (dm-error-part-appended-text!
{:type :error :error {:message "Ask your administrator to check the AI provider." :error-code code}})]
(is (str/includes? text "Ask your administrator to check the AI provider.") code))))
+ (testing "a full conversation gets Slack copy that asks for a new thread, not the web copy"
+ (let [text (dm-error-part-appended-text!
+ {:type :error :error {:message "This conversation has reached its maximum length and can't continue. Please start a new chat."
+ :error-code "ai_provider_context_full"}})]
+ (is (str/includes? text "This conversation has reached its maximum length and can't continue. Please start a new thread."))
+ (is (not (str/includes? text "new chat")))
+ (is (not (str/includes? text "Something went wrong")))))
(testing "an unrecognized error keeps the generic copy and leaks nothing from the provider"
(let [text (dm-error-part-appended-text!
{:type :error :error {:message "upstream rejected key sk-ant-oops"}})]