@runanywhere/core 0.16.0

package/src/types/LLMTypes.ts

@@ -0,0 +1,127 @@
+/**
+ * LLMTypes.ts
+ *
+ * Type definitions for LLM streaming functionality.
+ *
+ * Reference: sdk/runanywhere-swift/Sources/RunAnywhere/Public/Extensions/LLM/LLMTypes.swift
+ */
+
+/**
+ * LLM generation options
+ */
+export interface LLMGenerationOptions {
+  /** Maximum tokens to generate */
+  maxTokens?: number;
+
+  /** Temperature (0.0 - 2.0) */
+  temperature?: number;
+
+  /** Top-p sampling */
+  topP?: number;
+
+  /** Top-k sampling */
+  topK?: number;
+
+  /** Stop sequences */
+  stopSequences?: string[];
+
+  /** System prompt */
+  systemPrompt?: string;
+
+  /** Enable streaming */
+  streamingEnabled?: boolean;
+}
+
+/**
+ * LLM generation result
+ */
+export interface LLMGenerationResult {
+  /** Generated text */
+  text: string;
+
+  /** Thinking content (for models with reasoning) */
+  thinkingContent?: string;
+
+  /** Input tokens count */
+  inputTokens: number;
+
+  /** Output tokens count */
+  tokensUsed: number;
+
+  /** Model ID used */
+  modelUsed: string;
+
+  /** Total latency in ms */
+  latencyMs: number;
+
+  /** Framework used */
+  framework: string;
+
+  /** Tokens per second */
+  tokensPerSecond: number;
+
+  /** Time to first token in ms */
+  timeToFirstTokenMs?: number;
+
+  /** Thinking tokens count */
+  thinkingTokens: number;
+
+  /** Response tokens count */
+  responseTokens: number;
+}
+
+/**
+ * LLM streaming result
+ * Contains both a stream for real-time tokens and a promise for final metrics
+ */
+export interface LLMStreamingResult {
+  /** Async iterator for tokens */
+  stream: AsyncIterable<string>;
+
+  /** Promise that resolves to final result with metrics */
+  result: Promise<LLMGenerationResult>;
+
+  /** Cancel the generation */
+  cancel: () => void;
+}
+
+/**
+ * LLM streaming metrics collector state
+ */
+export interface LLMStreamingMetrics {
+  /** Full generated text */
+  fullText: string;
+
+  /** Total token count */
+  tokenCount: number;
+
+  /** Time to first token in ms */
+  timeToFirstTokenMs?: number;
+
+  /** Total generation time in ms */
+  totalTimeMs: number;
+
+  /** Tokens per second */
+  tokensPerSecond: number;
+
+  /** Whether generation completed successfully */
+  completed: boolean;
+
+  /** Error if generation failed */
+  error?: string;
+}
+
+/**
+ * Token callback for streaming
+ */
+export type LLMTokenCallback = (token: string) => void;
+
+/**
+ * Stream completion callback
+ */
+export type LLMStreamCompleteCallback = (result: LLMGenerationResult) => void;
+
+/**
+ * Stream error callback
+ */
+export type LLMStreamErrorCallback = (error: Error) => void;

package/src/types/STTTypes.ts

@@ -0,0 +1,124 @@
+/**
+ * STTTypes.ts
+ *
+ * Type definitions for Speech-to-Text functionality.
+ *
+ * Reference: sdk/runanywhere-swift/Sources/RunAnywhere/Public/Extensions/STT/STTTypes.swift
+ */
+
+/**
+ * STT options
+ */
+export interface STTOptions {
+  /** Language code (e.g., 'en') */
+  language?: string;
+
+  /** Sample rate in Hz (default: 16000) */
+  sampleRate?: number;
+
+  /** Enable word timestamps */
+  timestamps?: boolean;
+
+  /** Enable multiple alternatives */
+  alternatives?: boolean;
+
+  /** Maximum alternatives to return */
+  maxAlternatives?: number;
+}
+
+/**
+ * STT transcription output
+ */
+export interface STTOutput {
+  /** Transcribed text */
+  text: string;
+
+  /** Confidence score (0.0 - 1.0) */
+  confidence: number;
+
+  /** Word timestamps (if requested) */
+  wordTimestamps?: WordTimestamp[];
+
+  /** Detected language */
+  detectedLanguage?: string;
+
+  /** Alternative transcriptions */
+  alternatives?: STTAlternative[];
+
+  /** Transcription metadata */
+  metadata: TranscriptionMetadata;
+}
+
+/**
+ * Word timestamp
+ */
+export interface WordTimestamp {
+  word: string;
+  startTime: number;
+  endTime: number;
+  confidence?: number;
+}
+
+/**
+ * Alternative transcription
+ */
+export interface STTAlternative {
+  text: string;
+  confidence: number;
+}
+
+/**
+ * Transcription metadata
+ */
+export interface TranscriptionMetadata {
+  /** Model ID used */
+  modelId: string;
+
+  /** Processing time in seconds */
+  processingTime: number;
+
+  /** Audio length in seconds */
+  audioLength: number;
+
+  /** Real-time factor (processing time / audio length) */
+  realTimeFactor?: number;
+}
+
+/**
+ * STT partial result (for streaming)
+ */
+export interface STTPartialResult {
+  /** Partial transcript */
+  transcript: string;
+
+  /** Confidence (if available) */
+  confidence?: number;
+
+  /** Word timestamps (if available) */
+  timestamps?: WordTimestamp[];
+
+  /** Detected language */
+  language?: string;
+
+  /** Alternative transcriptions */
+  alternatives?: STTAlternative[];
+
+  /** Whether this is the final result */
+  isFinal: boolean;
+}
+
+/**
+ * STT streaming callback
+ */
+export type STTStreamCallback = (result: STTPartialResult) => void;
+
+/**
+ * STT streaming options
+ */
+export interface STTStreamOptions extends STTOptions {
+  /** Callback for partial results */
+  onPartialResult?: STTStreamCallback;
+
+  /** Interval for partial results in ms */
+  partialResultInterval?: number;
+}

package/src/types/StructuredOutputTypes.ts

@@ -0,0 +1,156 @@
+/**
+ * StructuredOutputTypes.ts
+ *
+ * Type definitions for Structured Output functionality.
+ *
+ * Reference: sdk/runanywhere-swift/Sources/RunAnywhere/Public/Extensions/LLM/StructuredOutput/
+ */
+
+/**
+ * JSON Schema type
+ */
+export type JSONSchemaType =
+  | 'string'
+  | 'number'
+  | 'integer'
+  | 'boolean'
+  | 'object'
+  | 'array'
+  | 'null';
+
+/**
+ * JSON Schema property
+ */
+export interface JSONSchemaProperty {
+  type?: JSONSchemaType | JSONSchemaType[];
+  description?: string;
+  enum?: (string | number | boolean)[];
+  const?: string | number | boolean;
+  default?: unknown;
+
+  // String validations
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  format?: string;
+
+  // Number validations
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
+
+  // Array validations
+  items?: JSONSchema;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+
+  // Object validations
+  properties?: Record<string, JSONSchemaProperty>;
+  required?: string[];
+  additionalProperties?: boolean | JSONSchema;
+}
+
+/**
+ * JSON Schema definition
+ */
+export interface JSONSchema extends JSONSchemaProperty {
+  $schema?: string;
+  $id?: string;
+  title?: string;
+  definitions?: Record<string, JSONSchema>;
+  $ref?: string;
+
+  // Composition
+  allOf?: JSONSchema[];
+  anyOf?: JSONSchema[];
+  oneOf?: JSONSchema[];
+  not?: JSONSchema;
+}
+
+/**
+ * Structured output options
+ */
+export interface StructuredOutputOptions {
+  /** Maximum tokens to generate */
+  maxTokens?: number;
+
+  /** Temperature for generation (0.0 - 2.0) */
+  temperature?: number;
+
+  /** Strict schema adherence */
+  strict?: boolean;
+
+  /** Number of retries on parse failure */
+  retries?: number;
+}
+
+/**
+ * Structured output result
+ */
+export interface StructuredOutputResult<T = unknown> {
+  /** Parsed data */
+  data: T;
+
+  /** Raw JSON string */
+  raw: string;
+
+  /** Whether generation was successful */
+  success: boolean;
+
+  /** Error message if failed */
+  error?: string;
+}
+
+/**
+ * Entity extraction result
+ */
+export interface EntityExtractionResult<T = unknown> {
+  entities: T;
+  confidence: number;
+}
+
+/**
+ * Classification result
+ */
+export interface ClassificationResult {
+  category: string;
+  confidence: number;
+  alternatives?: Array<{
+    category: string;
+    confidence: number;
+  }>;
+}
+
+/**
+ * Sentiment analysis result
+ */
+export interface SentimentResult {
+  sentiment: 'positive' | 'negative' | 'neutral';
+  score: number;
+  aspects?: Array<{
+    aspect: string;
+    sentiment: 'positive' | 'negative' | 'neutral';
+    score: number;
+  }>;
+}
+
+/**
+ * Named entity result
+ */
+export interface NamedEntity {
+  text: string;
+  type: string;
+  startOffset: number;
+  endOffset: number;
+  confidence: number;
+}
+
+/**
+ * Named entity recognition result
+ */
+export interface NERResult {
+  entities: NamedEntity[];
+}

package/src/types/TTSTypes.ts

@@ -0,0 +1,126 @@
+/**
+ * TTSTypes.ts
+ *
+ * Type definitions for Text-to-Speech functionality.
+ *
+ * Reference: sdk/runanywhere-swift/Sources/RunAnywhere/Public/Extensions/TTS/TTSTypes.swift
+ */
+
+/**
+ * TTS synthesis options
+ */
+export interface TTSOptions {
+  /** Voice ID to use */
+  voice?: string;
+
+  /** Speech rate multiplier (default: 1.0) */
+  rate?: number;
+
+  /** Pitch adjustment (default: 1.0) */
+  pitch?: number;
+
+  /** Volume (0.0 - 1.0, default: 1.0) */
+  volume?: number;
+
+  /** Sample rate in Hz (default: 22050) */
+  sampleRate?: number;
+
+  /** Language code (e.g., 'en-US') */
+  language?: string;
+
+  /** Audio format */
+  audioFormat?: AudioFormat;
+}
+
+/**
+ * Audio format enum
+ */
+export type AudioFormat = 'pcm' | 'wav' | 'mp3';
+
+/**
+ * TTS synthesis output
+ */
+export interface TTSOutput {
+  /** Audio data (base64 encoded or raw PCM) */
+  audioData: string;
+
+  /** Audio format */
+  format: AudioFormat;
+
+  /** Duration in seconds */
+  duration: number;
+
+  /** Phoneme timestamps (if available) */
+  phonemeTimestamps?: PhonemeTimestamp[];
+
+  /** Synthesis metadata */
+  metadata: TTSSynthesisMetadata;
+}
+
+/**
+ * Phoneme timestamp
+ */
+export interface PhonemeTimestamp {
+  phoneme: string;
+  startTime: number;
+  endTime: number;
+}
+
+/**
+ * TTS synthesis metadata
+ */
+export interface TTSSynthesisMetadata {
+  /** Voice used */
+  voice: string;
+
+  /** Language */
+  language?: string;
+
+  /** Processing time in seconds */
+  processingTime: number;
+
+  /** Character count of input text */
+  characterCount: number;
+}
+
+/**
+ * TTS speak result (simple playback API)
+ */
+export interface TTSSpeakResult {
+  /** Duration of audio in seconds */
+  duration: number;
+
+  /** Voice used */
+  voice: string;
+
+  /** Processing time in seconds */
+  processingTime: number;
+
+  /** Character count */
+  characterCount: number;
+}
+
+/**
+ * TTS voice info
+ */
+export interface TTSVoiceInfo {
+  /** Voice ID */
+  id: string;
+
+  /** Display name */
+  name: string;
+
+  /** Language code */
+  language: string;
+
+  /** Gender */
+  gender?: 'male' | 'female' | 'neutral';
+
+  /** Whether this voice is downloaded */
+  isDownloaded: boolean;
+}
+
+/**
+ * TTS stream chunk callback
+ */
+export type TTSStreamChunkCallback = (audioChunk: ArrayBuffer) => void;

package/src/types/VADTypes.ts

@@ -0,0 +1,70 @@
+/**
+ * VADTypes.ts
+ *
+ * Type definitions for Voice Activity Detection functionality.
+ *
+ * Reference: sdk/runanywhere-swift/Sources/RunAnywhere/Public/Extensions/VAD/VADTypes.swift
+ */
+
+/**
+ * VAD configuration options
+ */
+export interface VADConfiguration {
+  /** Sample rate in Hz (default: 16000) */
+  sampleRate?: number;
+
+  /** Frame length in seconds (default: 0.1) */
+  frameLength?: number;
+
+  /** Energy threshold for speech detection (default: 0.005) */
+  energyThreshold?: number;
+}
+
+/**
+ * VAD processing result
+ */
+export interface VADResult {
+  /** Whether speech was detected */
+  isSpeech: boolean;
+
+  /** Speech probability (0.0 - 1.0) */
+  probability: number;
+
+  /** Start time of speech segment (seconds) */
+  startTime?: number;
+
+  /** End time of speech segment (seconds) */
+  endTime?: number;
+}
+
+/**
+ * Speech activity event types
+ */
+export type SpeechActivityEvent = 'started' | 'ended';
+
+/**
+ * VAD speech activity callback
+ */
+export type VADSpeechActivityCallback = (event: SpeechActivityEvent) => void;
+
+/**
+ * VAD audio buffer callback
+ */
+export type VADAudioBufferCallback = (samples: Float32Array) => void;
+
+/**
+ * VAD state
+ */
+export interface VADState {
+  /** Whether VAD is initialized */
+  isInitialized: boolean;
+
+  /** Whether VAD is currently running */
+  isRunning: boolean;
+
+  /** Whether speech is currently active */
+  isSpeechActive: boolean;
+
+  /** Current speech probability */
+  currentProbability: number;
+}