@paean-ai/harness-model-pricing 0.1.1-rc.17

package/lib/index.js

@@ -0,0 +1,280 @@
+import z from "@deepseek-ai/schemastery";
+import { z as z$1 } from "zod";
+//#region lib/types/defaults.js
+/** Default market-price sheet; DeepSeek uses peak prices, Claude uses global/5-minute caching. */
+const DEFAULT_SHEET = {
+	verifiedOn: "2026-10-02",
+	cards: [
+		{
+			id: "deepseek-v4.1-flash",
+			name: "DeepSeek V4.1 Flash",
+			input: .3,
+			output: 1.2,
+			cacheRead: .006,
+			cacheWrite: .3,
+			source: "https://api-docs.deepseek.com/quick_start/pricing/"
+		},
+		{
+			id: "gpt-6-sol",
+			name: "GPT-6 Sol",
+			input: 2,
+			output: 10,
+			cacheRead: .2,
+			cacheWrite: 2.5,
+			source: "https://developers.openai.com/api/docs/models/gpt-6-sol",
+			longContext: {
+				above: 272e3,
+				rates: {
+					input: 4,
+					output: 15,
+					cacheRead: .4,
+					cacheWrite: 5
+				}
+			}
+		},
+		{
+			id: "gpt-6.1-sol",
+			name: "GPT-6.1 Sol",
+			input: 2,
+			output: 10,
+			cacheRead: .1,
+			cacheWrite: 2.5,
+			source: "https://developers.openai.com/api/docs/models/gpt-6.1-sol",
+			longContext: {
+				above: 272e3,
+				rates: {
+					input: 4,
+					output: 15,
+					cacheRead: .2,
+					cacheWrite: 5
+				}
+			}
+		},
+		{
+			id: "gpt-6-astra",
+			name: "GPT-6 Astra",
+			input: 10,
+			output: 50,
+			cacheRead: 1,
+			cacheWrite: 12.5,
+			source: "https://developers.openai.com/api/docs/models/gpt-6-astra",
+			longContext: {
+				above: 272e3,
+				rates: {
+					input: 20,
+					output: 75,
+					cacheRead: 2,
+					cacheWrite: 25
+				}
+			}
+		},
+		{
+			id: "sonnet-5.5",
+			name: "Claude Sonnet 5.5",
+			input: 2,
+			output: 10,
+			cacheRead: .2,
+			cacheWrite: 2.5,
+			source: "https://cloud.google.com/vertex-ai/generative-ai/pricing#claude_models"
+		},
+		{
+			id: "opus-5.5",
+			name: "Claude Opus 5.5",
+			input: 4,
+			output: 20,
+			cacheRead: .2,
+			cacheWrite: 5,
+			source: "https://cloud.google.com/vertex-ai/generative-ai/pricing#claude_models"
+		}
+	],
+	routes: [
+		{
+			provider: "paean",
+			model: "praxis-auto",
+			card: "deepseek-v4.1-flash"
+		},
+		{
+			provider: "paean",
+			model: "praxis-lite",
+			card: "deepseek-v4.1-flash"
+		},
+		{
+			provider: "paean",
+			model: "praxis-flash",
+			card: "gpt-6-sol"
+		},
+		{
+			provider: "paean",
+			model: "praxis-pro",
+			card: "gpt-6-astra"
+		},
+		{
+			provider: "paean-anthropic",
+			model: "praxis-auto",
+			card: "deepseek-v4.1-flash"
+		},
+		{
+			provider: "paean-anthropic",
+			model: "praxis-lite",
+			card: "deepseek-v4.1-flash"
+		},
+		{
+			provider: "paean-anthropic",
+			model: "praxis-flash",
+			card: "sonnet-5.5"
+		},
+		{
+			provider: "paean-anthropic",
+			model: "praxis-pro",
+			card: "opus-5.5"
+		}
+	]
+};
+//#endregion
+//#region lib/types/projection.js
+/** Whole-log usage attribution; prices remain read-side configuration, never durable billing facts. */
+const count = z$1.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const usageSchema = z$1.object({
+	inputTokens: count,
+	outputTokens: count,
+	cacheReadTokens: count.default(0),
+	cacheWriteTokens: count.default(0)
+}).strict();
+const requestSchema = z$1.object({
+	provider: z$1.string(),
+	model: z$1.string(),
+	purpose: z$1.enum(["assistant", "compaction"]),
+	usage: usageSchema.nullable()
+}).strict();
+const viewSchema = z$1.object({ requests: z$1.array(requestSchema) }).strict();
+const stateSchema = z$1.object({
+	view: viewSchema,
+	route: z$1.object({
+		provider: z$1.string(),
+		model: z$1.string()
+	}).nullable()
+}).strict();
+/**
+* Accept normalized SDK buckets, with omitted zero cache buckets and no reasoning surcharge.
+* @param value - measured usage from the durable SDK stream.
+* @returns disjoint buckets, or null for absent, invalid, or inconsistent evidence.
+*/
+function measuredUsage(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const raw = value;
+	const parsed = usageSchema.safeParse({
+		inputTokens: raw.inputTokens,
+		outputTokens: raw.outputTokens,
+		cacheReadTokens: raw.cacheReadTokens,
+		cacheWriteTokens: raw.cacheWriteTokens
+	});
+	if (!parsed.success) return null;
+	const usage = parsed.data;
+	const total = usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
+	if (!Number.isSafeInteger(total)) return null;
+	if (raw.totalTokens !== void 0 && raw.totalTokens !== total) return null;
+	if (raw.reasoningTokens !== void 0 && (!count.safeParse(raw.reasoningTokens).success || Number(raw.reasoningTokens) > usage.outputTokens)) return null;
+	return usage;
+}
+/** Last normalized usage chunk in one compact native stream, without expanding its content. */
+function usageFrom(stream) {
+	for (let index = stream.length - 1; index >= 0; index--) {
+		const record = stream[index];
+		if (record?.type === "chunk" && record.chunk.type === "usage") return record.chunk.usage;
+	}
+}
+/** Compact, whole-log request facts survive paging, compaction and price-sheet updates. */
+const pricingUsageProjection = {
+	key: "paeanPricingUsage",
+	stateVersion: 1,
+	stateSchema,
+	init: () => ({
+		view: { requests: [] },
+		route: null
+	}),
+	apply: (state, event) => {
+		if (event.type === "request/header") {
+			const { provider, model } = event.data.header.config;
+			if (state.route?.provider === provider && state.route.model === model) return state;
+			return {
+				...state,
+				route: {
+					provider,
+					model
+				}
+			};
+		}
+		if (event.type === "compaction/summary") {
+			const request = {
+				provider: event.data.provider,
+				model: event.data.model,
+				purpose: "compaction",
+				usage: measuredUsage(event.data.usage)
+			};
+			return {
+				...state,
+				view: { requests: [...state.view.requests, request] }
+			};
+		}
+		if (event.type !== "assistant/message" && event.type !== "assistant/attempt") return state;
+		const route = event.type === "assistant/message" ? event.data.message.source : state.route;
+		const sample = event.type === "assistant/message" && event.data.usage !== void 0 ? event.data.usage : usageFrom(event.data.stream);
+		const request = {
+			provider: route?.provider ?? "",
+			model: route?.model ?? "",
+			purpose: "assistant",
+			usage: measuredUsage(sample)
+		};
+		return {
+			...state,
+			view: { requests: [...state.view.requests, request] }
+		};
+	},
+	wire: {
+		viewSchema,
+		view: (state) => state.view
+	}
+};
+//#endregion
+//#region lib/types/index.js
+/** Cordis plugin identity. */
+const name = "paean-model-pricing";
+/** Services own configuration delivery and whole-log projection delivery. */
+const inject = ["sessionProjections", "settings"];
+const rate = z.number().required().min(0).max(1e6);
+const rates = {
+	input: rate,
+	output: rate,
+	cacheRead: rate,
+	cacheWrite: rate
+};
+/** Validated market rates and protocol-specific mappings, served by the standard Settings API. */
+const Config = z.object({ sheet: z.object({
+	verifiedOn: z.string().required().pattern(/^\d{4}-\d{2}-\d{2}$/),
+	cards: z.array(z.object({
+		id: z.string().required().min(1),
+		name: z.string().required().min(1),
+		source: z.string().required().pattern(/^https:\/\//),
+		...rates,
+		longContext: z.union([z.object({
+			above: z.number().required().step(1).min(1),
+			rates: z.object(rates).required()
+		}), z.const(void 0)])
+	})).required(),
+	routes: z.array(z.object({
+		provider: z.string().required().min(1),
+		model: z.string().required().min(1),
+		card: z.string().required().min(1)
+	})).required()
+}).default(DEFAULT_SHEET).volatile() });
+/**
+* Register the measured-usage fold and editable settings, both owned by this fiber.
+* @param ctx - injected projection and Settings services.
+* @param _config - live price sheet exposed to the browser through Settings.
+*/
+function apply(ctx, _config) {
+	ctx.sessionProjections.register(pricingUsageProjection);
+	ctx.effect(() => ctx.settings.configure({ auto: true }));
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/types/calculate.d.ts

@@ -0,0 +1,52 @@
+/** Pure USD estimates over measured, request-attributed usage and an editable price sheet. */
+import type { PriceCard, PriceSheet, PricedRequest, PricingUsage, Rates } from './types.ts';
+/** Estimated request subtotal, with the tariff that produced it. */
+export interface RequestEstimate {
+    card: PriceCard;
+    rates: Rates;
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+}
+/** Priced subtotal and explicit coverage of the settled requests in this session. */
+export interface UsageEstimate {
+    total: number;
+    priced: number;
+    unpriced: number;
+    byCard: {
+        card: PriceCard;
+        total: number;
+        requests: number;
+    }[];
+}
+/**
+ * Resolve an alias without querying account identity or changing its route.
+ * @param sheet - current tariff configuration.
+ * @param provider - recorded provider identity.
+ * @param model - recorded alias.
+ * @returns its tariff, or absence when no unambiguous mapping exists.
+ */
+export declare function resolveCard(sheet: PriceSheet, provider: string, model: string): PriceCard | undefined;
+/**
+ * Price disjoint usage buckets; reasoning is already part of output.
+ * @param sheet - current public rates, including any long-context band.
+ * @param request - one settled request's measured usage.
+ * @returns its estimate, or absence for unavailable usage or an unmapped route.
+ */
+export declare function estimateRequest(sheet: PriceSheet, request: PricedRequest): RequestEstimate | undefined;
+/**
+ * Revalue the complete session against the current sheet, preserving missing coverage.
+ * @param sheet - current market prices.
+ * @param usage - whole-log request facts from the projection.
+ * @returns a subtotal and per-model breakdown; unpriced requests never become zero-cost claims.
+ */
+export declare function estimateUsage(sheet: PriceSheet, usage: PricingUsage): UsageEstimate;
+/**
+ * Format USD with enough precision for a tiny test; positive amounts never display as zero.
+ * @param amount - nonnegative estimated dollars.
+ * @returns a compact USD amount, with an upper bound for sub-micro-dollar values.
+ */
+export declare function formatUsd(amount: number): string;
+//# sourceMappingURL=calculate.d.ts.map

package/lib/types/client/ModelPricing.d.ts

@@ -0,0 +1,26 @@
+import type { UseProjection } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { ConfigForm } from '@deepseek-ai/dsh-client-ui-settings/client';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { PriceSheet } from '../types.ts';
+import type { NS } from './locales.ts';
+/** Form access injected by the plugin; measured usage is supplied by the Session owner. */
+export interface PricingFace {
+    form: ConfigForm<{
+        sheet: PriceSheet;
+    }>;
+}
+/**
+ * Render a compact estimate beside token statistics; details never enlarge the composer.
+ * @param props - standard read-only form, session projection hook and locale seat.
+ * @returns the composer price row; unavailable configuration shows no monetary claim.
+ */
+export declare function ModelPricing({ form, useProjection, t }: PricingFace & {
+    useProjection: UseProjection;
+} & PropsLocale<typeof NS>): import("react").JSX.Element | null;
+/**
+ * Show the public price list in Settings before any session or credential exists.
+ * @param props - the same live price form and localized copy used by the composer.
+ * @returns the complete price list without a session cost claim.
+ */
+export declare function ModelPricingSettings({ form, t }: PricingFace & PropsLocale<typeof NS>): import("react").JSX.Element;
+//# sourceMappingURL=ModelPricing.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,11 @@
+/** Browser plugin registering a read-only price row on the DSH composer dock. */
+import type { Context } from '@deepseek-ai/cordis';
+export type * from '../types.ts';
+/** Services supplied by the browser composition. */
+export declare const inject: string[];
+/**
+ * Contribute localized prices while the matching Host settings namespace is served.
+ * @param ctx - browser composition services; all registrations withdraw with the fiber.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/locales.d.ts

@@ -0,0 +1,68 @@
+/** Typed English and Chinese copy for estimated USD and public tariff assumptions. */
+export declare const NS = "paeanModelPricing";
+/** Keys owned by the price presentation. */
+export type PricingKey = 'title' | 'total' | 'partialTotal' | 'empty' | 'loading' | 'coverage' | 'partial' | 'assumptions' | 'verified' | 'protocol' | 'alias' | 'input' | 'output' | 'cacheRead' | 'cacheWrite' | 'unit' | 'openai' | 'anthropic' | 'compactTotal' | 'unavailable' | 'hint' | 'disclaimer' | 'details' | 'close' | 'routeCount' | 'settingsHint';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        paeanModelPricing: PricingKey;
+    }
+}
+/** English price-estimation copy. */
+export declare const en: {
+    title: string;
+    total: string;
+    partialTotal: string;
+    empty: string;
+    loading: string;
+    coverage: string;
+    partial: string;
+    assumptions: string;
+    verified: string;
+    protocol: string;
+    alias: string;
+    input: string;
+    output: string;
+    cacheRead: string;
+    cacheWrite: string;
+    unit: string;
+    openai: string;
+    anthropic: string;
+    compactTotal: string;
+    unavailable: string;
+    hint: string;
+    disclaimer: string;
+    details: string;
+    close: string;
+    routeCount: string;
+    settingsHint: string;
+};
+/** Simplified Chinese price-estimation copy. */
+export declare const zh: {
+    title: string;
+    total: string;
+    partialTotal: string;
+    empty: string;
+    loading: string;
+    coverage: string;
+    partial: string;
+    assumptions: string;
+    verified: string;
+    protocol: string;
+    alias: string;
+    input: string;
+    output: string;
+    cacheRead: string;
+    cacheWrite: string;
+    unit: string;
+    openai: string;
+    anthropic: string;
+    compactTotal: string;
+    unavailable: string;
+    hint: string;
+    disclaimer: string;
+    details: string;
+    close: string;
+    routeCount: string;
+    settingsHint: string;
+};
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/defaults.d.ts

@@ -0,0 +1,5 @@
+/** Public standard tariffs checked on 2026-10-02, owned by this Paean plugin. */
+import type { PriceSheet } from './types.ts';
+/** Default market-price sheet; DeepSeek uses peak prices, Claude uses global/5-minute caching. */
+export declare const DEFAULT_SHEET: PriceSheet;
+//# sourceMappingURL=defaults.d.ts.map