@absolutejs/voice 0.0.22-beta.481 → 0.0.22-beta.483

package/dist/index.d.ts

@@ -71,10 +71,14 @@ export { createVoiceSessionListRoutes, createVoiceSessionReplayHTMLHandler, crea
 export { createVoiceAgent, createVoiceAgentSquad, createVoiceAgentTool, } from "./agent";
 export { createAIVoiceModel } from "./aiVoiceModel";
 export type { CreateAIVoiceModelOptions } from "./aiVoiceModel";
+export { createVoiceAIJudgeCompletion, createVoiceLLMJudge, } from "./llmJudge";
+export type { CreateVoiceAIJudgeCompletionOptions, CreateVoiceLLMJudgeOptions, VoiceLLMJudge, VoiceLLMJudgeCompletion, VoiceLLMJudgeCriterionVerdict, VoiceLLMJudgeInput, VoiceLLMJudgeRubric, VoiceLLMJudgeRubricCriterion, VoiceLLMJudgeVerdict, } from "./llmJudge";
 export { DEFAULT_VOICE_REDACTION_PATTERNS, createVoiceTranscriptRedactor, redactVoiceTranscript, } from "./redaction";
 export type { CreateVoiceTranscriptRedactorOptions, VoiceRedactionPattern, VoiceTranscriptRedactor, } from "./redaction";
 export { DEFAULT_VOICE_PRICE_BOOK, createVoiceCostAccountant, } from "./costAccounting";
 export type { CreateVoiceCostAccountantOptions, VoiceCostAccountant, VoiceCostBreakdown, VoiceCostLLMRecord, VoiceCostSTTRecord, VoiceCostTTSRecord, VoiceCostTelephonyRecord, VoicePriceBook, VoiceProviderRates, } from "./costAccounting";
+export { createPunctuationSemanticTurnDetector, createRegexSemanticTurnDetector, } from "./semanticTurn";
+export type { CreatePunctuationSemanticTurnDetectorOptions, CreateRegexSemanticTurnDetectorOptions, VoiceSemanticTurnDetector, VoiceSemanticTurnInput, VoiceSemanticTurnVerdict, } from "./semanticTurn";
 export { createMonologueAMDDetector } from "./amdDetector";
 export type { MonologueAMDDetectorOptions, VoiceAMDDetector, VoiceAMDDetectorInput, VoiceAMDVerdict, } from "./amdDetector";
 export { createVoiceRAGTool } from "./ragTool";

package/dist/index.js

@@ -4786,6 +4786,18 @@ var createVoiceSession = (options) => {
       session,
       type: "turn.transcript"
     });
+    if (options.semanticTurnDetector) {
+      const verdict = await Promise.resolve(options.semanticTurnDetector.evaluate({
+        lastFinalTranscript: transcript,
+        partialText: session.currentTurn.partialText,
+        silenceMs: session.currentTurn.silenceStartedAt !== undefined ? Date.now() - session.currentTurn.silenceStartedAt : 0,
+        transcripts: session.currentTurn.transcripts
+      }));
+      if (verdict.endOfTurn) {
+        clearSilenceTimer();
+        await requestTurnCommit("vendor");
+      }
+    }
   };
   const resumePendingTurnCommit = (session) => {
     const pendingText = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText, {
@@ -34981,6 +34993,134 @@ var createAIVoiceModel = (options) => ({
     return output;
   }
 });
+// src/llmJudge.ts
+var DEFAULT_SYSTEM_PROMPT = "You are an impartial evaluator scoring a voice-agent transcript against a rubric. " + "For each criterion, decide pass/fail and give a one-sentence rationale grounded in the transcript. " + 'Respond with strict JSON: {"criteria":[{"criterionId":"\u2026","passed":true,"rationale":"\u2026"}],"summary":"\u2026"}.';
+var buildPrompt = (rubric, input) => {
+  const criteriaBlock = rubric.criteria.map((criterion) => `- ${criterion.id}${criterion.required ? " (required)" : ""}: ${criterion.description}`).join(`
+`);
+  const metadataBlock = input.metadata ? `
+Metadata:
+${JSON.stringify(input.metadata, null, 2)}
+` : "";
+  return `Rubric criteria:
+${criteriaBlock}
+${metadataBlock}
+Transcript:
+${input.transcript}
+
+Return JSON only.`;
+};
+var extractJson = (raw) => {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    throw new Error("LLM judge returned an empty response");
+  }
+  const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(trimmed);
+  const candidate = fenced ? fenced[1].trim() : trimmed;
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    const start = candidate.indexOf("{");
+    const end = candidate.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      return JSON.parse(candidate.slice(start, end + 1));
+    }
+    throw new Error(`LLM judge response was not valid JSON: ${raw.slice(0, 200)}`);
+  }
+};
+var parseCriteria = (payload, rubric) => {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("LLM judge response is not a JSON object");
+  }
+  const root = payload;
+  const criteriaRaw = root.criteria;
+  if (!Array.isArray(criteriaRaw)) {
+    throw new Error("LLM judge response is missing the 'criteria' array");
+  }
+  const verdictById = new Map;
+  for (const entry of criteriaRaw) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const record = entry;
+    const criterionId = typeof record.criterionId === "string" ? record.criterionId : typeof record.id === "string" ? record.id : undefined;
+    if (!criterionId) {
+      continue;
+    }
+    verdictById.set(criterionId, {
+      criterionId,
+      passed: record.passed === true,
+      rationale: typeof record.rationale === "string" ? record.rationale : ""
+    });
+  }
+  const criteria = rubric.criteria.map((criterion) => verdictById.get(criterion.id) ?? {
+    criterionId: criterion.id,
+    passed: false,
+    rationale: "Judge did not return a verdict for this criterion."
+  });
+  return {
+    criteria,
+    summary: typeof root.summary === "string" ? root.summary : undefined
+  };
+};
+var scoreVerdict = (rubric, criteria) => {
+  const totalWeight = rubric.criteria.reduce((sum, criterion) => sum + (criterion.weight ?? 1), 0);
+  if (totalWeight === 0) {
+    return { passed: false, score: 0 };
+  }
+  const weightById = new Map(rubric.criteria.map((criterion) => [criterion.id, criterion.weight ?? 1]));
+  const requiredIds = new Set(rubric.criteria.filter((criterion) => criterion.required).map((criterion) => criterion.id));
+  let earned = 0;
+  let allRequiredPassed = true;
+  for (const verdict of criteria) {
+    if (verdict.passed) {
+      earned += weightById.get(verdict.criterionId) ?? 1;
+    } else if (requiredIds.has(verdict.criterionId)) {
+      allRequiredPassed = false;
+    }
+  }
+  const score = earned / totalWeight;
+  const minPassScore = rubric.minPassScore ?? 1;
+  return {
+    passed: allRequiredPassed && score >= minPassScore,
+    score
+  };
+};
+var createVoiceLLMJudge = (options) => ({
+  evaluate: async (input) => {
+    const prompt = buildPrompt(options.rubric, input);
+    const raw = await options.completion({
+      prompt,
+      systemPrompt: options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT
+    });
+    const parsed = parseCriteria(extractJson(raw), options.rubric);
+    const { passed, score } = scoreVerdict(options.rubric, parsed.criteria);
+    return {
+      criteria: parsed.criteria,
+      passed,
+      score,
+      summary: parsed.summary
+    };
+  },
+  rubric: options.rubric
+});
+var createVoiceAIJudgeCompletion = (options) => async ({ prompt, systemPrompt }) => {
+  const messages = [
+    { content: prompt, role: "user" }
+  ];
+  const stream = options.provider.stream({
+    messages,
+    model: options.model,
+    systemPrompt
+  });
+  let buffered = "";
+  for await (const chunk of stream) {
+    if (chunk.type === "text") {
+      buffered += chunk.content;
+    }
+  }
+  return buffered;
+};
 // src/redaction.ts
 var DEFAULT_VOICE_REDACTION_PATTERNS = [
   {
@@ -35164,6 +35304,76 @@ var createVoiceCostAccountant = (options = {}) => {
     })
   };
 };
+// src/semanticTurn.ts
+var DEFAULT_END_PUNCTUATION = [".", "?", "!"];
+var DEFAULT_FILLER_WORDS = [
+  "uh",
+  "um",
+  "er",
+  "ah",
+  "like",
+  "you know",
+  "i mean",
+  "well",
+  "so"
+];
+var stripTerminalPunctuation = (text) => text.replace(/[\s.?!]+$/u, "").trim();
+var createPunctuationSemanticTurnDetector = (options = {}) => {
+  const endPunctuation = options.endPunctuation ?? DEFAULT_END_PUNCTUATION;
+  const fillerWords = (options.fillerWords ?? DEFAULT_FILLER_WORDS).map((word) => word.toLowerCase());
+  const minPartialWords = options.minPartialWords ?? 2;
+  return {
+    evaluate: ({ lastFinalTranscript, partialText }) => {
+      const candidate = partialText.trim().length > 0 ? partialText : lastFinalTranscript?.text ?? "";
+      const trimmed = candidate.trim();
+      if (!trimmed) {
+        return { endOfTurn: false, reason: "empty" };
+      }
+      const wordCount = trimmed.split(/\s+/u).filter(Boolean).length;
+      if (wordCount < minPartialWords) {
+        return { endOfTurn: false, reason: "below-min-words" };
+      }
+      const lastChar = trimmed.at(-1);
+      const endsWithTerminal = typeof lastChar === "string" && endPunctuation.includes(lastChar);
+      if (!endsWithTerminal) {
+        return { endOfTurn: false, reason: "no-terminal-punctuation" };
+      }
+      const lastWord = stripTerminalPunctuation(trimmed).split(/\s+/u).at(-1)?.toLowerCase();
+      if (lastWord && fillerWords.includes(lastWord)) {
+        return { endOfTurn: false, reason: "trailing-filler" };
+      }
+      return {
+        confidence: 0.9,
+        endOfTurn: true,
+        reason: "terminal-punctuation"
+      };
+    }
+  };
+};
+var createRegexSemanticTurnDetector = (options) => {
+  const minPartialWords = options.minPartialWords ?? 2;
+  return {
+    evaluate: ({ lastFinalTranscript, partialText }) => {
+      const candidate = partialText.trim().length > 0 ? partialText : lastFinalTranscript?.text ?? "";
+      const trimmed = candidate.trim();
+      if (!trimmed) {
+        return { endOfTurn: false, reason: "empty" };
+      }
+      const wordCount = trimmed.split(/\s+/u).filter(Boolean).length;
+      if (wordCount < minPartialWords) {
+        return { endOfTurn: false, reason: "below-min-words" };
+      }
+      const match = options.endPattern.exec(trimmed);
+      if (!match) {
+        return { endOfTurn: false, reason: "pattern-miss" };
+      }
+      return {
+        endOfTurn: true,
+        reason: "pattern-match"
+      };
+    }
+  };
+};
 // src/amdDetector.ts
 var createMonologueAMDDetector = (options = {}) => {
   const minMonologueMs = options.minMonologueMs ?? 8000;
@@ -46252,6 +46462,7 @@ export {
   createVoiceLinearIssueUpdateSink,
   createVoiceLinearIssueSyncSinks,
   createVoiceLinearIssueSink,
+  createVoiceLLMJudge,
   createVoiceIntegrationSinkWorkerLoop,
   createVoiceIntegrationSinkWorker,
   createVoiceIntegrationHTTPSink,
@@ -46347,6 +46558,7 @@ export {
   createVoiceAgentTool,
   createVoiceAgentSquad,
   createVoiceAgent,
+  createVoiceAIJudgeCompletion,
   createTwilioVoiceRoutes,
   createTwilioVoiceResponse,
   createTwilioMediaStreamBridge,
@@ -46359,6 +46571,8 @@ export {
   createStoredVoiceExternalObjectMap,
   createStoredVoiceCallReviewArtifact,
   createRiskyTurnCorrectionHandler,
+  createRegexSemanticTurnDetector,
+  createPunctuationSemanticTurnDetector,
   createPlivoVoiceRoutes,
   createPlivoVoiceResponse,
   createPlivoMediaStreamBridge,

package/dist/llmJudge.d.ts

@@ -0,0 +1,45 @@
+import type { AIProviderConfig } from "@absolutejs/ai";
+export type VoiceLLMJudgeRubricCriterion = {
+    description: string;
+    id: string;
+    required?: boolean;
+    weight?: number;
+};
+export type VoiceLLMJudgeRubric = {
+    criteria: VoiceLLMJudgeRubricCriterion[];
+    minPassScore?: number;
+};
+export type VoiceLLMJudgeCriterionVerdict = {
+    criterionId: string;
+    passed: boolean;
+    rationale: string;
+};
+export type VoiceLLMJudgeVerdict = {
+    criteria: VoiceLLMJudgeCriterionVerdict[];
+    passed: boolean;
+    score: number;
+    summary?: string;
+};
+export type VoiceLLMJudgeInput = {
+    metadata?: Record<string, unknown>;
+    transcript: string;
+};
+export type VoiceLLMJudgeCompletion = (input: {
+    prompt: string;
+    systemPrompt?: string;
+}) => Promise<string>;
+export type CreateVoiceLLMJudgeOptions = {
+    completion: VoiceLLMJudgeCompletion;
+    rubric: VoiceLLMJudgeRubric;
+    systemPrompt?: string;
+};
+export type VoiceLLMJudge = {
+    evaluate: (input: VoiceLLMJudgeInput) => Promise<VoiceLLMJudgeVerdict>;
+    rubric: VoiceLLMJudgeRubric;
+};
+export declare const createVoiceLLMJudge: (options: CreateVoiceLLMJudgeOptions) => VoiceLLMJudge;
+export type CreateVoiceAIJudgeCompletionOptions = {
+    model: string;
+    provider: AIProviderConfig;
+};
+export declare const createVoiceAIJudgeCompletion: (options: CreateVoiceAIJudgeCompletionOptions) => VoiceLLMJudgeCompletion;

package/dist/semanticTurn.d.ts

@@ -0,0 +1,27 @@
+import type { Transcript } from "./types";
+export type VoiceSemanticTurnInput = {
+    audioLevel?: number;
+    lastFinalTranscript?: Transcript;
+    partialText: string;
+    silenceMs: number;
+    transcripts: Transcript[];
+};
+export type VoiceSemanticTurnVerdict = {
+    confidence?: number;
+    endOfTurn: boolean;
+    reason?: string;
+};
+export type VoiceSemanticTurnDetector = {
+    evaluate: (input: VoiceSemanticTurnInput) => Promise<VoiceSemanticTurnVerdict> | VoiceSemanticTurnVerdict;
+};
+export type CreatePunctuationSemanticTurnDetectorOptions = {
+    endPunctuation?: ReadonlyArray<string>;
+    fillerWords?: ReadonlyArray<string>;
+    minPartialWords?: number;
+};
+export declare const createPunctuationSemanticTurnDetector: (options?: CreatePunctuationSemanticTurnDetectorOptions) => VoiceSemanticTurnDetector;
+export type CreateRegexSemanticTurnDetectorOptions = {
+    endPattern: RegExp;
+    minPartialWords?: number;
+};
+export declare const createRegexSemanticTurnDetector: (options: CreateRegexSemanticTurnDetectorOptions) => VoiceSemanticTurnDetector;

package/dist/testing/index.js

@@ -6754,6 +6754,18 @@ var createVoiceSession = (options) => {
       session,
       type: "turn.transcript"
     });
+    if (options.semanticTurnDetector) {
+      const verdict = await Promise.resolve(options.semanticTurnDetector.evaluate({
+        lastFinalTranscript: transcript,
+        partialText: session.currentTurn.partialText,
+        silenceMs: session.currentTurn.silenceStartedAt !== undefined ? Date.now() - session.currentTurn.silenceStartedAt : 0,
+        transcripts: session.currentTurn.transcripts
+      }));
+      if (verdict.endOfTurn) {
+        clearSilenceTimer();
+        await requestTurnCommit("vendor");
+      }
+    }
   };
   const resumePendingTurnCommit = (session) => {
     const pendingText = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText, {

package/dist/types.d.ts

@@ -731,6 +731,7 @@ export type CreateVoiceSessionOptions<TContext = unknown, TSession extends Voice
         provider?: string;
     };
     redact?: import("./redaction").VoiceTranscriptRedactor;
+    semanticTurnDetector?: import("./semanticTurn").VoiceSemanticTurnDetector;
     reconnect: Required<VoiceReconnectConfig>;
     phraseHints?: VoicePhraseHint[];
     sessionMetadata?: Record<string, unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absolutejs/voice",
-  "version": "0.0.22-beta.481",
+  "version": "0.0.22-beta.483",
   "description": "Voice primitives and Elysia plugin for AbsoluteJS",
   "repository": {
     "type": "git",