@oh-my-pi/pi-ai 16.1.22 → 16.2.0

package/dist/types/utils/thinking-loop.d.ts

@@ -4,6 +4,15 @@ import { AssistantMessageEventStream } from "./event-stream";
  *  message also carries "stream stall" so the session + transport retry
  *  classifiers treat it as a transient (retryable) stop without bespoke rules. */
 export declare const THINKING_LOOP_ERROR_MARKER = "Thinking loop detected";
+/**
+ * True when `model` is a Gemini model whose native thinking stream surfaces the
+ * "thought summary" titles this module's header guard counts.
+ *
+ * OpenAI-compat transports can serve Gemini under an arbitrary provider/id, so they
+ * carry the explicit `compat.enableGeminiThinkingLoopGuard` flag; direct Gemini
+ * transports carry a clearly shaped id/provider, so a string match is sufficient.
+ */
+export declare function isGeminiThinkingModel(model: Model<Api>): boolean;
 /**
  * True when `model` should be guarded for thinking/response loops (Gemini & DeepSeek).
  *
@@ -27,6 +36,43 @@ export declare class ThinkingLoopDetector {
      *  which may be the one that completes a duplicate cluster — is not dropped. */
     flush(): string | null;
 }
+/**
+ * Consecutive Gemini thought-summary headers in one uninterrupted reasoning
+ * stream that trips the tool-call reminder. Gemini occasionally narrates a long
+ * chain of titled summaries ("Examining Result Handling", "Refining Result
+ * Rendering", …) without ever calling a tool, burning the whole budget on
+ * planning; at this many distinct titles it has almost certainly stalled. This
+ * is the over-planning shape {@link ThinkingLoopDetector} misses — those titles
+ * are stripped before its similarity analysis precisely because their wording
+ * keeps changing, so a genuinely-distinct planning runaway never trips it.
+ */
+export declare const GEMINI_HEADER_RUNAWAY_THRESHOLD = 10;
+/**
+ * True when a single trimmed line is a Gemini reasoning-summary title: a markdown
+ * ATX heading (`## …`) or a whole-line bold / bold-italic run (`**Title**`,
+ * `***Title***`). Inline emphasis inside prose never matches — the bold run must
+ * span the entire line. Mirrors the title shapes {@link ThinkingLoopDetector}
+ * strips before similarity analysis.
+ */
+export declare function isReasoningSummaryHeader(line: string): boolean;
+/**
+ * Counts consecutive Gemini reasoning-summary headers across a streamed thinking
+ * block. {@link push} returns true exactly once — when the running header count
+ * first reaches {@link GEMINI_HEADER_RUNAWAY_THRESHOLD} — and the caller then
+ * interrupts the stream and reminds the model to issue a tool call. Paragraph
+ * lines between titles do NOT reset the run (Gemini emits header + paragraph per
+ * thought, so the run IS the number of summaries); leaving the reasoning channel
+ * does, via {@link reset} on a new thinking block / prose / tool call.
+ */
+export declare class GeminiHeaderRunDetector {
+    #private;
+    /** Feed a thinking delta. Returns true the first time the run hits the threshold. */
+    push(delta: string): boolean;
+    /** Number of summary titles counted in the current run (for the reminder/log). */
+    get count(): number;
+    /** Re-arm for a fresh reasoning block: clears the buffer, count, and latch. */
+    reset(): void;
+}
 /**
  * Wrap a provider stream with the loop guard. `controller` is the guard's own
  * abort handle: aborting it (after wiring it into the provider's signal via

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.1.22",
+	"version": "16.2.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.1.22",
-		"@oh-my-pi/pi-utils": "16.1.22",
-		"@oh-my-pi/pi-wire": "16.1.22",
+		"@oh-my-pi/pi-catalog": "16.2.0",
+		"@oh-my-pi/pi-utils": "16.2.0",
+		"@oh-my-pi/pi-wire": "16.2.0",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

package/src/api-registry.ts

@@ -27,6 +27,7 @@ const BUILTIN_API_IDS = [
 	"google-vertex",
 	"ollama-chat",
 	"cursor-agent",
+	"gitlab-duo-agent",
 	"devin-agent",
 ] as const satisfies readonly KnownApi[];
 

package/src/auth-broker/wire-schemas.ts

@@ -183,8 +183,15 @@ const usageLimitSchema = type({
 	"notes?": "string[]",
 });
 
+const usageResetCreditDetailSchema = type({
+	"grantedAt?": "string",
+	"expiresAt?": "string",
+	"status?": "string",
+});
+
 const usageResetCreditsSchema = type({
 	availableCount: "number",
+	"credits?": usageResetCreditDetailSchema.array(),
 });
 
 const arkUsageReportSchema = type({

package/src/auth-storage.ts

@@ -13,7 +13,7 @@ import * as path from "node:path";
 import { extractHttpStatusFromError, getAgentDbPath, logger } from "@oh-my-pi/pi-utils";
 import type { ApiKeyResolver } from "./auth-retry";
 import { isUsageLimitOutcome } from "./rate-limit-utils";
-import { getProviderDefinition } from "./registry";
+import { getProviderDefinition, PASTE_CODE_LOGIN_PROVIDERS } from "./registry";
 import { getOAuthApiKey, getOAuthProvider, refreshOAuthToken } from "./registry/oauth";
 import type { OAuthController, OAuthCredentials, OAuthProvider, OAuthProviderId } from "./registry/oauth/types";
 import { getEnvApiKey, getEnvApiKeyName } from "./stream";
@@ -39,6 +39,7 @@ import { googleGeminiCliUsageProvider } from "./usage/gemini";
 import { githubCopilotUsageProvider } from "./usage/github-copilot";
 import { antigravityRankingStrategy, antigravityUsageProvider } from "./usage/google-antigravity";
 import { kimiUsageProvider } from "./usage/kimi";
+import { ollamaCloudUsageProvider, ollamaUsageProvider } from "./usage/ollama";
 import { codexRankingStrategy, openaiCodexUsageProvider } from "./usage/openai-codex";
 import {
 	type CodexResetConsumeCode,
@@ -496,6 +497,8 @@ const DEFAULT_USAGE_PROVIDERS: UsageProvider[] = [
 	kimiUsageProvider,
 	antigravityUsageProvider,
 	googleGeminiCliUsageProvider,
+	ollamaUsageProvider,
+	ollamaCloudUsageProvider,
 	claudeUsageProvider,
 	zaiUsageProvider,
 	opencodeGoUsageProvider,
@@ -1884,7 +1887,17 @@ export class AuthStorage {
 			onPrompt: (prompt: { message: string; placeholder?: string }) => Promise<string>;
 		},
 	): Promise<void> {
-		const manualCodeInput = () => ctrl.onPrompt({ message: "Paste the authorization code (or full redirect URL):" });
+		// Only paste-code providers (fixed non-loopback redirect, e.g. GitLab Duo
+		// Agent's vscode:// URI) get a default manual-code prompt. For loopback OAuth
+		// providers the `OAuthCallbackFlow` would otherwise race this readline prompt
+		// against the HTTP callback and, when the callback wins, leave the prompt
+		// outstanding — a dirty/blocked terminal. Synthesizing the default only for
+		// paste-code providers is the authoritative gate (it covers every caller, not
+		// just the CLI); an explicit caller-supplied `onManualCodeInput` is still
+		// honored for any provider as an escape hatch.
+		const manualCodeInput = PASTE_CODE_LOGIN_PROVIDERS.has(provider)
+			? () => ctrl.onPrompt({ message: "Paste the authorization code (or full redirect URL):" })
+			: undefined;
 		// Built-in registry first, then runtime-registered extension providers.
 		const def = getProviderDefinition(provider) ?? getOAuthProvider(provider);
 		if (!def?.login) {

package/src/dialect/anthropic.md

@@ -22,10 +22,10 @@ Results arrive later in a `<function_results>` block, one `<result>` per call (f
 ## Rules
 
 - `name` MUST match a listed function.
-- String/scalar parameters: exact text, spaces preserved. Lists/objects: JSON.
+- String/scalar parameters: exact text, spaces preserved — bodies are read by regex (delimiter matching), NOT a real XML parser, so never HTML-escape them (emit `a & b`, not `a &amp; b`; `<`/`>` stay literal); only the body's own `</parameter>` closing tag is reserved. Lists/objects: JSON.
 - Multiple calls: multiple `<invoke>` blocks in one `<function_calls>`.
 - You MAY write visible text before the calls.
 - NEVER emit `tool_calls` JSON.
 - NEVER use the legacy `<tool_name>`/`<parameters>` call syntax.
 - Read each `<result>`/`<error>` in call order. NEVER emit `<function_results>` yourself.
-- After emitting your tool calls, YOU MUST EMIT THE STOP SEQUENCE AND HALT.
+- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `<invoke>` emitted). Write the complete call, THEN the stop sequence, THEN halt.

package/src/dialect/anthropic.ts

@@ -1,5 +1,5 @@
+import { parseJsonWithRepair } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
-import { parseJsonWithRepair } from "../utils/json-parse";
 import dialectPrompt from "./anthropic.md" with { type: "text" };
 import { buildArgShapes, buildStringArgsResolver, mintToolCallId, type ToolArgShape } from "./coercion";
 import {

package/src/dialect/deepseek.md

@@ -16,8 +16,9 @@ Results arrive as output tokens:
 
 - Use `｜` (U+FF5C) and `▁` (U+2581) exactly.
 - Tool name MUST match an available function; arguments are one valid JSON object.
+- Argument string values use only normal JSON string escaping (`\"`, `\\`, `\n`); never HTML-escape their contents — write `a & b`, not `a & b`.
 - NEVER wrap arguments in Markdown fences; NEVER emit a `type` field or `function` prefix.
 - Multiple calls chain `<｜tool▁call▁begin｜>...<｜tool▁call▁end｜>` directly — no separators, spaces, or newlines between them.
 - Private reasoning, when needed, goes in `<think>...</think>` before the tokens.
 - Read each output token in call order. NEVER emit output tokens yourself.
-- After emitting your tool calls, YOU MUST EMIT THE STOP SEQUENCE AND HALT.
+- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `<｜tool▁call▁begin｜>` emitted). Write the complete call, THEN the stop sequence, THEN halt.

package/src/dialect/deepseek.ts

@@ -1,5 +1,5 @@
+import { parseJsonWithRepair } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
-import { parseJsonWithRepair } from "../utils/json-parse";
 import { asRecord, mintToolCallId, partialSuffixOverlapAny } from "./coercion";
 import dialectPrompt from "./deepseek.md" with { type: "text" };
 import { assistantTranscriptParts, collectToolResultRun, messageContentText, stringifyJson } from "./rendering";

package/src/dialect/gemini.md

@@ -37,7 +37,8 @@ brief reasoning
 ## Rules
 
 - The function name MUST match a listed function; arguments are keyword form (`name=value`).
+- Argument string values use only normal Python string escaping; never HTML-escape their contents — write `"a & b"`, not `"a & b"`.
 - Multiple calls = a single `[...]` list (or one `default_api...` call per line) inside one ` ```tool_code ` block.
 - Put private reasoning in a ` ```thinking ` block before the ` ```tool_code ` block, never inside ` ```tool_code `.
 - Read each ` ```tool_outputs ` block in call order. NEVER write a ` ```tool_outputs ` block yourself.
-- After emitting the ` ```tool_code ` block, YOU MUST STOP AND HALT.
+- Emit the ` ```tool_code ` block in full, THEN stop and halt — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no ` ```tool_code ` block emitted).

package/src/dialect/gemma.md

@@ -25,8 +25,9 @@ brief reasoning
 ## Rules
 
 - `NAME` MUST match a listed function; arguments are `key:value` pairs separated by commas.
+- String values between `<|"|>` tokens are raw literal text (no escaping); never HTML-escape them — write `a & b`, not `a &amp; b`.
 - Multiple calls = consecutive `<|tool_call>...<tool_call|>` blocks; keep prose outside them.
 - The closer is `<tool_call|>` (pipe on the right), not `</tool_call>` or `<|tool_call>`.
 - Private reasoning goes in a `<|channel>thought…<channel|>` block before any call; NEVER put tool calls inside it.
 - Read each `<|tool_response>` block in call order. NEVER write a `<|tool_response>` block yourself.
-- After emitting your tool calls, YOU MUST STOP AND HALT.
+- Write each call in full, THEN stop and halt — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `<|tool_call>` block emitted).

package/src/dialect/glm.md

@@ -25,8 +25,8 @@ verbatim tool result
 
 - The name after `<tool_call>` must match a listed function and sit on the same line.
 - Emit one `<arg_key>name</arg_key>` + `<arg_value>value</arg_value>` pair per argument; omit unset optional args.
-- String values are raw text (no quotes, no escaping); non-string values are valid JSON.
+- `<arg_value>` bodies are read by regex (delimiter matching), NOT a real XML parser: write string values as raw literal text and never HTML-escape them (emit `a & b`, not `a &amp; b`; `<`/`>` stay literal); only the body's own `</arg_value>` closing tag is reserved. Non-string values are valid JSON.
 - Multiple calls are consecutive `<tool_call>…</tool_call>` blocks.
 - Private reasoning goes in `<think>…</think>`; NEVER put tool calls inside `<think>`.
 - Read each `<tool_response>` in call order. NEVER emit `<tool_response>` yourself.
-- After emitting your tool calls, YOU MUST EMIT THE STOP SEQUENCE AND HALT.
+- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `<tool_call>` emitted). Write the complete call, THEN the stop sequence, THEN halt.

package/src/dialect/harmony.md

@@ -22,9 +22,10 @@ Tool results arrive as messages authored by the function, addressed back to the
 
 - Recipient is `functions.` + a listed function name.
 - Body is one JSON object matching the schema; omit optional arguments you are not setting.
+- Argument string values use only normal JSON string escaping (`\"`, `\\`, `\n`); never HTML-escape their contents — write `a & b`, not `a & b`.
 - Multiple calls = consecutive call messages.
 - An optional visible preamble is a `commentary` message ending `<|end|>`.
 - NEVER put tool calls in `analysis`.
 - NEVER wrap calls in Markdown/code fences.
 - Read each tool-result message in call order. NEVER emit tool-result messages yourself.
-- After emitting your tool calls, YOU MUST EMIT THE STOP SEQUENCE AND HALT.
+- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `<|call|>` message emitted). Write the complete call, THEN the stop sequence, THEN halt.

package/src/dialect/harmony.ts

@@ -1,5 +1,5 @@
+import { parseJsonWithRepair } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
-import { parseJsonWithRepair } from "../utils/json-parse";
 import { asRecord, mintToolCallId, partialSuffixOverlapAny } from "./coercion";
 import dialectPrompt from "./harmony.md" with { type: "text" };
 import {

package/src/dialect/hermes.md

@@ -19,6 +19,7 @@ verbatim tool result
 ## Rules
 
 - `name` MUST match a listed function; `arguments` is a JSON object, never a stringified JSON.
+- Argument string values use only normal JSON string escaping (`\"`, `\\`, `\n`); never HTML-escape their contents — write `a & b`, not `a & b`.
 - Emit multiple calls as consecutive `<tool_call>` blocks; keep any prose outside them.
 - Read each `<tool_response>` in call order. NEVER emit `<tool_response>` yourself.
-- After emitting your tool calls, YOU MUST EMIT THE STOP SEQUENCE AND HALT.
+- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `<tool_call>` emitted). Write the complete call, THEN the stop sequence, THEN halt.

package/src/dialect/hermes.ts

@@ -1,5 +1,5 @@
+import { parseJsonWithRepair, parseStreamingJson } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
-import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse";
 import { asRecord, mintToolCallId, partialSuffixOverlapAny } from "./coercion";
 import dialectPrompt from "./hermes.md" with { type: "text" };
 import { renderChatMlTranscript, renderDelimitedThinking, renderToolResponseResults, stringifyJson } from "./rendering";

package/src/dialect/kimi.md

@@ -17,7 +17,8 @@ verbatim tool result<|im_end|>
 
 - `NAME` MUST match a listed function exactly.
 - Arguments MUST be one JSON object with double-quoted keys.
+- Argument string values use only normal JSON string escaping (`\"`, `\\`, `\n`); never HTML-escape their contents — write `a & b`, not `a &amp; b`.
 - Multiple calls = consecutive `<|tool_call_begin|>…<|tool_call_end|>` blocks in the same section; `INDEX` increments from `0`.
 - Private reasoning, when supported, goes in `<think>…</think>` before the tool-call section; NEVER put tool calls inside `<think>`.
 - Read each result turn in call order. NEVER emit result turns yourself.
-- After emitting your tool calls, YOU MUST EMIT THE STOP SEQUENCE AND HALT.
+- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `<|tool_call_begin|>` emitted). Write the complete call, THEN the stop sequence, THEN halt.

package/src/dialect/kimi.ts

@@ -1,5 +1,5 @@
+import { parseJsonWithRepair } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
-import { parseJsonWithRepair } from "../utils/json-parse";
 import { asRecord, normalizeKimiFunctionName, partialSuffixOverlapAny } from "./coercion";
 import dialectPrompt from "./kimi.md" with { type: "text" };
 import { assistantTranscriptParts, collectToolResultRun, messageContentText, stringifyJson } from "./rendering";

package/src/dialect/minimax.md

@@ -22,10 +22,10 @@ Results arrive later in a `<function_results>` block, one `<result>` per call (f
 ## Rules
 
 - `name` MUST match a listed function.
-- String/scalar parameters: exact text, spaces preserved. Lists/objects: JSON.
+- String/scalar parameters: exact text, spaces preserved — bodies are read by regex (delimiter matching), NOT a real XML parser, so never HTML-escape them (emit `a & b`, not `a &amp; b`; `<`/`>` stay literal); only the body's own `</parameter>` closing tag is reserved. Lists/objects: JSON.
 - Multiple calls: multiple `<invoke>` blocks in one `<minimax:tool_call>`.
 - You MAY write visible text before the calls.
 - NEVER emit `tool_calls` JSON.
 - NEVER use `<function_calls>` or the legacy `<tool_name>`/`<parameters>` call syntax.
 - Read each `<result>`/`<error>` in call order. NEVER emit `<function_results>` yourself.
-- After emitting your tool calls, YOU MUST EMIT THE STOP SEQUENCE AND HALT.
+- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `<invoke>` emitted). Write the complete call, THEN the stop sequence, THEN halt.

package/src/dialect/pi.md

@@ -52,4 +52,4 @@ verbatim tool result
 - Emit parallel calls as consecutive `§…` blocks. NEVER invent call ids; results are positional.
 - Private reasoning goes in a `¤…¤` block before your calls; NEVER put calls inside it, and keep a literal `¤` out of the reasoning text.
 - Read each `‡‡…‡‡` result in call order. NEVER emit a `‡‡` block yourself.
-- After emitting your tool calls, YOU MUST EMIT THE STOP SEQUENCE AND HALT.
+- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `§` call emitted). Write the complete call, THEN the stop sequence, THEN halt.

package/src/dialect/qwen3.md

@@ -21,7 +21,8 @@ verbatim tool result
 ## Rules
 
 - `name` MUST match a listed function; `arguments` is a JSON object, never a JSON string.
+- Argument string values use only normal JSON string escaping (`\"`, `\\`, `\n`); never HTML-escape their contents — write `a & b`, not `a & b`.
 - Multiple calls = consecutive `<tool_call>...</tool_call>` blocks; keep prose outside them.
 - NEVER put tool calls inside `<think>`.
 - Read each `<tool_response>` in call order. NEVER emit `<tool_response>` yourself.
-- After emitting your tool calls, YOU MUST EMIT THE STOP SEQUENCE AND HALT.
+- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `<tool_call>` emitted). Write the complete call, THEN the stop sequence, THEN halt.

package/src/dialect/qwen3.ts

@@ -1,5 +1,5 @@
+import { parseJsonWithRepair } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
-import { parseJsonWithRepair } from "../utils/json-parse";
 import { asRecord, mintToolCallId, partialSuffixOverlapAny } from "./coercion";
 import dialectPrompt from "./qwen3.md" with { type: "text" };
 import { renderChatMlTranscript, renderToolResponseResults, stringifyJson } from "./rendering";

package/src/dialect/xml.md

@@ -17,6 +17,6 @@ verbatim tool result
 ## Rules
 
 - `name` MUST match a listed function.
-- String values are literal text (no JSON quotes or escaping); non-string values are JSON. Add `string="false"` to a parameter only to force JSON parsing of a value the schema treats as a string.
+- Parameter values are read literally by regex (delimiter matching), NOT a real XML parser: write them verbatim and never HTML-escape (emit `a & b`, never `a &amp; b`; `<`/`>` stay literal too). Only the body's own `</parameter>` closing tag is reserved. Non-string values are JSON; add `string="false"` to a parameter only to force JSON parsing of a value the schema treats as a string.
 - Read each `<tool_response>` in call order. NEVER emit `<tool_response>` yourself.
-- After emitting your tool calls, YOU MUST EMIT THE STOP SEQUENCE AND HALT.
+- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `<invoke>` emitted). Write the complete call, THEN the stop sequence, THEN halt.

package/src/index.ts

@@ -13,6 +13,7 @@ export * from "./providers/anthropic-client";
 export * from "./providers/azure-openai-responses";
 export type * from "./providers/cursor";
 export * from "./providers/gitlab-duo";
+export * from "./providers/gitlab-duo-workflow";
 export type * from "./providers/google";
 export type * from "./providers/google-gemini-cli";
 export type * from "./providers/google-vertex";
@@ -34,6 +35,7 @@ export * from "./usage/github-copilot";
 export * from "./usage/google-antigravity";
 export * from "./usage/kimi";
 export * from "./usage/minimax-code";
+export * from "./usage/ollama";
 export * from "./usage/openai-codex";
 export * from "./usage/openai-codex-reset";
 export * from "./usage/opencode-go";

package/src/providers/amazon-bedrock.ts

@@ -10,7 +10,14 @@
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import { mapEffortToAnthropicAdaptiveEffort, requireSupportedEffort } from "@oh-my-pi/pi-catalog/model-thinking";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
-import { $env, $flag, extractHttpStatusFromError, fetchWithRetry } from "@oh-my-pi/pi-utils";
+import {
+	$env,
+	$flag,
+	extractHttpStatusFromError,
+	fetchWithRetry,
+	parseStreamingJson,
+	parseStreamingJsonThrottled,
+} from "@oh-my-pi/pi-utils";
 import { ProviderHttpError } from "../errors";
 import type {
 	Api,
@@ -32,7 +39,6 @@ import { normalizeToolCallId, resolveCacheRetention } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { appendRawHttpRequestDumpFor400, type RawHttpRequestDump } from "../utils/http-inspector";
 import { armPreResponseTimeout, getStreamFirstEventTimeoutMs } from "../utils/idle-iterator";
-import { parseStreamingJson, parseStreamingJsonThrottled } from "../utils/json-parse";
 import { toolWireSchema } from "../utils/schema/wire";
 import { invalidateAwsCredentialCache, resolveAwsCredentials } from "./aws-credentials";
 import { decodeEventStream } from "./aws-eventstream";

package/src/providers/anthropic-messages-server-schema.ts

@@ -135,12 +135,17 @@ export const userMessageSchema = type({
 	content: type("string").or(userContentBlockSchema.array()),
 });
 
+export const systemMessageSchema = type({
+	role: "'system'",
+	content: type("string").or(systemBlockSchema.array()),
+});
+
 export const assistantMessageSchema = type({
 	role: "'assistant'",
 	content: type("string").or(assistantContentBlockSchema.array()),
 });
 
-export const messageSchema = userMessageSchema.or(assistantMessageSchema);
+export const messageSchema = userMessageSchema.or(assistantMessageSchema).or(systemMessageSchema);
 
 // ─── Tools ─────────────────────────────────────────────────────────────────
 

package/src/providers/anthropic.ts

@@ -15,6 +15,8 @@ import {
 	isRetryableError,
 	isUnexpectedSocketCloseMessage,
 	logger,
+	parseJsonWithRepair,
+	parseStreamingJsonThrottled,
 	readSseEvents,
 } from "@oh-my-pi/pi-utils";
 import { isUsageLimitError } from "../rate-limit-utils";
@@ -51,7 +53,6 @@ import { AssistantMessageEventStream } from "../utils/event-stream";
 import { isFoundryEnabled } from "../utils/foundry";
 import { finalizeErrorMessage, type RawHttpRequestDump, rewriteCopilotError } from "../utils/http-inspector";
 import { getStreamFirstEventTimeoutMs, getStreamIdleTimeoutMs, iterateWithIdleTimeout } from "../utils/idle-iterator";
-import { parseJsonWithRepair, parseStreamingJsonThrottled } from "../utils/json-parse";
 import { notifyProviderResponse } from "../utils/provider-response";
 import { isCopilotTransientModelError } from "../utils/retry";
 import { COMBINATOR_KEYS, NO_STRICT, toolWireSchema } from "../utils/schema";

package/src/providers/cursor.ts

@@ -102,7 +102,13 @@ import {
 	WriteSuccessSchema,
 } from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
-import { $env, extractHttpStatusFromError, sanitizeText } from "@oh-my-pi/pi-utils";
+import {
+	$env,
+	extractHttpStatusFromError,
+	parseJsonWithRepair,
+	parseStreamingJson,
+	sanitizeText,
+} from "@oh-my-pi/pi-utils";
 import type {
 	Api,
 	AssistantMessage,
@@ -126,7 +132,6 @@ import type {
 import { normalizeSystemPrompts } from "../utils";
 import { deterministicUuid } from "../utils/deterministic-id";
 import { AssistantMessageEventStream } from "../utils/event-stream";
-import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse";
 import { connectProxiedSocket, getProxyForProvider, shouldBypassProxy } from "../utils/proxy";
 import { createRequestDebugSession, isRequestDebugEnabled, type RequestDebugResponseLog } from "../utils/request-debug";
 import { formatErrorMessageWithRetryAfter } from "../utils/retry-after";

package/src/providers/devin.ts

@@ -28,7 +28,7 @@ import {
 	StopReason,
 } from "@oh-my-pi/pi-catalog/discovery/devin-gen/exa/codeium_common_pb/codeium_common_pb";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
-import { extractHttpStatusFromError, logger } from "@oh-my-pi/pi-utils";
+import { extractHttpStatusFromError, logger, parseStreamingJson } from "@oh-my-pi/pi-utils";
 import type {
 	Api,
 	AssistantMessage,
@@ -44,7 +44,6 @@ import type {
 } from "../types";
 import { deterministicUuid } from "../utils/deterministic-id";
 import { AssistantMessageEventStream } from "../utils/event-stream";
-import { parseStreamingJson } from "../utils/json-parse";
 import { formatErrorMessageWithRetryAfter } from "../utils/retry-after";
 import { toolWireSchema } from "../utils/schema/wire";
 

package/src/providers/gitlab-duo-workflow-chatml-note.md

@@ -0,0 +1 @@
+The task below is a transcript of the conversation so far, written as a plain-text log. Turn boundaries (`<|im_start|>role` … `<|im_end|>`) and any `<ran NAME>{…}</ran>` / `<ran:result>` entries inside it are a RECORD of what already happened — past tool calls and their results. They are not a syntax for you to emit. To call a tool, use your normal structured tool-calling channel; never write `<ran …>`, `<tool_call>`, `<|im_start|>`, or similar markers as your own output.