@namzu/sdk 62.4.0 → 62.5.0

package/src/types/session/config.ts

@@ -69,6 +69,17 @@ export interface TurnConfig {
 	 */
 	effort?: import('../provider/index.js').ReasoningEffort
 
+	/**
+	 * Inference speed for every model call in the turn: `'fast'` asks for the
+	 * provider's premium low-latency mode (billed at a multiple of the standard
+	 * rate), absent and `'standard'` are the ordinary request. Turn-level for
+	 * the same reason as {@link TurnConfig.effort}: speeds do not share a
+	 * prompt-cache prefix, so a value that moves between steps pays for a cache
+	 * miss each time. A driver or model without the mode REFUSES `'fast'`
+	 * rather than serving it slowly.
+	 */
+	speed?: import('../provider/index.js').InferenceSpeed
+
 	/**
 	 * How the turn bounds its reasoning. On by default.
 	 *

package/src/types/session/events.ts

@@ -519,7 +519,14 @@ type CoreSessionEvent =
 			/** The model that declined. */
 			model: string
 			providerId: string
-			outcome: 'fallback' | 'retry' | 'declined'
+			outcome: 'fallback' | 'retry' | 'withheld' | 'declined'
+			/**
+			 * Set only with `outcome: 'withheld'`: the recorded-context keys the
+			 * re-run leaves out of the request (see `QueryParams.withholdOnRefusal`).
+			 */
+			withheldKeys?: string[]
+			/** With `'withheld'`: the ids of the recalled memories those entries carried. */
+			withheldMemoryIds?: string[]
 			/** The model the request moves to. Set only with `outcome: 'fallback'`. */
 			fallbackModel?: string
 			/** The provider's own classification, when it gave one. */

package/src/types/session/prepare-step.ts

@@ -98,6 +98,13 @@ export interface PrepareStepContext {
 	}
 	/** Every completed step, in order. */
 	readonly steps: readonly StepResult[]
+	/**
+	 * Recorded-context keys the request leaves out: set aside by a refused
+	 * request (`QueryParams.withholdOnRefusal`) or by the host
+	 * (`QueryParams.withheldKeys`). A stage that records text under one of
+	 * these keys should add nothing now; whatever it records is also left out.
+	 */
+	readonly withheldKeys?: readonly string[]
 
 	/**
 	 * What the stages before this one decided, when several were supplied.

package/src/utils/cost.ts

@@ -41,6 +41,13 @@ export interface ModelPricing {
 	 * part. The catalogue always supplies this.
 	 */
 	cache?: CacheRates
+	/**
+	 * The vendor's published multiple of every rate on this card for a request
+	 * served in fast mode (`TokenUsage.speed === 'fast'`). Absent means there is
+	 * no published fast price: fast usage is then counted as unpriced, never
+	 * charged at the standard rate, which would under-report it.
+	 */
+	fastMultiplier?: number
 }
 
 export { ZERO_COST }
@@ -54,6 +61,22 @@ interface Priced {
 }
 
 function priceUsage(usage: TokenUsage, pricing: ModelPricing): Priced {
+	if (usage.speed === 'fast') {
+		const multiplier = pricing.fastMultiplier
+		if (multiplier === undefined) {
+			return { cost: 0, cacheDiscount: 0, unpriced: usage.totalTokens }
+		}
+		const standard = priceStandard({ ...usage, speed: undefined }, pricing)
+		return {
+			cost: standard.cost * multiplier,
+			cacheDiscount: standard.cacheDiscount * multiplier,
+			unpriced: standard.unpriced,
+		}
+	}
+	return priceStandard(usage, pricing)
+}
+
+function priceStandard(usage: TokenUsage, pricing: ModelPricing): Priced {
 	const perMillion = (tokens: number, rate: number) => (tokens / 1_000_000) * rate
 
 	const cache = pricing.cache