@backbay/glia-agent 0.1.0

package/dist/audio.d.ts

@@ -0,0 +1,163 @@
+import { s as SpeechSynthesisProvider, o as AudioVerifier, V as VoiceCatalog, i as AudioPolicy, h as AudioPlannerSignals, j as AudioProof, t as SpeechSynthesisRequest, u as SpeechSynthesisResult, O as OverlayPhraseLibrary, r as OverlayToken } from './httpSpeechSynthesisProvider-CIR7L2Zr.js';
+export { A as AudioArtifact, a as AudioFormat, b as AudioFormatSchema, c as AudioGateResult, d as AudioGates, e as AudioPlannerCognitionInput, f as AudioPlannerInput, g as AudioPlannerMode, k as AudioProofInput, l as AudioProofOutput, m as AudioProofSchema, n as AudioProofValidationResult, D as DEFAULT_OVERLAY_PHRASES, E as DEFAULT_TARGET_AVO, F as EvidenceRef, H as HttpSpeechSynthesisProvider, p as HttpSpeechSynthesisProviderOptions, q as HttpSynthesisResponse, S as SpeechControls, v as VoiceCatalogEntry, w as VoiceLicenseCategory, x as VoiceLicenseCategorySchema, G as clamp01, I as createTraceId, y as pickOverlayPhrase, z as planSpeech, B as planSpeechFromCognition, C as validateAudioProof } from './httpSpeechSynthesisProvider-CIR7L2Zr.js';
+import { A as AVO } from './types-B0jyNVTH.js';
+import 'zod';
+import './types-CRp9rbx0.js';
+
+interface UseAudioPlayerOptions {
+    volume?: number;
+    onEnded?: () => void;
+    onError?: (error: Error) => void;
+}
+interface UseAudioPlayerReturn {
+    isPlaying: boolean;
+    error: string | null;
+    play: (source: Blob | string) => Promise<void>;
+    stop: () => void;
+    audioElement: HTMLAudioElement | null;
+}
+declare function useAudioPlayer(options?: UseAudioPlayerOptions): UseAudioPlayerReturn;
+
+interface UseBargeInOptions {
+    /**
+     * Microphone or remote user stream.
+     * You must request user consent in the host app (getUserMedia) and pass it in.
+     */
+    stream: MediaStream | null;
+    enabled?: boolean;
+    /**
+     * RMS threshold in 0..1.
+     * Typical values are small; start around 0.02 and calibrate per environment.
+     */
+    threshold?: number;
+    /**
+     * Keep "speaking" true for this long after signal drops below threshold.
+     */
+    hangoverMs?: number;
+    /**
+     * Called on the rising edge (silence -> speaking).
+     */
+    onBargeIn?: () => void;
+}
+interface UseBargeInReturn {
+    isUserSpeaking: boolean;
+    levelRms: number;
+}
+declare function useBargeIn(options: UseBargeInOptions): UseBargeInReturn;
+
+interface UseSpeechSynthesisOptions {
+    provider: SpeechSynthesisProvider;
+    verifier?: AudioVerifier;
+    voices: VoiceCatalog;
+    policy: AudioPolicy;
+    signals?: AudioPlannerSignals;
+    defaults?: {
+        voiceId?: string;
+        groundedVoiceTag?: string;
+        defaultVoiceTag?: string;
+        temperature?: number;
+    };
+    /**
+     * If provided, enables barge-in (user speech cancels synthesis and playback).
+     */
+    bargeIn?: {
+        stream: MediaStream | null;
+        threshold?: number;
+        hangoverMs?: number;
+    };
+    /**
+     * Playback volume 0..1
+     */
+    volume?: number;
+    /**
+     * Controls when verification happens.
+     *
+     * - "before_playback": verify first; only play if verified (best for high-trust lanes)
+     * - "after_playback": play immediately; verify in background (best UX when trust allows)
+     * - "never": do not verify (not recommended)
+     *
+     * Default: derived from policy (`requireProofBeforePlayback`).
+     */
+    verificationMode?: 'before_playback' | 'after_playback' | 'never';
+    onProof?: (proof: AudioProof) => void;
+    onBargeIn?: () => void;
+    onError?: (error: Error) => void;
+}
+interface SpeakOptions {
+    runId?: string;
+    language?: string;
+    targetAffect?: AVO;
+}
+interface UseSpeechSynthesisReturn {
+    isSynthesizing: boolean;
+    isSpeaking: boolean;
+    error: string | null;
+    lastRequest: SpeechSynthesisRequest | null;
+    lastResult: SpeechSynthesisResult | null;
+    lastProof: AudioProof | null;
+    speak: (text: string, options?: SpeakOptions) => Promise<void>;
+    cancel: () => void;
+}
+declare function useSpeechSynthesis(options: UseSpeechSynthesisOptions): UseSpeechSynthesisReturn;
+
+interface UseAudioOverlayOptions {
+    provider: SpeechSynthesisProvider;
+    verifier?: AudioVerifier;
+    voices: VoiceCatalog;
+    policy: AudioPolicy;
+    signals?: AudioPlannerSignals;
+    defaults?: {
+        voiceId?: string;
+        groundedVoiceTag?: string;
+        defaultVoiceTag?: string;
+        temperature?: number;
+    };
+    phrases?: Partial<OverlayPhraseLibrary>;
+    bargeIn?: {
+        stream: MediaStream | null;
+        threshold?: number;
+        hangoverMs?: number;
+    };
+    volume?: number;
+    verificationMode?: 'before_playback' | 'after_playback' | 'never';
+    onProof?: (proof: AudioProof) => void;
+    onBargeIn?: () => void;
+    onError?: (error: Error) => void;
+}
+interface OverlaySpeakOptions extends SpeakOptions {
+    targetAffect?: AVO;
+}
+interface UseAudioOverlayReturn {
+    isSynthesizing: boolean;
+    isSpeaking: boolean;
+    error: string | null;
+    lastProof: AudioProof | null;
+    speakToken: (token: OverlayToken, options?: OverlaySpeakOptions) => Promise<void>;
+    speakText: (text: string, options?: OverlaySpeakOptions) => Promise<void>;
+    cancel: () => void;
+}
+declare function useAudioOverlay(options: UseAudioOverlayOptions): UseAudioOverlayReturn;
+
+interface UseHybridSpeechOptions {
+    main: UseSpeechSynthesisOptions;
+    overlay: UseAudioOverlayOptions & {
+        enabled?: boolean;
+    };
+    /**
+     * If true, automatically stops overlay playback when main speech starts.
+     */
+    stopOverlayOnMainSpeak?: boolean;
+}
+interface UseHybridSpeechReturn {
+    main: UseSpeechSynthesisReturn;
+    overlay: UseAudioOverlayReturn;
+    /**
+     * Convenience: play a quick acknowledgement (overlay) while synthesizing main speech.
+     * Overlay is best-effort and will not block main speech if it fails.
+     */
+    speakWithAck: (text: string, options?: SpeakOptions) => Promise<void>;
+    cancelAll: () => void;
+}
+declare function useHybridSpeech(options: UseHybridSpeechOptions): UseHybridSpeechReturn;
+
+export { AudioPlannerSignals, AudioPolicy, AudioProof, AudioVerifier, OverlayPhraseLibrary, type OverlaySpeakOptions, OverlayToken, type SpeakOptions, SpeechSynthesisProvider, SpeechSynthesisRequest, SpeechSynthesisResult, type UseAudioOverlayOptions, type UseAudioOverlayReturn, type UseAudioPlayerOptions, type UseAudioPlayerReturn, type UseBargeInOptions, type UseBargeInReturn, type UseHybridSpeechOptions, type UseHybridSpeechReturn, type UseSpeechSynthesisOptions, type UseSpeechSynthesisReturn, VoiceCatalog, useAudioOverlay, useAudioPlayer, useBargeIn, useHybridSpeech, useSpeechSynthesis };

package/dist/audio.js

@@ -0,0 +1,39 @@
+import {
+  AudioFormatSchema,
+  AudioProofSchema,
+  DEFAULT_OVERLAY_PHRASES,
+  DEFAULT_TARGET_AVO,
+  HttpSpeechSynthesisProvider,
+  VoiceLicenseCategorySchema,
+  clamp01,
+  createTraceId,
+  pickOverlayPhrase,
+  planSpeech,
+  planSpeechFromCognition,
+  useAudioOverlay,
+  useAudioPlayer,
+  useBargeIn,
+  useHybridSpeech,
+  useSpeechSynthesis,
+  validateAudioProof
+} from "./chunk-XE2IVCKJ.js";
+export {
+  AudioFormatSchema,
+  AudioProofSchema,
+  DEFAULT_OVERLAY_PHRASES,
+  DEFAULT_TARGET_AVO,
+  HttpSpeechSynthesisProvider,
+  VoiceLicenseCategorySchema,
+  clamp01,
+  createTraceId,
+  pickOverlayPhrase,
+  planSpeech,
+  planSpeechFromCognition,
+  useAudioOverlay,
+  useAudioPlayer,
+  useBargeIn,
+  useHybridSpeech,
+  useSpeechSynthesis,
+  validateAudioProof
+};
+//# sourceMappingURL=audio.js.map

package/dist/audio.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-LLOGBVQT.js

@@ -0,0 +1,445 @@
+// src/cognition/types.ts
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+var DEFAULT_AVO = { arousal: 0.25, valence: 0.6, openness: 0.35 };
+function createInitialCognitionState(overrides) {
+  return {
+    mode: "idle",
+    attention: 0.3,
+    workload: 0,
+    timePressure: 0,
+    planDrift: 0,
+    costPressure: 0,
+    risk: 0,
+    uncertainty: 0.2,
+    confidence: 0.8,
+    errorStress: 0,
+    personaAnchor: 1,
+    personaDriftRisk: 0,
+    moodAVO: { ...DEFAULT_AVO },
+    emotionAVO: { ...DEFAULT_AVO },
+    ...overrides
+  };
+}
+
+// src/cognition/schema.ts
+import { z } from "zod";
+var Signal01 = z.number().min(0).max(1);
+var CognitiveModeSchema = z.enum([
+  "idle",
+  "listening",
+  "deliberating",
+  "acting",
+  "explaining",
+  "recovering",
+  "blocked"
+]);
+var CognitiveSubmodeSchema = z.enum([
+  "reading",
+  "searching",
+  "verifying",
+  "waiting",
+  "writing",
+  "tool_call"
+]);
+var AVOSchema = z.object({
+  arousal: Signal01,
+  valence: Signal01,
+  openness: Signal01
+});
+var TrapWarningSchema = z.object({
+  stateId: z.string(),
+  reason: z.string(),
+  recommendation: z.string(),
+  severity: z.enum(["info", "warning", "danger"]).optional()
+});
+var DetailedBalanceSchema = z.object({
+  chi2PerNdf: z.number(),
+  passed: z.boolean(),
+  threshold: z.number()
+});
+var DynamicsStateSchema = z.object({
+  potentialV: z.number().optional(),
+  actionRate: Signal01.optional(),
+  detailedBalance: DetailedBalanceSchema.optional(),
+  traps: z.array(TrapWarningSchema).optional()
+});
+var PersonalityConfigSchema = z.object({
+  style: z.enum(["professional", "casual", "terse", "verbose"]),
+  riskTolerance: z.enum(["conservative", "moderate", "aggressive"]),
+  autonomy: z.enum(["low", "medium", "high", "full"])
+});
+var PolicyConfigSchema = z.object({
+  safetyMode: z.boolean(),
+  trustTier: z.string().optional()
+});
+var CognitionStateSchema = z.object({
+  mode: CognitiveModeSchema,
+  submode: CognitiveSubmodeSchema.optional(),
+  focusRunId: z.string().optional(),
+  attention: Signal01,
+  workload: Signal01,
+  timePressure: Signal01,
+  planDrift: Signal01,
+  costPressure: Signal01,
+  risk: Signal01,
+  uncertainty: Signal01,
+  confidence: Signal01,
+  errorStress: Signal01,
+  personaAnchor: Signal01,
+  personaDriftRisk: Signal01,
+  personaStyle: z.array(z.string()).optional(),
+  dynamics: DynamicsStateSchema.optional(),
+  personality: PersonalityConfigSchema.optional(),
+  policy: PolicyConfigSchema.optional(),
+  moodAVO: AVOSchema,
+  emotionAVO: AVOSchema
+});
+var CognitionSnapshotSchema = z.object({
+  version: z.literal("1.0"),
+  timestamp: z.number(),
+  state: CognitionStateSchema,
+  recentEvents: z.array(
+    z.object({
+      t: z.number(),
+      event: z.record(z.unknown())
+    })
+  ).optional()
+});
+function validateCognitionSnapshot(input) {
+  const result = CognitionSnapshotSchema.safeParse(input);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+
+// src/cognition/reducers.ts
+var MODE_TRANSITION_MAP = {
+  "ui.input_received": "listening",
+  "ui.user_idle": "idle",
+  "ui.interrupt": "listening",
+  "run.started": "deliberating",
+  "run.completed": "idle",
+  "run.event": "deliberating"
+};
+var DECAY_RATES = {
+  errorStress: 0.1,
+  // Decays 10% per second
+  timePressure: 0.05,
+  // Decays 5% per second
+  planDrift: 0.08
+  // Decays 8% per second
+};
+function reduceSignals(state, signals) {
+  return {
+    ...state,
+    attention: signals.attention !== void 0 ? clamp01(signals.attention) : state.attention,
+    workload: signals.workload !== void 0 ? clamp01(signals.workload) : state.workload,
+    risk: signals.risk !== void 0 ? clamp01(signals.risk) : state.risk,
+    timePressure: signals.timePressure !== void 0 ? clamp01(signals.timePressure) : state.timePressure,
+    errorStress: signals.errorStress !== void 0 ? clamp01(signals.errorStress) : state.errorStress,
+    planDrift: signals.planDrift !== void 0 ? clamp01(signals.planDrift) : state.planDrift,
+    costPressure: signals.costPressure !== void 0 ? clamp01(signals.costPressure) : state.costPressure,
+    uncertainty: signals.uncertainty !== void 0 ? clamp01(signals.uncertainty) : state.uncertainty,
+    confidence: signals.confidence !== void 0 ? clamp01(signals.confidence) : state.confidence
+  };
+}
+function reduceDynamicsUpdate(state, dynamics) {
+  return {
+    ...state,
+    dynamics
+  };
+}
+function reducePolicyUpdate(state, policy, personality) {
+  return {
+    ...state,
+    policy: policy ?? state.policy,
+    personality: personality ?? state.personality
+  };
+}
+function reduceModeTransition(state, event) {
+  const trigger = event.type;
+  const newMode = MODE_TRANSITION_MAP[trigger];
+  if (!newMode) {
+    return state;
+  }
+  let focusRunId = state.focusRunId;
+  let errorStress = state.errorStress;
+  let mode = newMode;
+  if (event.type === "run.started") {
+    focusRunId = event.runId;
+  } else if (event.type === "run.completed") {
+    focusRunId = void 0;
+    if (!event.success) {
+      errorStress = clamp01(state.errorStress + 0.2);
+      mode = "recovering";
+    }
+  } else if (event.type === "run.event") {
+    focusRunId = event.runId;
+  }
+  return {
+    ...state,
+    mode,
+    focusRunId,
+    errorStress
+  };
+}
+function reduceDecay(state, deltaMs) {
+  const deltaSec = deltaMs / 1e3;
+  const errorStress = clamp01(
+    state.errorStress * Math.exp(-DECAY_RATES.errorStress * deltaSec)
+  );
+  const timePressure = clamp01(
+    state.timePressure * Math.exp(-DECAY_RATES.timePressure * deltaSec)
+  );
+  const planDrift = clamp01(
+    state.planDrift * Math.exp(-DECAY_RATES.planDrift * deltaSec)
+  );
+  return {
+    ...state,
+    errorStress,
+    timePressure,
+    planDrift
+  };
+}
+function reduceEvent(state, event) {
+  switch (event.type) {
+    case "signals.update":
+      return reduceSignals(state, event.signals);
+    case "intensity.update":
+      return reduceSignals(state, event.values);
+    case "dynamics.update":
+      return reduceDynamicsUpdate(state, event.dynamics);
+    case "policy.update":
+      return reducePolicyUpdate(state, event.policy, event.personality);
+    case "tick":
+      return reduceDecay(state, event.deltaMs);
+    case "ui.input_received":
+    case "ui.user_idle":
+    case "ui.interrupt":
+    case "run.started":
+    case "run.completed":
+    case "run.event":
+      return reduceModeTransition(state, event);
+    case "text.user_message": {
+      const categories = event.categories ?? [];
+      const driftRisk = categories.includes("meta_reflection") ? 0.3 : categories.includes("vulnerable_disclosure") ? 0.4 : 0;
+      const newPersonaDriftRisk = clamp01(
+        state.personaDriftRisk * 0.7 + driftRisk * 0.3
+      );
+      return {
+        ...state,
+        mode: "listening",
+        personaDriftRisk: newPersonaDriftRisk
+      };
+    }
+    default: {
+      const _exhaustive = event;
+      return state;
+    }
+  }
+}
+
+// src/cognition/controller.ts
+var MODE_TO_ANCHOR = {
+  idle: "idle",
+  listening: "listening",
+  deliberating: "thinking",
+  acting: "focused",
+  explaining: "explaining",
+  recovering: "recovering",
+  blocked: "concerned"
+};
+var MODE_TO_AVO = {
+  idle: { arousal: 0.25, valence: 0.6, openness: 0.35 },
+  listening: { arousal: 0.45, valence: 0.7, openness: 0.05 },
+  deliberating: { arousal: 0.6, valence: 0.6, openness: 0.4 },
+  acting: { arousal: 0.7, valence: 0.7, openness: 0.5 },
+  explaining: { arousal: 0.55, valence: 0.8, openness: 0.85 },
+  recovering: { arousal: 0.4, valence: 0.45, openness: 0.4 },
+  blocked: { arousal: 0.55, valence: 0.3, openness: 0.3 }
+};
+var CognitionController = class {
+  _state;
+  _listeners = /* @__PURE__ */ new Map();
+  _disposed = false;
+  constructor(options = {}) {
+    this._state = createInitialCognitionState(options.initial);
+  }
+  /**
+   * Get current cognition state
+   */
+  getState() {
+    return { ...this._state };
+  }
+  /**
+   * Get the emotion target for the current cognitive state
+   * Returns anchor state and AVO values adjusted by signals
+   */
+  getEmotionTarget() {
+    const anchor = MODE_TO_ANCHOR[this._state.mode];
+    const baseAVO = MODE_TO_AVO[this._state.mode];
+    const avo = this._adjustAVOBySignals(baseAVO);
+    return { anchor, avo };
+  }
+  /**
+   * Get emotion bridge - derives anchor and AVO from cognitive state
+   * @deprecated Use getEmotionTarget() instead
+   */
+  getEmotionBridge() {
+    const target = this.getEmotionTarget();
+    return { anchor: target.anchor, avo: target.avo };
+  }
+  /**
+   * Handle a cognition event and update state
+   */
+  handleEvent(event) {
+    if (this._disposed) return;
+    const prevMode = this._state.mode;
+    this._state = reduceEvent(this._state, event);
+    if (this._state.mode !== prevMode) {
+      this._emitEvent("modeChange", { from: prevMode, to: this._state.mode });
+    }
+    this._emitEvent("change", this._state);
+  }
+  /**
+   * Process an event and update state
+   * @deprecated Use handleEvent() instead
+   */
+  emit(event) {
+    this.handleEvent(event);
+  }
+  /**
+   * Update tick - call each frame with delta time in milliseconds
+   * Applies time-based decay to stress signals
+   */
+  tick(deltaMs) {
+    if (this._disposed) return;
+    const prevState = this._state;
+    this._state = reduceDecay(this._state, deltaMs);
+    if (prevState.errorStress !== this._state.errorStress || prevState.timePressure !== this._state.timePressure || prevState.planDrift !== this._state.planDrift) {
+      this._emitEvent("change", this._state);
+    }
+  }
+  /**
+   * Subscribe to controller events
+   * Returns unsubscribe function
+   */
+  on(event, handler) {
+    if (!this._listeners.has(event)) {
+      this._listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this._listeners.get(event).add(handler);
+    return () => {
+      this._listeners.get(event)?.delete(handler);
+    };
+  }
+  /**
+   * Dispose controller and clean up resources
+   */
+  dispose() {
+    this._disposed = true;
+    this._listeners.clear();
+  }
+  /**
+   * Adjust AVO values based on current signal levels
+   */
+  _adjustAVOBySignals(baseAVO) {
+    const { errorStress, workload, timePressure, uncertainty, confidence, personaDriftRisk } = this._state;
+    const arousalBoost = workload * 0.2 + timePressure * 0.15 + errorStress * 0.1;
+    const valenceDrops = errorStress * 0.3 + uncertainty * 0.15;
+    const valenceBoost = (confidence - 0.5) * 0.2;
+    const opennessDrop = personaDriftRisk * 0.3;
+    return {
+      arousal: Math.max(0, Math.min(1, baseAVO.arousal + arousalBoost)),
+      valence: Math.max(0, Math.min(1, baseAVO.valence - valenceDrops + valenceBoost)),
+      openness: Math.max(0, Math.min(1, baseAVO.openness - opennessDrop))
+    };
+  }
+  _emitEvent(event, data) {
+    this._listeners.get(event)?.forEach((handler) => handler(data));
+  }
+};
+
+// src/cognition/hooks/useCognition.ts
+import { useState, useEffect, useCallback, useRef } from "react";
+function useCognition(options = {}) {
+  const { initial, onChange, autoTick = true } = options;
+  const controllerRef = useRef(null);
+  if (!controllerRef.current) {
+    controllerRef.current = new CognitionController({ initial });
+  }
+  const controller = controllerRef.current;
+  const [state, setState] = useState(controller.getState());
+  const [emotion, setEmotion] = useState(
+    controller.getEmotionTarget()
+  );
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  useEffect(() => {
+    const unsub = controller.on("change", (newState) => {
+      setState({ ...newState });
+      setEmotion(controller.getEmotionTarget());
+      onChangeRef.current?.(newState);
+    });
+    return () => {
+      unsub();
+    };
+  }, [controller]);
+  useEffect(() => {
+    if (!autoTick) return;
+    let lastTime = performance.now();
+    let rafId;
+    const tickFn = (time) => {
+      const delta = time - lastTime;
+      lastTime = time;
+      controller.tick(delta);
+      rafId = requestAnimationFrame(tickFn);
+    };
+    rafId = requestAnimationFrame(tickFn);
+    return () => {
+      cancelAnimationFrame(rafId);
+    };
+  }, [controller, autoTick]);
+  useEffect(() => {
+    return () => {
+      controller.dispose();
+    };
+  }, [controller]);
+  const handleEvent = useCallback(
+    (event) => {
+      controller.handleEvent(event);
+    },
+    [controller]
+  );
+  const tick = useCallback(
+    (deltaMs) => {
+      controller.tick(deltaMs);
+    },
+    [controller]
+  );
+  const emit = handleEvent;
+  return {
+    state,
+    emotion,
+    handleEvent,
+    tick,
+    emit
+  };
+}
+
+export {
+  clamp01,
+  createInitialCognitionState,
+  CognitionStateSchema,
+  CognitionSnapshotSchema,
+  validateCognitionSnapshot,
+  MODE_TRANSITION_MAP,
+  reduceDecay,
+  reduceEvent,
+  CognitionController,
+  useCognition
+};
+//# sourceMappingURL=chunk-LLOGBVQT.js.map