@oh-my-pi/pi-ai 18.2.8 → 18.2.9

package/src/usage/claude.ts

@@ -2,7 +2,6 @@ import { scheduler } from "node:timers/promises";
 import { classifyModel } from "@oh-my-pi/pi-catalog/compat/taxonomy";
 import { toNumber } from "@oh-my-pi/pi-catalog/utils";
 import * as AIError from "../error";
-import { claudeCodeVersion } from "../providers/claude-code-fingerprint";
 import {
 	type CredentialRankingContext,
 	type CredentialRankingStrategy,
@@ -13,66 +12,22 @@ import {
 	type UsageLimit,
 	type UsageProvider,
 	type UsageReport,
+	type UsageResetCredits,
 	type UsageStatus,
 	type UsageWindow,
 } from "../usage";
 import { isRecord } from "../utils";
+import { buildClaudeOAuthHeaders, claudeOAuthBaseUrls } from "./claude-api";
+import { listClaudeResetCredits, parseClaudeResetCreditsFromUsagePayload } from "./claude-reset";
 import { HOUR_MS, parseIsoTimestamp, WEEK_MS } from "./shared";
 
-const DEFAULT_ENDPOINT = "https://api.anthropic.com/api/oauth";
 const MAX_ATTEMPTS = 3;
 const BASE_RETRY_DELAY_MS = 500;
 /** Shared windows that gate every Claude request, whatever the model. */
 const CLAUDE_SHARED_GATE_WINDOW_IDS = ["5h", "7d"] as const;
 
-const CLAUDE_HEADERS = {
-	accept: "application/json, text/plain, */*",
-	"accept-encoding": "gzip, compress, deflate, br",
-	"anthropic-beta":
-		"claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,redact-thinking-2026-02-12,context-management-2025-06-27,prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07,advanced-tool-use-2025-11-20,effort-2025-11-24,extended-cache-ttl-2025-04-11",
-	"content-type": "application/json",
-	"user-agent": `claude-cli/${claudeCodeVersion} (external, cli)`,
-	connection: "keep-alive",
-} as const;
-
-function normalizeClaudeBaseUrl(baseUrl?: string): string {
-	if (!baseUrl?.trim()) return DEFAULT_ENDPOINT;
-	const trimmed = baseUrl.trim().replace(/\/+$/, "");
-	const lower = trimmed.toLowerCase();
-	if (lower.endsWith("/api/oauth")) return trimmed;
-	let url: URL;
-	try {
-		url = new URL(trimmed);
-	} catch {
-		return DEFAULT_ENDPOINT;
-	}
-	let path = url.pathname.replace(/\/+$/, "");
-	if (path === "/") path = "";
-	if (path.toLowerCase().endsWith("/v1")) {
-		path = path.slice(0, -3);
-	}
-	if (!path) return `${url.origin}/api/oauth`;
-	return `${url.origin}${path}/api/oauth`;
-}
-
-/**
- * Subscription usage is served by Anthropic's OAuth API, which a custom
- * `baseUrl` pointed at a Messages-only endpoint does not expose. Probe the
- * configured host first so a full mirror keeps answering (including its own
- * `/profile` identity), then fall back to the canonical endpoint — but only
- * when the configured host answered that it has no usage endpoint there (see
- * {@link ClaudeUsagePayloadResult.endpointAbsent}), so a host that refuses the
- * credential or fails transiently keeps the request.
- *
- * Without the fallback the report degrades to rate-limit headers, and those
- * carry the model-scoped weekly row only on responses for that model family,
- * so a scoped window can read far below its real utilization until a request
- * hits the family again.
- */
-function claudeUsageBaseUrls(baseUrl?: string): readonly string[] {
-	const configured = normalizeClaudeBaseUrl(baseUrl);
-	return configured === DEFAULT_ENDPOINT ? [DEFAULT_ENDPOINT] : [configured, DEFAULT_ENDPOINT];
-}
+const CLAUDE_USAGE_BETAS =
+	"claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,redact-thinking-2026-02-12,context-management-2025-06-27,prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07,advanced-tool-use-2025-11-20,effort-2025-11-24,extended-cache-ttl-2025-04-11";
 
 interface ClaudeUsageBucket {
 	utilization?: number;
@@ -246,7 +201,8 @@ function hasUsageData(payload: ClaudeUsageResponse): boolean {
 		parseBucket(payload.seven_day_opus)?.utilization !== undefined ||
 		parseBucket(payload.seven_day_sonnet)?.utilization !== undefined ||
 		parseApiLimitEntries(payload.limits).some(entry => entry.bucket.utilization !== undefined) ||
-		buildClaudeExtraUsageLimit(payload) !== null
+		buildClaudeExtraUsageLimit(payload) !== null ||
+		parseClaudeResetCreditsFromUsagePayload(payload) !== null
 	);
 }
 
@@ -316,7 +272,9 @@ function looksLikeUsagePayload(payload: ClaudeUsageResponse): boolean {
 		"seven_day" in payload ||
 		"limits" in payload ||
 		"extra_usage" in payload ||
-		"spend" in payload
+		"spend" in payload ||
+		"cedar_ember" in payload ||
+		"juniper_tide" in payload
 	);
 }
 
@@ -684,14 +642,11 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 	const credential = params.credential;
 	if (credential.type !== "oauth" || !credential.accessToken) return null;
 
-	const headers: Record<string, string> = {
-		...CLAUDE_HEADERS,
-		authorization: `Bearer ${credential.accessToken}`,
-	};
+	const headers = buildClaudeOAuthHeaders(credential.accessToken, { beta: CLAUDE_USAGE_BETAS });
 
 	let baseUrl: string | undefined;
 	let payload: ClaudeUsageResponse | null = null;
-	for (const candidate of claudeUsageBaseUrls(params.baseUrl)) {
+	for (const candidate of claudeOAuthBaseUrls(params.baseUrl)) {
 		const result = await fetchUsagePayload(`${candidate}/usage`, headers, ctx, params.signal);
 		if (result.payload && hasUsageData(result.payload)) {
 			baseUrl = candidate;
@@ -766,7 +721,22 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 		buildClaudeExtraUsageLimit(payload),
 	].filter((limit): limit is UsageLimit => limit !== null);
 
-	if (limits.length === 0) return null;
+	const resetCreditList =
+		parseClaudeResetCreditsFromUsagePayload(payload, credential.orgId, baseUrl) ??
+		(await listClaudeResetCredits({
+			accessToken: credential.accessToken,
+			...(credential.orgId ? { orgId: credential.orgId } : {}),
+			...(params.baseUrl ? { baseUrl: params.baseUrl } : {}),
+			fetch: ctx.fetch,
+			...(params.signal ? { signal: params.signal } : {}),
+		}));
+	const hasResetInventory =
+		resetCreditList !== null &&
+		(resetCreditList.availableCount > 0 ||
+			resetCreditList.nextCreditId !== undefined ||
+			resetCreditList.credits.length > 0);
+	if (limits.length === 0 && !hasResetInventory) return null;
+
 	const identity = extractUsageIdentity(payload);
 	let accountId = identity.accountId ?? credential.accountId;
 	let email = identity.email ?? credential.email;
@@ -775,16 +745,24 @@ async function fetchClaudeUsage(params: UsageFetchParams, ctx: UsageFetchContext
 		accountId = accountId ?? profileIdentity.accountId;
 		email = email ?? profileIdentity.email;
 	}
+	let resetCredits: UsageResetCredits | undefined;
+	let reportOrgId = credential.orgId;
+	if (resetCreditList) {
+		const { orgId, baseUrl: _baseUrl, ...usageResetCredits } = resetCreditList;
+		resetCredits = usageResetCredits;
+		reportOrgId ??= orgId;
+	}
 
 	const report: UsageReport = {
 		provider: params.provider,
 		fetchedAt: Date.now(),
 		limits,
+		...(resetCredits ? { resetCredits } : {}),
 		metadata: {
 			endpoint: url,
 			...(accountId ? { accountId } : {}),
 			...(email ? { email } : {}),
-			...(credential.orgId ? { orgId: credential.orgId } : {}),
+			...(reportOrgId ? { orgId: reportOrgId } : {}),
 		},
 		raw: payload,
 	};

package/src/usage/kimi.ts

@@ -10,6 +10,7 @@ import type {
 	UsageProvider,
 	UsageReport,
 	UsageWindow,
+	UsageUnit,
 } from "../usage";
 import { isRecord } from "../utils";
 import { parseIsoTimestamp, usageStatus } from "./shared";
@@ -21,12 +22,14 @@ const USAGE_PATH = "usages";
 
 interface KimiUsagePayload {
 	usage?: unknown;
+	usages?: unknown;
 	limits?: unknown;
 	totalQuota?: unknown;
 }
 
 type KimiUsageRow = {
 	label: string;
+	unit: UsageUnit;
 	used?: number;
 	limit?: number;
 	remaining?: number;
@@ -137,6 +140,7 @@ function buildUsageRow(data: Record<string, unknown>, defaultLabel: string, nowM
 				: typeof data.title === "string" && data.title
 					? data.title
 					: defaultLabel,
+		unit: "unknown",
 		used,
 		limit,
 		remaining,
@@ -144,8 +148,26 @@ function buildUsageRow(data: Record<string, unknown>, defaultLabel: string, nowM
 	};
 }
 
+function buildAggregateUsageRow(key: string, data: Record<string, unknown>, nowMs: number): KimiUsageRow | null {
+	const usedRatio = toNumber(data.used_ratio);
+	if (usedRatio === undefined) return null;
+
+	const usedFraction = Math.min(Math.max(usedRatio, 0), 1);
+	const label = key === "limit_month_total" ? "Monthly total" : key === "limit_month_code" ? "Monthly code" : key;
+	const resetsAt = parseResetTime(data, nowMs);
+	return {
+		label,
+		unit: "percent",
+		used: usedFraction * 100,
+		limit: 100,
+		remaining: (1 - usedFraction) * 100,
+		resetsAt,
+		window: { id: key, label, resetsAt },
+	};
+}
+
 function buildUsageAmount(row: KimiUsageRow): UsageAmount {
-	const amount: UsageAmount = { unit: "unknown" };
+	const amount: UsageAmount = { unit: row.unit };
 	if (row.limit !== undefined) amount.limit = row.limit;
 	if (row.used !== undefined) amount.used = row.used;
 	if (row.remaining !== undefined) amount.remaining = row.remaining;
@@ -236,6 +258,15 @@ function parseUsagePayload(payload: unknown, nowMs: number): { rows: KimiUsageRo
 		});
 	}
 
+	if (isRecord(data.usages)) {
+		for (const key in data.usages) {
+			const aggregate = data.usages[key];
+			if (key === "limit_5h" || !isRecord(aggregate)) continue;
+			const row = buildAggregateUsageRow(key, aggregate, nowMs);
+			if (row) rows.push(row);
+		}
+	}
+
 	return { rows, raw: data };
 }
 

package/src/usage.ts

@@ -75,11 +75,29 @@ export interface UsageLimit {
  * Per-credit detail for a saved/banked rate-limit reset.
  *
  * Populated when the provider's listing endpoint returns individual credit
- * metadata (e.g. OpenAI Codex `wham/rate-limit-reset-credits`). Callers that
+ * metadata (e.g. OpenAI Codex credits or Claude Cedar grants). Callers that
  * only need the count can ignore this; display layers use `expiresAt` to show
  * when banked resets expire ([#3339](https://github.com/can1357/oh-my-pi/issues/3339)).
  */
 export interface UsageResetCreditDetail {
+	/** Opaque provider credit/grant identifier. */
+	id?: string;
+	/** Human-facing name for the reset. */
+	title?: string;
+	/** Provider reset program/family. */
+	program?: string;
+	/** Resets still banked in this credit/grant. */
+	remainingCount?: number;
+	/** Whether the provider says this credit can be redeemed now. */
+	usable?: boolean;
+	/** Whether redemption requires an exhausted covered limit. */
+	requiresLimit?: boolean;
+	/** Normalized {@link UsageLimit.id}s this credit resets. */
+	clears?: string[];
+	/** Normalized limit ids currently preventing redemption. */
+	blocking?: string[];
+	/** Used fractions for covered limits, keyed by normalized limit id. */
+	usedFractions?: Record<string, number>;
 	/** ISO timestamp when the credit was granted. */
 	grantedAt?: string;
 	/** ISO timestamp when the credit expires and can no longer be redeemed. */
@@ -88,17 +106,32 @@ export interface UsageResetCreditDetail {
 	status?: string;
 }
 
+/** Reset credit carrying the provider id required by its consume endpoint. */
+export interface UsageResetCredit extends UsageResetCreditDetail {
+	id: string;
+}
+
 /**
  * Saved/banked rate-limit resets an account can redeem on demand.
  *
  * Surfaced by providers that let users defer a usage-window reset and spend it
- * later (OpenAI Codex "saved rate limit resets"). The redeem itself is a
- * separate, provider-specific action; this is the read-only count for display.
+ * later (OpenAI Codex and Claude Cedar resets). The redeem itself is a
+ * separate, provider-specific action; this is the read-only state for display.
  */
 export interface UsageResetCredits {
-	/** Number of resets available to redeem right now. */
+	/** Number of banked resets, including grants that are not currently usable. */
 	availableCount: number;
-	/** Individual credit details (expiry dates, etc.) when the provider exposes them. */
+	/** Number of resets the provider says can be redeemed now. */
+	redeemableCount?: number;
+	/** Provider-selected credit/grant eligible for the next redemption. */
+	nextCreditId?: string;
+	/** Whether this account is eligible for the reset program. */
+	eligible?: boolean;
+	/** Provider reason the program or its credits are unavailable. */
+	reason?: string;
+	/** ISO timestamp until which redemption is cooling down. */
+	cooldownUntil?: string;
+	/** Individual credit details (expiry dates, coverage, etc.) when exposed. */
 	credits?: UsageResetCreditDetail[];
 }
 
@@ -287,6 +320,15 @@ export const usageLimitSchema = type({
 });
 
 export const usageResetCreditDetailSchema = type({
+	"id?": "string",
+	"title?": "string",
+	"program?": "string",
+	"remainingCount?": "number",
+	"usable?": "boolean",
+	"requiresLimit?": "boolean",
+	"clears?": "string[]",
+	"blocking?": "string[]",
+	"usedFractions?": { "[string]": "number" },
 	"grantedAt?": "string",
 	"expiresAt?": "string",
 	"status?": "string",
@@ -294,6 +336,11 @@ export const usageResetCreditDetailSchema = type({
 
 export const usageResetCreditsSchema = type({
 	availableCount: "number",
+	"redeemableCount?": "number",
+	"nextCreditId?": "string",
+	"eligible?": "boolean",
+	"reason?": "string",
+	"cooldownUntil?": "string",
 	"credits?": usageResetCreditDetailSchema.array(),
 });
 

package/src/utils/schema/json-schema-validator.ts

@@ -98,6 +98,17 @@ function isTagSelectedBranch(branch: unknown, value: unknown): boolean {
 	return matched;
 }
 
+/** The unique discriminator-selected branch, or undefined when selection is ambiguous or absent. */
+export function getTagSelectedUnionBranch(branches: readonly unknown[], value: unknown): unknown {
+	let selected: unknown;
+	for (const branch of branches) {
+		if (!isTagSelectedBranch(branch, value)) continue;
+		if (selected !== undefined) return undefined;
+		selected = branch;
+	}
+	return selected;
+}
+
 function pushIssue(
 	issues: JsonSchemaValidationIssue[],
 	path: readonly PropertyKey[],
@@ -383,7 +394,7 @@ function validateSchemaNode(
 		let matches = 0;
 		let firstIssues: JsonSchemaValidationIssue[] | undefined;
 		let selectedIssues: JsonSchemaValidationIssue[] | undefined;
-		let selectedCount = 0;
+		const selectedBranch = getTagSelectedUnionBranch(branches, value);
 		for (const branch of branches) {
 			const branchIssues: JsonSchemaValidationIssue[] = [];
 			if (validateSchemaNode(branch, value, path, ctx, branchIssues)) {
@@ -391,14 +402,11 @@ function validateSchemaNode(
 				continue;
 			}
 			if (!firstIssues) firstIssues = branchIssues;
-			if (isTagSelectedBranch(branch, value)) {
-				selectedCount += 1;
-				if (selectedCount === 1) selectedIssues = branchIssues;
-			}
+			if (branch === selectedBranch) selectedIssues = branchIssues;
 		}
 		const branchValid = keyword === "anyOf" ? matches > 0 : matches === 1;
 		if (!branchValid) {
-			if (matches === 0 && selectedCount === 1 && selectedIssues && selectedIssues.length > 0) {
+			if (matches === 0 && selectedIssues && selectedIssues.length > 0) {
 				// A const/enum discriminator uniquely identifies the intended
 				// variant, so its diagnosis is authoritative: surface untagged and
 				// keep every repair (including lossy ones) available.
@@ -741,10 +749,15 @@ function validateSchemaValueInRoot(schema: unknown, value: unknown, root: unknow
 	return { success, issues };
 }
 
-export function validateJsonSchemaValue(schema: unknown, value: unknown): JsonSchemaValidationResult {
-	return validateSchemaValueInRoot(schema, value, schema);
+export function validateJsonSchemaValue(
+	schema: unknown,
+	value: unknown,
+	root: unknown = schema,
+): JsonSchemaValidationResult {
+	return validateSchemaValueInRoot(schema, value, root);
 }
 
-export function isJsonSchemaValueValid(schema: unknown, value: unknown): boolean {
-	return validateJsonSchemaValue(schema, value).success;
+/** Validate a subschema using its complete schema's local-reference context. */
+export function isJsonSchemaValueValid(schema: unknown, value: unknown, root: unknown = schema): boolean {
+	return validateSchemaValueInRoot(schema, value, root).success;
 }

package/src/utils/tool-call-loop-guard.ts

@@ -76,7 +76,7 @@ export class ToolCallLoopGuard {
 		this.#exemptTools = new Set(options.exemptTools);
 	}
 
-	/** Records one completed turn and returns the threshold hit, if any. */
+	/** Records one completed turn and reports repetitions at or beyond the threshold. */
 	recordTurn(turn: ToolCallLoopTurn): RepeatedToolCallDetection | null {
 		const toolCalls = turn.message.content.filter((part): part is ToolCall => part.type === "toolCall");
 		if (toolCalls.length === 0) {
@@ -101,7 +101,7 @@ export class ToolCallLoopGuard {
 			this.#count = 1;
 		}
 
-		if (this.#count !== this.#threshold) return null;
+		if (this.#count < this.#threshold) return null;
 		const reportCall = toolCalls.find(tc => !this.#exemptTools.has(tc.name)) ?? toolCalls[0]!;
 		return {
 			kind: "repeated_tool_call",