@oh-my-pi/pi-ai 18.8.5 → 18.8.6

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [18.8.6] - 2026-10-08
+
+### Fixed
+
+- Fixed Google Gemini and Cloud Code Assist (Antigravity) requests failing when tool schemas contain unsupported JSON Schema keywords or fields that allow multiple types.
+- Fixed auth broker account selection and usage-limit enforcement to consistently use the selected account’s quota when multiple accounts are present.
+- Fixed Anthropic-family model streaming so encoded marker tokens are decoded correctly in text, tool-call updates, partial messages, and completed tool calls.
+
 ## [18.8.5] - 2026-10-08
 
 ### Added
@@ -2333,19 +2341,4 @@
 - Fixed OpenAI-compatible Ollama completions that return empty `finish_reason:length` after filling `num_ctx` so they surface an actionable context-window error instead of an empty length stop. ([#2774](https://github.com/can1357/oh-my-pi/issues/2774))
 - Fixed Codex browser login issuing credentials for the `opencode` OAuth originator while OMP requests identify as `pi`, which could make the first authenticated Codex request return 401 ([#2696](https://github.com/can1357/oh-my-pi/issues/2696)).
 
-## [16.0.1] - 2026-06-15
-
-### Added
-
-- Added Umans AI Coding Plan API-key login support and `UMANS_AI_CODING_PLAN_API_KEY` environment fallback ([#2636](https://github.com/can1357/oh-my-pi/pull/2636) by [@oldschoola](https://github.com/oldschoola)).
-
-### Fixed
-
-- Fixed OpenAI Responses, Azure OpenAI Responses, and Codex Responses providers ignoring async `onPayload` replacement bodies. Provider payload hooks can now transform the actual request body sent upstream, matching the Anthropic/Gemini replacement contract.
-- Fixed OpenAI-compatible chat-completions streams that send object-shaped tool arguments in fragments by deep-merging nested objects and task arrays instead of replacing earlier chunks. ([#2617](https://github.com/can1357/oh-my-pi/issues/2617))
-- Fixed OpenAI Responses strict-mode tool schema normalization for nullable enum MCP parameters so enum constraints are distributed to matching `anyOf` branches instead of being copied onto the `null` branch. ([#1835](https://github.com/can1357/oh-my-pi/issues/1835))
-- Fixed Cursor provider formatting tool errors with the same `[Tool Result]` prefix as successful results, causing Composer models to misinterpret error messages (e.g. "Pattern must not be empty") as directives over long conversations. Errors now use a `[Tool Error]` prefix so the model can distinguish failures from successes in the prompt history. ([#1853](https://github.com/can1357/oh-my-pi/pull/1853))
-- Fixed `validateToolArguments` silently accepting JSON-encoded array strings (e.g. `'["a","b"]'`) against `union(string, array<string>)` schemas — providers that double-serialize tool-call arguments (Z.AI / GLM) caused tools like `search` to receive the literal `["a","b"]` as a single path, producing zero matches (single element) or glob parse errors (multi-element). A new pre-validation pass parses JSON-array-shaped strings when the schema explicitly accepts both shapes. ([#1788](https://github.com/can1357/oh-my-pi/issues/1788))
-- Fixed Anthropic thinking summaries that arrive wrapped in literal `<thinking>` tags so advisor/raw transcript dumps do not render nested thinking tags ([#2695](https://github.com/can1357/oh-my-pi/issues/2695)).
-
-Older entries are archived in [packages/ai/CHANGELOG.md@d22e34333695](https://github.com/can1357/oh-my-pi/blob/d22e34333695d3dd9de7741ff45903681dba4606/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages/ai/CHANGELOG.md@0dd6aff5f282](https://github.com/can1357/oh-my-pi/blob/0dd6aff5f2821aec1e5b54c6a458e323667a949b/packages/ai/CHANGELOG.md).

package/dist/types/utils/glyph-codec.d.ts

@@ -4,7 +4,7 @@ import { AssistantMessageEventStream } from "./event-stream.js";
 export interface GlyphCodec {
     /** Context with model-bound glyphs encoded and one conditional convention notice. */
     context: Context;
-    /** Decodes glyph tokens in the stream's terminal assistant message. */
+    /** Decodes glyph tokens live: text and tool-call deltas, partial snapshots, completed tool calls, and the terminal message. */
     wrap(inner: AssistantMessageEventStream): AssistantMessageEventStream;
     /** Decodes Cursor Pi calls and encodes their provider-bound results. */
     wrapCursorExecHandlers(handlers: CursorExecHandlers): CursorExecHandlers;

package/dist/types/utils/schema/normalize.d.ts

@@ -10,7 +10,11 @@ export interface NormalizeSchemaOptions {
     unsupportedFields: (key: string) => boolean;
     normalizeFieldNames: boolean;
     collapseNullFields: boolean;
-    normalizeTypeArrayToNullable: boolean;
+    /**
+     * Target takes a scalar `type` only: `["T", "null"]` becomes `T` (+ `nullable`)
+     * and a multi-type array becomes one `anyOf` branch per type.
+     */
+    scalarizeTypeArrays: boolean;
     stripNullableKeyword: boolean;
     autoPropertyOrdering: boolean;
     ensureObjectProperties: boolean;
@@ -66,8 +70,9 @@ export declare function normalizeSchemaForMCP(value: unknown): unknown;
  *    rejected; collapse to `enum` with an inferred scalar `type`.
  *  - `oneOf` is not an MFJS combinator (only `anyOf` is); residual `oneOf` is
  *    folded into `anyOf`.
- *  - `type` must be a scalar string; `type: [...]` arrays are reduced to a
- *    single scalar (the `null` branch is dropped — `nullable` is unsupported).
+ *  - `type` must be a scalar string; `["T", "null"]` reduces to `T` (the
+ *    `null` member is dropped — `nullable` is unsupported) and a multi-type
+ *    array becomes one typed `anyOf` branch per type.
  *  - Enum-bearing nodes get an inferred `type` (the idiomatic MFJS form; a bare
  *    `enum` is valid too) so `anyOf` branches always carry a `type`.
  *  - Validation/decorative keywords (`minItems`, `maxItems`, `maxLength`,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.8.5",
+	"version": "18.8.6",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -155,11 +155,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.8.5",
-		"@oh-my-pi/pi-catalog": "18.8.5",
-		"@oh-my-pi/pi-natives": "18.8.5",
-		"@oh-my-pi/pi-utils": "18.8.5",
-		"@oh-my-pi/pi-wire": "18.8.5"
+		"@oh-my-pi/omptype": "18.8.6",
+		"@oh-my-pi/pi-catalog": "18.8.6",
+		"@oh-my-pi/pi-natives": "18.8.6",
+		"@oh-my-pi/pi-utils": "18.8.6",
+		"@oh-my-pi/pi-wire": "18.8.6"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/auth-broker/remote-store.ts

@@ -1582,9 +1582,10 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
  * pick the one whose identity (accountId / email / projectId) lines up with
  * the credential the caller is asking about.
  *
- * Falls back to the lone candidate when only one matches the provider; falls
- * through to `null` when nothing matches, which `AuthStorage` treats as "no
- * usage data" (ranking proceeds without a usage signal for this credential).
+ * Falls back to the provider's lone report when it shares no identity field
+ * with the credential; falls through to `null` when nothing matches, which
+ * `AuthStorage` treats as "no usage data" (ranking proceeds without a usage
+ * signal for this credential).
  */
 function matchUsageReport(reports: UsageReport[], provider: Provider, credential: OAuthCredential): UsageReport | null {
 	const all = reports.filter(report => report.provider === provider);
@@ -1635,7 +1636,17 @@ function matchUsageReport(reports: UsageReport[], provider: Provider, credential
 		report => !readMetadataString((report.metadata ?? {}) as Record<string, unknown>, "orgId"),
 	);
 	if (candidates.length === 0) return null;
-	if (all.length === 1 && candidates.length === 1) return candidates[0];
+	// The sole report stands in for a credential it shares no identity field
+	// with; otherwise identity decides, because a report naming another email,
+	// account or project is a sibling's pool whose fetch succeeded where this
+	// credential's failed.
+	if (
+		all.length === 1 &&
+		candidates.length === 1 &&
+		!reportHasComparableIdentity(candidates[0], accountId, email, projectId)
+	) {
+		return candidates[0];
+	}
 	for (const report of candidates) {
 		if (reportMatchesIdentity(report, accountId, email, projectId)) return report;
 	}
@@ -1699,7 +1710,13 @@ function findMatchingReportIndex(reports: UsageReport[], overlay: UsageReport):
 		candidate => !readMetadataString((candidate.report.metadata ?? {}) as Record<string, unknown>, "orgId"),
 	);
 	if (candidates.length === 0) return -1;
-	if (all.length === 1 && candidates.length === 1) return candidates[0]!.index;
+	if (
+		all.length === 1 &&
+		candidates.length === 1 &&
+		!reportHasComparableIdentity(candidates[0]!.report, accountId, email, projectId)
+	) {
+		return candidates[0]!.index;
+	}
 	for (const candidate of candidates) {
 		if (reportMatchesIdentity(candidate.report, accountId, email, projectId)) return candidate.index;
 	}
@@ -1721,19 +1738,39 @@ function reportMatchesIdentity(
 		const metaAccount = readMetadataString(metadata, "accountId") ?? readMetadataString(metadata, "account_id");
 		if (metaAccount && metaAccount.toLowerCase() === accountId) return true;
 		for (const limit of report.limits) {
-			if (limit.scope.accountId?.toLowerCase() === accountId) return true;
+			if (limit.scope.accountId?.trim().toLowerCase() === accountId) return true;
 		}
 	}
 	if (projectId) {
 		const metaProject = readMetadataString(metadata, "projectId") ?? readMetadataString(metadata, "project_id");
 		if (metaProject && metaProject.toLowerCase() === projectId) return true;
 		for (const limit of report.limits) {
-			if (limit.scope.projectId?.toLowerCase() === projectId) return true;
+			if (limit.scope.projectId?.trim().toLowerCase() === projectId) return true;
 		}
 	}
 	return false;
 }
 
+/** Whether the report names an email, account or project the caller can compare against. */
+function reportHasComparableIdentity(
+	report: UsageReport,
+	accountId: string | undefined,
+	email: string | undefined,
+	projectId: string | undefined,
+): boolean {
+	const metadata = report.metadata ?? {};
+	if (email && readMetadataString(metadata, "email")) return true;
+	if (accountId) {
+		if (readMetadataString(metadata, "accountId") ?? readMetadataString(metadata, "account_id")) return true;
+		if (report.limits.some(limit => limit.scope.accountId?.trim())) return true;
+	}
+	if (projectId) {
+		if (readMetadataString(metadata, "projectId") ?? readMetadataString(metadata, "project_id")) return true;
+		if (report.limits.some(limit => limit.scope.projectId?.trim())) return true;
+	}
+	return false;
+}
+
 function readMetadataString(metadata: Record<string, unknown>, key: string): string | undefined {
 	const value = metadata[key];
 	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;

package/src/utils/glyph-codec.ts

@@ -1,4 +1,13 @@
-import type { AssistantMessage, Context, CursorExecHandlers, ImageContent, Message, TextContent } from "../types";
+import type {
+	AssistantMessage,
+	AssistantMessageEvent,
+	Context,
+	CursorExecHandlers,
+	ImageContent,
+	Message,
+	TextContent,
+	ToolCall,
+} from "../types";
 import { getStreamingPartialJson, setStreamingPartialJson } from "./block-symbols";
 import { AssistantMessageEventStream } from "./event-stream";
 import glyphNotice from "./glyph-notice.md" with { type: "text" };
@@ -10,6 +19,9 @@ const GLYPH_ENCODE_PATTERN =
 	/([\uE000-\uF8FF\u{F0000}-\u{FFFFD}\u{100000}-\u{10FFFD}])|⟦(?=(?:U[0-9a-fA-F]{4,6}|E)⟧)/gu;
 const GLYPH_DECODE_PATTERN = /⟦E⟧|⟦U([0-9a-fA-F]{4,6})⟧/gu;
 
+/** A trailing token or escape prefix that a later delta may still complete; sticky, tested at the last opener. */
+const GLYPH_PENDING_TAIL = /⟦(?:U[0-9a-fA-F]{0,6}|E)?$/uy;
+
 const kGlyphEncoded = Symbol("provider.context.glyphEncoded");
 
 interface GlyphEncodedContext extends Context {
@@ -20,7 +32,7 @@ interface GlyphEncodedContext extends Context {
 export interface GlyphCodec {
 	/** Context with model-bound glyphs encoded and one conditional convention notice. */
 	context: Context;
-	/** Decodes glyph tokens in the stream's terminal assistant message. */
+	/** Decodes glyph tokens live: text and tool-call deltas, partial snapshots, completed tool calls, and the terminal message. */
 	wrap(inner: AssistantMessageEventStream): AssistantMessageEventStream;
 	/** Decodes Cursor Pi calls and encodes their provider-bound results. */
 	wrapCursorExecHandlers(handlers: CursorExecHandlers): CursorExecHandlers;
@@ -287,15 +299,196 @@ function decodeAssistantMessageInPlace(message: AssistantMessage): void {
 	}
 }
 
+/** Decoded copy of a tool call, or the block itself when it carries no tokens. */
+function decodeToolCall(block: ToolCall): ToolCall {
+	const args = transformRecord(block.arguments, decodeGlyphText);
+	const partialJson = getStreamingPartialJson(block);
+	const json = partialJson === undefined ? undefined : decodeGlyphText(partialJson);
+	if (args === block.arguments && json === partialJson) return block;
+	const decoded: ToolCall = { ...block, arguments: args };
+	if (json !== undefined) setStreamingPartialJson(decoded, json);
+	return decoded;
+}
+
+/** Decodes one streamed block incrementally, holding back a token split across deltas. */
+class GlyphDeltaDecoder {
+	#pending = "";
+
+	/** Decodes everything in the held-back tail plus `delta` that no later delta can still change. */
+	push(delta: string): string {
+		const text = this.#pending + delta;
+		const open = text.lastIndexOf(GLYPH_OPEN);
+		let cut = text.length;
+		if (open >= 0) {
+			GLYPH_PENDING_TAIL.lastIndex = open;
+			if (GLYPH_PENDING_TAIL.test(text)) cut = open;
+		}
+		this.#pending = text.slice(cut);
+		return decodeGlyphText(cut === text.length ? text : text.slice(0, cut));
+	}
+
+	/** Releases the held-back tail verbatim: an unfinished token is literal text. */
+	flush(): string {
+		const tail = this.#pending;
+		this.#pending = "";
+		return tail;
+	}
+}
+
+/** Decode state for one streamed text or tool-call block. */
+interface GlyphChannel {
+	kind: "text" | "toolCall";
+	decoder: GlyphDeltaDecoder;
+	/** Decoded text forwarded so far; text blocks only. */
+	text: string;
+	/** Whether a delta carried a token opener; tool-call stand-ins are only rebuilt then. */
+	tokens: boolean;
+	/** Decoded stand-in for the provider's block in forwarded partials. */
+	view?: AssistantMessage["content"][number];
+}
+
+/**
+ * Re-projects a provider stream with glyph tokens decoded as they arrive, so
+ * delta consumers (side-channel replies, argument streams) and partial
+ * snapshots (live rendering, speculation) never see wire tokens.
+ *
+ * Provider-owned blocks are never mutated mid-stream — the provider keeps
+ * appending to them — so decoded stand-ins are swapped into each forwarded
+ * partial instead. The terminal message is decoded in place once. Thinking
+ * stays encoded, matching {@link decodeAssistantMessageInPlace}.
+ */
+class GlyphStreamProjector {
+	readonly #out: AssistantMessageEventStream;
+	readonly #channels = new Map<number, GlyphChannel>();
+	/** Set once any block has a stand-in; until then events pass through untouched. */
+	#projected = false;
+
+	constructor(out: AssistantMessageEventStream) {
+		this.#out = out;
+	}
+
+	push(event: AssistantMessageEvent): void {
+		switch (event.type) {
+			case "start":
+				this.#channels.clear();
+				this.#projected = false;
+				this.#out.push(event);
+				return;
+			case "text_delta": {
+				const channel = this.#channel(event.contentIndex, "text");
+				const delta = channel.decoder.push(event.delta);
+				channel.text += delta;
+				const block = event.partial.content[event.contentIndex];
+				if (block?.type === "text" && (channel.view !== undefined || delta !== event.delta)) {
+					this.#setView(channel, { ...block, text: channel.text });
+				}
+				if (!delta) return;
+				this.#out.push(
+					delta === event.delta && !this.#projected
+						? event
+						: { ...event, delta, partial: this.#partial(event.partial) },
+				);
+				return;
+			}
+			case "text_end": {
+				const channel = this.#channel(event.contentIndex, "text");
+				this.#flush(event.contentIndex, channel, event.partial);
+				const content = decodeGlyphText(event.content);
+				const block = event.partial.content[event.contentIndex];
+				if (block?.type === "text" && (channel.view !== undefined || content !== event.content)) {
+					this.#setView(channel, { ...block, text: content });
+				}
+				this.#out.push(
+					content === event.content && !this.#projected
+						? event
+						: { ...event, content, partial: this.#partial(event.partial) },
+				);
+				return;
+			}
+			case "toolcall_delta": {
+				const channel = this.#channel(event.contentIndex, "toolCall");
+				const delta = channel.decoder.push(event.delta);
+				channel.tokens ||= event.delta.includes(GLYPH_OPEN);
+				const block = event.partial.content[event.contentIndex];
+				if (channel.tokens && block?.type === "toolCall") {
+					const view = decodeToolCall(block);
+					if (view === block) channel.view = undefined;
+					else this.#setView(channel, view);
+				}
+				if (!delta) return;
+				this.#out.push(
+					delta === event.delta && !this.#projected
+						? event
+						: { ...event, delta, partial: this.#partial(event.partial) },
+				);
+				return;
+			}
+			case "toolcall_end": {
+				const channel = this.#channel(event.contentIndex, "toolCall");
+				this.#flush(event.contentIndex, channel, event.partial);
+				const toolCall = decodeToolCall(event.toolCall);
+				if (toolCall === event.toolCall) channel.view = undefined;
+				else this.#setView(channel, toolCall);
+				this.#out.push(
+					toolCall === event.toolCall && !this.#projected
+						? event
+						: { ...event, toolCall, partial: this.#partial(event.partial) },
+				);
+				return;
+			}
+			case "done":
+			case "error": {
+				const message = event.type === "done" ? event.message : event.error;
+				for (const [index, channel] of this.#channels) this.#flush(index, channel, message);
+				decodeAssistantMessageInPlace(message);
+				this.#out.push(event);
+				return;
+			}
+			default:
+				this.#out.push(this.#projected ? { ...event, partial: this.#partial(event.partial) } : event);
+		}
+	}
+
+	#channel(index: number, kind: GlyphChannel["kind"]): GlyphChannel {
+		let channel = this.#channels.get(index);
+		if (channel === undefined) {
+			channel = { kind, decoder: new GlyphDeltaDecoder(), text: "", tokens: false };
+			this.#channels.set(index, channel);
+		}
+		return channel;
+	}
+
+	#setView(channel: GlyphChannel, view: AssistantMessage["content"][number]): void {
+		channel.view = view;
+		this.#projected = true;
+	}
+
+	/** Forwards a block's held-back tail before the block ends or the stream settles. */
+	#flush(index: number, channel: GlyphChannel, partial: AssistantMessage): void {
+		const tail = channel.decoder.flush();
+		if (!tail) return;
+		if (channel.kind === "toolCall") {
+			this.#out.push({ type: "toolcall_delta", contentIndex: index, delta: tail, partial: this.#partial(partial) });
+			return;
+		}
+		channel.text += tail;
+		const block = partial.content[index];
+		if (block?.type === "text") this.#setView(channel, { ...block, text: channel.text });
+		this.#out.push({ type: "text_delta", contentIndex: index, delta: tail, partial: this.#partial(partial) });
+	}
+
+	#partial(partial: AssistantMessage): AssistantMessage {
+		if (!this.#projected) return partial;
+		return { ...partial, content: partial.content.map((block, index) => this.#channels.get(index)?.view ?? block) };
+	}
+}
+
 function wrapGlyphStream(inner: AssistantMessageEventStream): AssistantMessageEventStream {
 	const out = new AssistantMessageEventStream();
+	const projector = new GlyphStreamProjector(out);
 	void (async () => {
 		try {
-			for await (const event of inner) {
-				if (event.type === "done") decodeAssistantMessageInPlace(event.message);
-				else if (event.type === "error") decodeAssistantMessageInPlace(event.error);
-				out.push(event);
-			}
+			for await (const event of inner) projector.push(event);
 			if (!out.done) {
 				const result = await inner.result();
 				decodeAssistantMessageInPlace(result);

package/src/utils/schema/CONSTRAINTS.md

@@ -64,19 +64,21 @@ Schemas sent on the Google JSON Schema path MUST follow:
 
 1. **Unsupported JSON Schema keywords are stripped (except property names under `properties`)**
    - Unsupported keys (`UNSUPPORTED_SCHEMA_FIELDS`):
-      - `$schema`, `$ref`, `$defs`, `$dynamicRef`, `$dynamicAnchor`
+      - `$schema`, `$id`, `$anchor`, `$ref`, `$defs`, `$dynamicRef`, `$dynamicAnchor`
       - `examples`, `prefixItems`, `unevaluatedProperties`, `unevaluatedItems`
-      - `patternProperties`, `additionalProperties`
-      - `minItems`, `maxItems`, `minLength`, `maxLength`
-      - `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum`
-      - `pattern`, `format`
+      - `patternProperties`, `additionalProperties`, `propertyNames`
+      - `minItems`, `maxItems`, `uniqueItems`, `contains`, `minContains`, `maxContains`, `additionalItems`
+      - `minLength`, `maxLength`, `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf`
+      - `pattern`, `format`, `contentEncoding`, `contentMediaType`, `contentSchema`
       - `dependencies`, `dependentSchemas`, `dependentRequired`
-      - `deprecated`, `readOnly`, `writeOnly`, `$comment`
+      - `x-mcp-header`, `deprecated`, `readOnly`, `writeOnly`, `$comment`
    - Important: keys inside a `properties` object are treated as property names and MUST NOT be stripped by keyword match.
    - Human-meaningful stripped keys (`pattern`, `format`, min/max constraints, `default`, `examples`, etc.) are appended to the sibling `description` as an Anthropic-style spill block: `{pattern: "^foo$", minimum: 0}`. Structural/meta keys such as `$ref`, `$defs`, and `additionalProperties` are not spilled.
 
 2. **`type` arrays are normalized to scalar type + nullable marker**
    - `type: ["T", "null"]` becomes `type: "T"` and `nullable: true`.
+   - `type: ["A", "B", …]` becomes `anyOf: [{ type: "A", …A keywords }, { type: "B", …B keywords }]`; type-specific keywords (`items`, `properties`, `minimum`, …) move into the branches whose type they constrain, and a `null` member becomes `nullable: true`.
+   - A node left with a scalar `type` MUST NOT keep another type's keywords: Gemini rejects `items` beside `type: "string"` with HTTP 400.
    - Google expects scalar type, not `type[]`.
 
 3. **`const` is converted to `enum`**
@@ -115,7 +117,7 @@ For Cloud Code Assist Claude tool declarations, schema MUST satisfy stricter con
 
 1. Start with Google unsupported-key stripping behavior.
 2. **`nullable` keyword MUST be stripped** in CCA Claude path.
-3. `type: ["T", "null"]` becomes `type: "T"` with no `nullable` marker.
+3. `type: ["T", "null"]` becomes `type: "T"` with no `nullable` marker; a multi-type array becomes `anyOf` branches that the combiner rules below collapse.
 4. Human-meaningful stripped keys are appended to `description` with the same spill format used by the Google dispatcher.
 
 ### 3.3 Combiner/union normalization contract

package/src/utils/schema/fields.ts

@@ -15,6 +15,8 @@
  */
 export const UNSUPPORTED_SCHEMA_FIELDS: Record<string, true> = {
 	$schema: true,
+	$id: true,
+	$anchor: true,
 	$ref: true,
 	$defs: true,
 	$dynamicRef: true,
@@ -28,6 +30,11 @@ export const UNSUPPORTED_SCHEMA_FIELDS: Record<string, true> = {
 	propertyNames: true,
 	minItems: true,
 	maxItems: true,
+	uniqueItems: true,
+	contains: true,
+	minContains: true,
+	maxContains: true,
+	additionalItems: true,
 	minLength: true,
 	maxLength: true,
 	minimum: true,
@@ -37,6 +44,9 @@ export const UNSUPPORTED_SCHEMA_FIELDS: Record<string, true> = {
 	multipleOf: true,
 	pattern: true,
 	format: true,
+	contentEncoding: true,
+	contentMediaType: true,
+	contentSchema: true,
 	dependencies: true,
 	dependentSchemas: true,
 	dependentRequired: true,
@@ -212,6 +222,8 @@ export const COMBINATOR_KEYS = ["anyOf", "allOf", "oneOf"] as const;
  */
 export const CCA_UNSUPPORTED_SCHEMA_FIELDS: Record<string, true> = {
 	$schema: true,
+	$id: true,
+	$anchor: true,
 	$ref: true,
 	$defs: true,
 	$dynamicRef: true,
@@ -223,4 +235,12 @@ export const CCA_UNSUPPORTED_SCHEMA_FIELDS: Record<string, true> = {
 	readOnly: true,
 	writeOnly: true,
 	$comment: true,
+	uniqueItems: true,
+	contains: true,
+	minContains: true,
+	maxContains: true,
+	additionalItems: true,
+	contentEncoding: true,
+	contentMediaType: true,
+	contentSchema: true,
 };

package/src/utils/schema/normalize.ts

@@ -36,7 +36,11 @@ export interface NormalizeSchemaOptions {
 	unsupportedFields: (key: string) => boolean;
 	normalizeFieldNames: boolean;
 	collapseNullFields: boolean;
-	normalizeTypeArrayToNullable: boolean;
+	/**
+	 * Target takes a scalar `type` only: `["T", "null"]` becomes `T` (+ `nullable`)
+	 * and a multi-type array becomes one `anyOf` branch per type.
+	 */
+	scalarizeTypeArrays: boolean;
 	stripNullableKeyword: boolean;
 	autoPropertyOrdering: boolean;
 	ensureObjectProperties: boolean;
@@ -290,6 +294,51 @@ function preHandleNullFields(obj: JsonObject): JsonObject {
 	return out;
 }
 
+/**
+ * Rewrites a multi-type `type` array (`["string", "array"]`) as one `anyOf`
+ * branch per non-null type, each carrying only the keywords that constrain its
+ * type. Collapsing to the first type instead narrows what the tool accepts and
+ * strands the other types' keywords: Gemini rejects `items` beside
+ * `type: "string"` with HTTP 400. A `null` member becomes `nullable: true`, as
+ * in the scalar collapse. Returns `obj` itself when it has fewer than two
+ * non-null types or already carries `anyOf`.
+ */
+function splitTypeArrayIntoAnyOf(obj: JsonObject): JsonObject {
+	if (!Array.isArray(obj.type) || Array.isArray(obj.anyOf)) return obj;
+	const types: string[] = [];
+	for (const type of obj.type) {
+		if (typeof type === "string" && type !== "null" && !types.includes(type)) types.push(type);
+	}
+	if (types.length < 2) return obj;
+	const branches = types.map(type => {
+		const schema: JsonObject = { type };
+		return { schema, keys: CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS[type] ?? {} };
+	});
+	const out: JsonObject = {};
+	for (const key in obj) {
+		if (!Object.hasOwn(obj, key) || key === "type") continue;
+		const value = obj[key];
+		if (!Object.hasOwn(ALL_CCA_TYPE_SPECIFIC_KEYS, key)) {
+			out[key] = value;
+			continue;
+		}
+		for (const branch of branches) {
+			if (Object.hasOwn(branch.keys, key)) branch.schema[key] = value;
+		}
+	}
+	if (obj.type.includes("null")) out.nullable = true;
+	out.anyOf = branches.map(branch => branch.schema);
+	return out;
+}
+
+/** Deletes keywords that constrain a JSON type other than `type`, e.g. `items` on a string node. */
+function dropForeignTypeKeywords(schema: JsonObject, type: string): void {
+	const allowed = CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS[type] ?? {};
+	for (const key in schema) {
+		if (Object.hasOwn(ALL_CCA_TYPE_SPECIFIC_KEYS, key) && !Object.hasOwn(allowed, key)) delete schema[key];
+	}
+}
+
 function outHasOwn(obj: JsonObject, key: string): boolean {
 	return Object.hasOwn(obj, key);
 }
@@ -375,6 +424,9 @@ function normalizeSchemaNode(value: unknown, options: NormalizeSchemaWalkOptions
 
 function normalizeSchemaObjectNode(value: JsonObject, options: NormalizeSchemaWalkOptions): unknown {
 	let obj = options.normalizeFieldNames && !options.insideSchemaMap ? applySnakeCaseRenames(value) : value;
+	if (options.scalarizeTypeArrays && !options.insideSchemaMap) {
+		obj = splitTypeArrayIntoAnyOf(obj);
+	}
 	if (options.collapseNullFields && !options.insideSchemaMap) {
 		obj = preHandleNullFields(obj);
 	}
@@ -479,13 +531,14 @@ function normalizeSchemaObjectNode(value: JsonObject, options: NormalizeSchemaWa
 			: entry;
 	}
 
-	if (options.normalizeTypeArrayToNullable && Array.isArray(result.type)) {
+	if (options.scalarizeTypeArrays && Array.isArray(result.type)) {
 		const types = (result.type as unknown[]).filter((t): t is string => typeof t === "string");
 		const nonNull = types.filter(t => t !== "null");
 		if (types.includes("null") && !options.stripNullableKeyword) {
 			result.nullable = true;
 		}
 		result.type = nonNull[0] ?? types[0];
+		if (typeof result.type === "string") dropForeignTypeKeywords(result, result.type);
 	}
 	if (constValue !== undefined) {
 		const existingEnum = Array.isArray(result.enum) ? result.enum : [];
@@ -738,20 +791,8 @@ function collapseMixedTypeCombinerVariants(schema: JsonObject, combiner: "anyOf"
 	const chosenType: string = nonNullTypes[0] ?? variantTypes[0];
 	nextSchema.type = chosenType;
 	const chosenTypeAllowedKeys = CLOUD_CODE_ASSIST_TYPE_SPECIFIC_KEYS[chosenType] ?? {};
-
-	// Strip sibling keys that were copied from the parent and belong to a
-	// different type (e.g. `items` sibling on a now-string-typed schema).
-	for (const key in nextSchema) {
-		if (!Object.hasOwn(nextSchema, key)) continue;
-		if (key === "type") continue;
-		if (
-			Object.hasOwn(ALL_CCA_TYPE_SPECIFIC_KEYS, key) &&
-			!Object.hasOwn(chosenTypeAllowedKeys, key) &&
-			!Object.hasOwn(CLOUD_CODE_ASSIST_SHARED_SCHEMA_KEYS, key)
-		) {
-			delete nextSchema[key];
-		}
-	}
+	// Sibling keys copied from the parent may belong to a different type.
+	dropForeignTypeKeywords(nextSchema, chosenType);
 
 	for (const key in mergedVariantFields) {
 		if (!Object.hasOwn(mergedVariantFields, key)) continue;
@@ -1256,7 +1297,7 @@ export function normalizeSchemaForGoogle(value: unknown): unknown {
 		unsupportedFields: isGoogleUnsupportedSchemaField,
 		normalizeFieldNames: true,
 		collapseNullFields: true,
-		normalizeTypeArrayToNullable: true,
+		scalarizeTypeArrays: true,
 		stripNullableKeyword: false,
 		autoPropertyOrdering: true,
 		ensureObjectProperties: true,
@@ -1279,7 +1320,7 @@ export function normalizeSchemaForCCA(value: unknown): unknown {
 		unsupportedFields: isGoogleUnsupportedSchemaField,
 		normalizeFieldNames: true,
 		collapseNullFields: false,
-		normalizeTypeArrayToNullable: true,
+		scalarizeTypeArrays: true,
 		stripNullableKeyword: true,
 		autoPropertyOrdering: false,
 		ensureObjectProperties: true,
@@ -1302,7 +1343,7 @@ export function normalizeSchemaForMCP(value: unknown): unknown {
 		unsupportedFields: isMcpUnsupportedSchemaField,
 		normalizeFieldNames: false,
 		collapseNullFields: false,
-		normalizeTypeArrayToNullable: false,
+		scalarizeTypeArrays: false,
 		foldOneOfIntoAnyOf: false,
 		stripNullableKeyword: true,
 		autoPropertyOrdering: false,
@@ -1330,8 +1371,9 @@ export function normalizeSchemaForMCP(value: unknown): unknown {
  *    rejected; collapse to `enum` with an inferred scalar `type`.
  *  - `oneOf` is not an MFJS combinator (only `anyOf` is); residual `oneOf` is
  *    folded into `anyOf`.
- *  - `type` must be a scalar string; `type: [...]` arrays are reduced to a
- *    single scalar (the `null` branch is dropped — `nullable` is unsupported).
+ *  - `type` must be a scalar string; `["T", "null"]` reduces to `T` (the
+ *    `null` member is dropped — `nullable` is unsupported) and a multi-type
+ *    array becomes one typed `anyOf` branch per type.
  *  - Enum-bearing nodes get an inferred `type` (the idiomatic MFJS form; a bare
  *    `enum` is valid too) so `anyOf` branches always carry a `type`.
  *  - Validation/decorative keywords (`minItems`, `maxItems`, `maxLength`,
@@ -1354,7 +1396,7 @@ export function normalizeSchemaForMoonshot(value: unknown): unknown {
 		unsupportedFields: isMoonshotUnsupportedSchemaField,
 		normalizeFieldNames: false,
 		collapseNullFields: false,
-		normalizeTypeArrayToNullable: true,
+		scalarizeTypeArrays: true,
 		stripNullableKeyword: true,
 		autoPropertyOrdering: false,
 		ensureObjectProperties: false,