@crossworks/voice-client 0.232.205 → 0.232.210

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crossworks/voice-client",
-  "version": "0.232.205",
+  "version": "0.232.210",
   "description": "Browser-safe surface of the voice/model layer — provider catalogue, model catalogs, audio tags, and the adapter type/metadata contract. Zero deps by design: nothing here may reach the network adapters or node builtins (the jackdaw-repo-split P0 boundary).",
   "exports": {
     ".": "./src/index.ts",

package/src/adapters/registry.ts

@@ -15,6 +15,7 @@
 import type { Provider, ProviderCapability, ProviderId } from '../providers';
 import type {
   ChatDispatcher,
+  DecisionDispatcher,
   EmbeddingDispatcher,
   ImageGenDispatcher,
   SttDispatcher,
@@ -29,8 +30,10 @@ const STT = new Map<ProviderId, SttDispatcher>();
 const VISION = new Map<ProviderId, VisionDispatcher>();
 const IMAGE_GEN = new Map<ProviderId, ImageGenDispatcher>();
 const EMBEDDING = new Map<ProviderId, EmbeddingDispatcher>();
+const DECISION = new Map<ProviderId, DecisionDispatcher>();
 
-export type WiredCapability = 'chat' | 'tts' | 'stt' | 'vision' | 'image_gen' | 'embedding';
+export type WiredCapability =
+  'chat' | 'tts' | 'stt' | 'vision' | 'image_gen' | 'embedding' | 'decision';
 
 /**
  * STATIC mirror of which providers have a registered adapter, per capability —
@@ -70,6 +73,8 @@ export const WIRED_PROVIDERS: Record<WiredCapability, ReadonlySet<ProviderId>> =
   vision: new Set<ProviderId>(['openai', 'anthropic', 'google', 'xai', 'openrouter']),
   image_gen: new Set<ProviderId>(['openrouter', 'openai', 'xai', 'google', 'huggingface']),
   embedding: new Set<ProviderId>(['openrouter', 'openai', 'google', 'mistral', 'cohere', 'local']),
+  // Typed decisions: only OpenRouter's alpha decisions endpoint today.
+  decision: new Set<ProviderId>(['openrouter']),
 };
 
 function mapFor(capability: WiredCapability): ReadonlyMap<ProviderId, unknown> {
@@ -80,6 +85,7 @@ function mapFor(capability: WiredCapability): ReadonlyMap<ProviderId, unknown> {
     vision: VISION,
     image_gen: IMAGE_GEN,
     embedding: EMBEDDING,
+    decision: DECISION,
   }[capability];
 }
 
@@ -189,6 +195,19 @@ export function listEmbeddingAdapters(): EmbeddingDispatcher[] {
   return Array.from(EMBEDDING.values());
 }
 
+// ─── Decision (typed answers, no prose) ──────────────────────────────
+
+export function registerDecisionAdapter(adapter: DecisionDispatcher): void {
+  DECISION.set(adapter.providerId, adapter);
+}
+
+/** No retry wrapper on purpose: a decision sits IN FRONT of a call the caller
+ *  will make anyway, so a failed decision is simply "no decision" — retrying
+ *  would spend the latency budget the caller was trying to save. */
+export function getDecisionAdapter(providerId: string): DecisionDispatcher | null {
+  return DECISION.get(providerId as ProviderId) ?? null;
+}
+
 // ─── Capability check (used by UI to derive `wired` flag) ────────────
 
 /**
@@ -220,10 +239,7 @@ export function findAdapterCatalogDrift(
   const problems: string[] = [];
   const catalogById = new Map(providers.map((p) => [p.id as string, p.capabilities]));
 
-  function check(
-    label: 'chat' | 'tts' | 'stt' | 'vision' | 'image_gen' | 'embedding',
-    registry: Map<ProviderId, { adapterName: string }>,
-  ): void {
+  function check(label: WiredCapability, registry: Map<ProviderId, { adapterName: string }>): void {
     for (const [providerId, adapter] of registry) {
       const caps = catalogById.get(providerId);
       if (!caps) {
@@ -247,6 +263,7 @@ export function findAdapterCatalogDrift(
   check('vision', VISION);
   check('image_gen', IMAGE_GEN);
   check('embedding', EMBEDDING);
+  check('decision', DECISION);
 
   return problems;
 }

package/src/adapters/types.ts

@@ -864,3 +864,65 @@ export interface EmbeddingDispatcher extends AdapterMeta {
    *  AND as a last-resort if discovery errors. */
   staticCatalog?(): readonly EmbeddingModelInfo[];
 }
+
+// ─── Decision (typed answers, no prose) ─────────────────────────────
+
+/** One question for a decision model. Three shapes, mirroring TypeSafe's
+ *  primitives: `choice` picks one key from `criteria`; `score` places the
+ *  state on an ORDERED rubric (index 0 = lowest); `noul` is a yes/no whose
+ *  answer is the probability of "yes". Write `instructions` as one direct
+ *  question and name the state fields it refers to in backticks — the model
+ *  reads literally, so contrastive criteria ("not for …") pay off. */
+export type DecisionQuestion =
+  | { type: 'choice'; instructions: string; criteria: Record<string, string> }
+  | { type: 'score'; instructions: string; criteria: readonly string[] }
+  | { type: 'noul'; instructions: string; criteria?: { true?: string; false?: string } };
+
+/** One answer. `confidence` (0-1) is the SHAPE of the distribution — 1 when
+ *  all mass sits on one option, 0 when it is flat — and is the number the
+ *  caller gates on; `probabilities` say WHICH options were likely. A `noul`
+ *  has no separate confidence: its probability is the whole answer. */
+export type DecisionAnswer =
+  | {
+      type: 'choice';
+      choice: string;
+      confidence: number;
+      probabilities: Record<string, number>;
+    }
+  | {
+      type: 'score';
+      /** Probability-weighted mean over the rubric indexes (fractional). */
+      score: number;
+      confidence: number;
+      probabilities: Record<string, number>;
+    }
+  | { type: 'noul'; probability: number };
+
+export interface DecisionOptions {
+  apiKey: string;
+  model: string;
+  /** The evidence: a string, a JSON object (preferred — every part has a
+   *  name the questions can point at) or an array. Text only. */
+  state: unknown;
+  questions: Record<string, DecisionQuestion>;
+  /** Ask the provider for zero-data-retention routing and no data
+   *  collection. The state can hold the owner's documents. */
+  zeroDataRetention?: boolean;
+  /** Hard ceiling; the adapter aborts and throws past it. */
+  timeoutMs?: number;
+}
+
+export interface DecisionResult {
+  answers: Record<string, DecisionAnswer>;
+  /** Echo of the model the provider actually served. */
+  model: string;
+  tokensIn?: number;
+  tokensOut?: number;
+  /** Provider-reported USD cost (OpenRouter `usage.cost`). */
+  reportedCostUsd?: number;
+}
+
+export interface DecisionDispatcher extends AdapterMeta {
+  /** One evaluation: all questions answered in one parallel pass. */
+  decide(opts: DecisionOptions): Promise<DecisionResult>;
+}

package/src/providers.ts

@@ -48,7 +48,17 @@ export type ProviderId =
  *
  *  When a new ai_workers kind ships, add its capability here too so
  *  the provider filter knows which providers to expose for that kind. */
-export type ProviderCapability = 'chat' | 'embedding' | 'tts' | 'stt' | 'vision' | 'image_gen';
+export type ProviderCapability =
+  | 'chat'
+  | 'embedding'
+  | 'tts'
+  | 'stt'
+  | 'vision'
+  | 'image_gen'
+  /** Typed decisions (choice / score / yes-no with probabilities, no prose)
+   *  — TypeSafe Jev through OpenRouter's decisions endpoint. Not chat-shaped:
+   *  its own dispatcher, its own endpoint. */
+  | 'decision';
 
 export type Provider = {
   id: ProviderId;
@@ -82,7 +92,7 @@ export const SUPPORTED_PROVIDERS: readonly Provider[] = [
     label: 'OpenRouter',
     description:
       'Aggregator covering OpenAI, Anthropic, Google, Mistral, DeepSeek, and most open models behind one key — plus audio (TTS/STT) and image generation. One key powers chat, memory, voice, and images.',
-    capabilities: ['chat', 'embedding', 'vision', 'tts', 'stt', 'image_gen'],
+    capabilities: ['chat', 'embedding', 'vision', 'tts', 'stt', 'image_gen', 'decision'],
     signupUrl: 'https://openrouter.ai/keys',
     docsUrl: 'https://openrouter.ai/docs',
     isAggregator: true,
@@ -259,4 +269,7 @@ export const CAPABILITY_FOR_KIND: Record<string, ProviderCapability> = {
   // The suggester runs a plain chat-completion to propose one follow-up
   // question after a turn; same 'chat' capability as the narrator.
   suggester: 'chat',
+  // The decider is the first kind whose output is neither prose nor media: a
+  // typed-decision model behind its own endpoint, so its own capability.
+  decider: 'decision',
 };