@pipedog/core 0.0.0 → 0.1.0

package/dist/utils/text/skip_tags_aggregator.js

@@ -0,0 +1,147 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/text/skip_tags_aggregator.py
+/**
+ * Skip tags aggregator for preventing sentence boundaries within tagged content.
+ *
+ * This module provides a text aggregator that prevents end-of-sentence matching
+ * between specified start/end tag pairs, ensuring that tagged content is processed
+ * as a unit regardless of internal punctuation.
+ */
+import { longestTrailingPartialMatch, parseStartEndTags } from "../string.js";
+import { Aggregation, TextType } from "./base_text_aggregator.js";
+import { SimpleTextAggregator, } from "./simple_text_aggregator.js";
+/**
+ * Aggregator that prevents end of sentence matching between start/end tags.
+ *
+ * This aggregator buffers text until it finds an end of sentence or a start
+ * tag. If a start tag is found the aggregator will keep aggregating text
+ * unconditionally until the corresponding end tag is found. It's particularly
+ * useful for processing content with custom delimiters that should prevent
+ * text from being considered for end of sentence matching.
+ *
+ * The aggregator ensures that tags spanning multiple text chunks are correctly
+ * identified and that content within tags is never split at sentence boundaries.
+ */
+export class SkipTagsAggregator extends SimpleTextAggregator {
+    _tags;
+    _currentTag;
+    _currentTagIndex;
+    /**
+     * Initialize the skip tags aggregator.
+     *
+     * @param options.tags Tag pairs that should prevent sentence boundary detection.
+     *   Other options are passed to SimpleTextAggregator (e.g. aggregationType).
+     */
+    constructor(options) {
+        super(options);
+        this._tags = options.tags;
+        this._currentTag = null;
+        this._currentTagIndex = 0;
+    }
+    /**
+     * Aggregate text while respecting tag boundaries.
+     *
+     * Processes the input text character-by-character, updates tag state, and
+     * uses the parent's lookahead logic for sentence detection when not
+     * inside tags.
+     *
+     * In TOKEN mode, text is passed through immediately unless we're inside
+     * a tag, in which case we buffer until the closing tag is found. Text
+     * ending in a partial start tag (e.g. `<spe` of `<spell>`) is held
+     * back until a later chunk determines whether it begins a tag, so a tag
+     * split across chunks is still recognized.
+     *
+     * @param text Text to aggregate.
+     * @returns Aggregation objects containing text up to a sentence boundary,
+     *   marked as SENTENCE type (or TOKEN type in TOKEN mode).
+     */
+    async *aggregate(text) {
+        if (this._aggregationType === TextType.TOKEN) {
+            // In TOKEN mode, process chars for tag tracking but yield the
+            // full input as a single token when not inside a tag.
+            for (const char of text) {
+                this._text += char;
+                // Update tag state
+                [this._currentTag, this._currentTagIndex] = parseStartEndTags(this._text, this._tags, this._currentTag, this._currentTagIndex);
+            }
+            // After processing all chars: if not inside a tag, yield accumulated text.
+            // A trailing partial start tag (e.g. "<spe" of "<spell>") is held back
+            // so a tag split across chunks isn't leaked as plain text; it's retained
+            // in the buffer to be completed by the next chunk. The tag-scan index
+            // resets to 0 so the retained partial tag is rescanned once complete.
+            if (!this._currentTag && this._text) {
+                const heldBack = longestTrailingPartialMatch(this._text, this._tags.map(([start]) => start));
+                const yieldLength = this._text.length - heldBack;
+                if (yieldLength > 0) {
+                    const content = this._text.slice(0, yieldLength);
+                    this._text = this._text.slice(yieldLength);
+                    this._currentTagIndex = 0;
+                    yield new Aggregation({ text: content, type: TextType.TOKEN });
+                }
+            }
+            return;
+        }
+        // Process text character by character
+        for (const char of text) {
+            this._text += char;
+            // Update tag state
+            [this._currentTag, this._currentTagIndex] = parseStartEndTags(this._text, this._tags, this._currentTag, this._currentTagIndex);
+            // If inside tags, don't check for sentences
+            if (this._currentTag) {
+                continue;
+            }
+            // Otherwise, use parent's lookahead logic for sentence detection
+            const result = await super._checkSentenceWithLookahead(char);
+            if (result) {
+                yield result;
+            }
+        }
+    }
+    /**
+     * Flush any remaining text in the buffer.
+     *
+     * In SENTENCE mode, returns the buffered text as-is: tags are
+     * pass-through markers, so content is spoken whether or not a start
+     * tag's closing tag ever arrived. In TOKEN mode, returns any text
+     * still buffered behind an unclosed tag instead of discarding it.
+     *
+     * @returns Any remaining text, or null if the buffer is empty.
+     */
+    async flush() {
+        if (this._aggregationType === TextType.TOKEN) {
+            if (this._text) {
+                const result = this._text;
+                await this.reset();
+                return new Aggregation({ text: result, type: TextType.TOKEN });
+            }
+            return null;
+        }
+        return await super.flush();
+    }
+    /**
+     * Handle interruptions by clearing the buffer and tag state.
+     *
+     * Called when an interruption occurs in the processing pipeline,
+     * to reset the state and discard any partially aggregated text.
+     */
+    async handleInterruption() {
+        await super.handleInterruption();
+        this._currentTag = null;
+        this._currentTagIndex = 0;
+    }
+    /**
+     * Clear the internally aggregated text and tag state.
+     *
+     * Resets the aggregator to its initial state, discarding any
+     * buffered text.
+     */
+    async reset() {
+        await super.reset();
+        this._currentTag = null;
+        this._currentTagIndex = 0;
+    }
+}
+//# sourceMappingURL=skip_tags_aggregator.js.map

package/dist/utils/text/transforms/pronunciations.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Replace words with a TTS service's pronunciation markup.
+ *
+ * Applications usually reach this through a service's
+ * `TTSService.pronunciationTransformIpa` static method, which supplies the
+ * service's own formatter.
+ */
+import type { TextType } from "../../../frames/frames.ts";
+/** Turns `(word, ipa)` into the text to send, or null when it cannot. */
+export type PronunciationFormatter = (word: string, ipa: string) => string | null;
+/** Returns the text to send in place of a match. */
+export type PronunciationReplacer = (match: RegExpExecArray) => string;
+export interface PronunciationTransform {
+    (text: string, textType: string | TextType): Promise<string>;
+}
+/**
+ * A text transform that replaces words with a service's pronunciation markup.
+ *
+ * TTS services recognize it among their `textTransforms` and skip it while
+ * they cannot read pronunciation markup (see `TTSService.supportsPronunciations`),
+ * so the words are spoken as written.
+ */
+export declare class PronunciationTransform {
+    protected _pattern: RegExp | null;
+    protected _replace: PronunciationReplacer;
+    /**
+     * Initialize the transform.
+     *
+     * @param pattern Matches the words to replace, or null when there are none.
+     * @param replace Returns the text to send in place of a match.
+     */
+    constructor(pattern: RegExp | null, replace: PronunciationReplacer);
+    /**
+     * Replace every matched word in `text`.
+     *
+     * Python's `__call__`; calling the instance runs this.
+     *
+     * @param text The text about to be sent to the service.
+     * @param _textType The text type of the text (unused).
+     * @returns The text with each matched word replaced.
+     */
+    transform(text: string, _textType: string | TextType): string;
+}
+/**
+ * Return a transform that replaces each word with its formatted pronunciation.
+ *
+ * Words match whole and case-insensitively, longest first, and never as part
+ * of a longer or hyphenated word. The matched text is passed to the formatter,
+ * so markup that keeps the word (such as an SSML `<phoneme>` tag) keeps it as
+ * written.
+ *
+ * Every pronunciation is formatted once here, so one the service cannot use
+ * is reported when the transform is built rather than while speaking. Those
+ * words are left out and spoken as written.
+ *
+ * @param pronunciations Word to IPA, e.g. `{ Metformin: "mɛtˈfɔɹmɪn" }`.
+ * @param formatPronunciation Turns `(word, ipa)` into the text to send, or
+ *   null when it cannot.
+ * @param options.serviceName Name used in the warning for unusable pronunciations.
+ * @returns A transform to register with `textTransforms`.
+ */
+export declare function pronunciationTransform(pronunciations: Readonly<Record<string, string>>, formatPronunciation: PronunciationFormatter, options?: {
+    serviceName?: string;
+}): PronunciationTransform;
+//# sourceMappingURL=pronunciations.d.ts.map

package/dist/utils/text/transforms/pronunciations.js

@@ -0,0 +1,111 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/text/transforms/pronunciations.py
+import { logger } from "../../logger.js";
+/**
+ * A text transform that replaces words with a service's pronunciation markup.
+ *
+ * TTS services recognize it among their `textTransforms` and skip it while
+ * they cannot read pronunciation markup (see `TTSService.supportsPronunciations`),
+ * so the words are spoken as written.
+ */
+// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: adds Python's `__call__` signature to the class.
+export class PronunciationTransform {
+    _pattern;
+    _replace;
+    /**
+     * Initialize the transform.
+     *
+     * @param pattern Matches the words to replace, or null when there are none.
+     * @param replace Returns the text to send in place of a match.
+     */
+    constructor(pattern, replace) {
+        const call = async (text, textType) => self.transform(text, textType);
+        const self = Object.setPrototypeOf(call, new.target.prototype);
+        self._pattern = pattern;
+        self._replace = replace;
+        // biome-ignore lint/correctness/noConstructorReturn: returning the callable is the point (see above).
+        return self;
+    }
+    /**
+     * Replace every matched word in `text`.
+     *
+     * Python's `__call__`; calling the instance runs this.
+     *
+     * @param text The text about to be sent to the service.
+     * @param _textType The text type of the text (unused).
+     * @returns The text with each matched word replaced.
+     */
+    transform(text, _textType) {
+        const pattern = this._pattern;
+        if (!pattern)
+            return text;
+        pattern.lastIndex = 0;
+        return text.replace(pattern, (...args) => {
+            // `replace` passes (match, ...groups, offset, input); rebuild an exec array.
+            const match = [args[0]];
+            return this._replace(match);
+        });
+    }
+}
+/** Python's `re.escape` for a JS (`u`-flag) regular expression. */
+function escapeRegex(text) {
+    return text.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+}
+/**
+ * Return a transform that replaces each word with its formatted pronunciation.
+ *
+ * Words match whole and case-insensitively, longest first, and never as part
+ * of a longer or hyphenated word. The matched text is passed to the formatter,
+ * so markup that keeps the word (such as an SSML `<phoneme>` tag) keeps it as
+ * written.
+ *
+ * Every pronunciation is formatted once here, so one the service cannot use
+ * is reported when the transform is built rather than while speaking. Those
+ * words are left out and spoken as written.
+ *
+ * @param pronunciations Word to IPA, e.g. `{ Metformin: "mɛtˈfɔɹmɪn" }`.
+ * @param formatPronunciation Turns `(word, ipa)` into the text to send, or
+ *   null when it cannot.
+ * @param options.serviceName Name used in the warning for unusable pronunciations.
+ * @returns A transform to register with `textTransforms`.
+ */
+export function pronunciationTransform(pronunciations, formatPronunciation, options = {}) {
+    const serviceName = options.serviceName ?? "TTS service";
+    const phonemes = new Map();
+    const unusable = [];
+    for (const [rawWord, value] of Object.entries(pronunciations)) {
+        const word = rawWord.trim();
+        if (!word)
+            continue;
+        if (formatPronunciation(word, value) === null) {
+            unusable.push(word);
+        }
+        else {
+            phonemes.set(word.toLowerCase(), value);
+        }
+    }
+    if (unusable.length > 0) {
+        logger.warning(`${serviceName} cannot use these IPA pronunciations, so they ` +
+            `will be spoken as written: ${unusable.join(", ")}`);
+    }
+    let pattern = null;
+    if (phonemes.size > 0) {
+        const words = [...phonemes.keys()].sort((a, b) => b.length - a.length);
+        // Python's Unicode `\w` is letters, digits and underscore.
+        pattern = new RegExp(`(?<![\\p{L}\\p{N}_-])(?:${words.map(escapeRegex).join("|")})(?![\\p{L}\\p{N}_-])`, "giu");
+    }
+    const replace = (match) => {
+        const word = match[0];
+        // Python indexes the dict directly; a case-folding mismatch would raise
+        // there, here the word is kept as written.
+        const ipa = phonemes.get(word.toLowerCase());
+        if (ipa === undefined)
+            return word;
+        return formatPronunciation(word, ipa) || word;
+    };
+    return new PronunciationTransform(pattern, replace);
+}
+//# sourceMappingURL=pronunciations.js.map

package/dist/utils/text/word_timestamp_utils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Merge punctuation/space-only tokens into the preceding word.
+ *
+ * Some TTS services (e.g. Inworld) emit spaces and punctuation as separate
+ * word-timestamp tokens rather than attaching them to the adjacent word.
+ * This function collapses those tokens so downstream consumers always receive
+ * words with trailing punctuation already attached — identical to the format
+ * produced by ElevenLabs or Cartesia.
+ *
+ * A token is considered punct/space-only when its text contains no alphanumeric
+ * characters after stripping XML/HTML tags. Such tokens are appended to the
+ * preceding word's text and their timestamp is discarded (the preceding word's
+ * timestamp is kept). Leading punct/space tokens with no preceding word are
+ * silently discarded. Every output token is stripped of leading and trailing
+ * whitespace (spaces, tabs, newlines).
+ *
+ * @param wordTimes Raw list of `[word, timestamp]` pairs from the TTS service.
+ * @returns Merged list where every entry contains at least one alphanumeric
+ *   character and has no leading or trailing whitespace.
+ *
+ * @example
+ * mergePunctTokens([["questions", 1.0], [", ", 1.2], ["explain", 1.4]]);
+ * // → [["questions,", 1.0], ["explain", 1.4]]
+ */
+export declare function mergePunctTokens(wordTimes: readonly (readonly [string, number])[]): [string, number][];
+//# sourceMappingURL=word_timestamp_utils.d.ts.map

package/dist/utils/text/word_timestamp_utils.js

@@ -0,0 +1,52 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/text/word_timestamp_utils.py
+/** Utilities for normalizing word-timestamp streams from TTS services. */
+const TAG_RE = /<[^>]+>/g;
+const ALNUM_RE = /[\p{L}\p{N}]/u;
+/**
+ * Merge punctuation/space-only tokens into the preceding word.
+ *
+ * Some TTS services (e.g. Inworld) emit spaces and punctuation as separate
+ * word-timestamp tokens rather than attaching them to the adjacent word.
+ * This function collapses those tokens so downstream consumers always receive
+ * words with trailing punctuation already attached — identical to the format
+ * produced by ElevenLabs or Cartesia.
+ *
+ * A token is considered punct/space-only when its text contains no alphanumeric
+ * characters after stripping XML/HTML tags. Such tokens are appended to the
+ * preceding word's text and their timestamp is discarded (the preceding word's
+ * timestamp is kept). Leading punct/space tokens with no preceding word are
+ * silently discarded. Every output token is stripped of leading and trailing
+ * whitespace (spaces, tabs, newlines).
+ *
+ * @param wordTimes Raw list of `[word, timestamp]` pairs from the TTS service.
+ * @returns Merged list where every entry contains at least one alphanumeric
+ *   character and has no leading or trailing whitespace.
+ *
+ * @example
+ * mergePunctTokens([["questions", 1.0], [", ", 1.2], ["explain", 1.4]]);
+ * // → [["questions,", 1.0], ["explain", 1.4]]
+ */
+export function mergePunctTokens(wordTimes) {
+    const merged = [];
+    for (const [word, ts] of wordTimes) {
+        const stripped = word.replace(TAG_RE, "");
+        const hasAlnum = ALNUM_RE.test(stripped);
+        if (!hasAlnum) {
+            const last = merged[merged.length - 1];
+            if (last) {
+                const [prevWord, prevTs] = last;
+                merged[merged.length - 1] = [prevWord + word, prevTs];
+            }
+            // else: leading punct/space with no preceding word → discard
+        }
+        else {
+            merged.push([word, ts]);
+        }
+    }
+    return merged.map(([word, ts]) => [word.trim(), ts]);
+}
+//# sourceMappingURL=word_timestamp_utils.js.map

package/dist/utils/time.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Time utilities: ISO8601 formatting, nanosecond conversions, and
+ * human-readable time strings.
+ */
+/** The current UTC time as an ISO8601 string with millisecond precision. */
+export declare function timeNowIso8601(): string;
+/** Convert seconds to (integer) nanoseconds. */
+export declare function secondsToNanoseconds(seconds: number): number;
+/** Convert nanoseconds to seconds. */
+export declare function nanosecondsToSeconds(nanoseconds: number): number;
+/** Convert nanoseconds to an "H:MM:SS.microseconds" string. */
+export declare function nanosecondsToStr(nanoseconds: number): string;
+//# sourceMappingURL=time.d.ts.map

package/dist/utils/time.js

@@ -0,0 +1,31 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/time.py
+/**
+ * Time utilities: ISO8601 formatting, nanosecond conversions, and
+ * human-readable time strings.
+ */
+/** The current UTC time as an ISO8601 string with millisecond precision. */
+export function timeNowIso8601() {
+    return new Date().toISOString().replace("Z", "+00:00");
+}
+/** Convert seconds to (integer) nanoseconds. */
+export function secondsToNanoseconds(seconds) {
+    return Math.trunc(seconds * 1_000_000_000);
+}
+/** Convert nanoseconds to seconds. */
+export function nanosecondsToSeconds(nanoseconds) {
+    return nanoseconds / 1_000_000_000;
+}
+/** Convert nanoseconds to an "H:MM:SS.microseconds" string. */
+export function nanosecondsToStr(nanoseconds) {
+    const totalSeconds = nanosecondsToSeconds(nanoseconds);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = Math.floor(totalSeconds % 60);
+    const microseconds = Math.trunc((totalSeconds - Math.trunc(totalSeconds)) * 1_000_000);
+    return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${String(microseconds).padStart(6, "0")}`;
+}
+//# sourceMappingURL=time.js.map

package/dist/utils/tracing/index.d.ts

@@ -0,0 +1,3 @@
+/** OpenTelemetry tracing utilities for Pipecat. */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/tracing/index.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/tracing/__init__.py
+/** OpenTelemetry tracing utilities for Pipecat. */
+export {};
+//# sourceMappingURL=index.js.map

package/dist/utils/tracing/service_attributes.d.ts

@@ -0,0 +1,198 @@
+/**
+ * Functions for adding attributes to OpenTelemetry spans.
+ *
+ * This module provides specialized functions for adding service-specific
+ * attributes to OpenTelemetry spans, following standard semantic conventions
+ * where applicable and Pipecat-specific conventions for additional context.
+ *
+ * Porting notes:
+ * - Upstream's keyword arguments become an options object after the span.
+ *   Extra keyword arguments (upstream `**kwargs`) are any other keys of that
+ *   object; they are used verbatim as attribute names.
+ * - Settings field names are camelCase in TS (`givenFields()`); they are
+ *   converted back to snake_case for the `settings.*` attribute names so spans
+ *   carry the same attribute names as upstream.
+ */
+import type { ServiceSettings } from "../../services/settings.ts";
+import type { OtelSpan } from "./setup.ts";
+/** Convert a camelCase name back to upstream's snake_case (`voiceId` → `voice_id`). */
+export declare function _camelToSnake(name: string): string;
+/**
+ * Extract the standardized gen_ai.provider.name value from a service class name.
+ *
+ * Source:
+ * https://github.com/open-telemetry/semantic-conventions-genai/blob/main/docs/registry/attributes/gen-ai.md
+ *
+ * Uses standard OTel names where possible, with special case mappings for
+ * service names that don't follow the pattern.
+ *
+ * @param serviceName The service class name to extract provider name from.
+ * @returns The standardized gen_ai.provider.name value.
+ */
+export declare function _getProviderNameFromServiceName(serviceName: string): string;
+export interface TtsSpanAttributesOptions {
+    /** Name of the TTS service (e.g., "cartesia"). */
+    serviceName: string;
+    /** Model name/identifier. */
+    model: string;
+    /** Voice identifier. */
+    voiceId: string;
+    /** The text being synthesized. */
+    text?: string | null;
+    /** Service configuration settings. */
+    settings?: ServiceSettings | null;
+    /** Number of characters in the text. */
+    characterCount?: number | null;
+    /** Name of the operation (default: "tts"). */
+    operationName?: string;
+    /** Time to first byte in seconds. */
+    ttfb?: number | null;
+    /** Additional attributes to add. */
+    [key: string]: unknown;
+}
+/**
+ * Add TTS-specific attributes to a span.
+ *
+ * @param span The span to add attributes to.
+ * @param options The TTS attributes; any other key is added as an attribute.
+ */
+export declare function addTtsSpanAttributes(span: OtelSpan, options: TtsSpanAttributesOptions): void;
+export interface SttSpanAttributesOptions {
+    /** Name of the STT service (e.g., "deepgram"). */
+    serviceName: string;
+    /** Model name/identifier. */
+    model: string;
+    /** Name of the operation (default: "stt"). */
+    operationName?: string;
+    /** The transcribed text. */
+    transcript?: string | null;
+    /** Whether this is a final transcript. */
+    isFinal?: boolean | null;
+    /** Detected or configured language. */
+    language?: string | null;
+    /** User ID associated with the audio being transcribed. */
+    userId?: string | null;
+    /** Service configuration settings. */
+    settings?: ServiceSettings | null;
+    /** Whether voice activity detection is enabled. */
+    vadEnabled?: boolean;
+    /** Time to first byte in seconds. */
+    ttfb?: number | null;
+    /** Additional attributes to add. */
+    [key: string]: unknown;
+}
+/**
+ * Add STT-specific attributes to a span.
+ *
+ * @param span The span to add attributes to.
+ * @param options The STT attributes; any other key is added as an attribute.
+ */
+export declare function addSttSpanAttributes(span: OtelSpan, options: SttSpanAttributesOptions): void;
+export interface LlmSpanAttributesOptions {
+    /** Name of the LLM service (e.g., "openai"). */
+    serviceName: string;
+    /** Model name/identifier. */
+    model: string;
+    /** Whether streaming is enabled. */
+    stream?: boolean;
+    /** JSON-serialized messages. */
+    messages?: string | null;
+    /** Aggregated output text from the LLM. */
+    output?: string | null;
+    /** JSON-serialized tools configuration. */
+    tools?: string | null;
+    /** Number of tools available. */
+    toolCount?: number | null;
+    /** Tool selection configuration. */
+    toolChoice?: string | null;
+    /** System instructions. */
+    systemInstructions?: string | null;
+    /** Service parameters. */
+    parameters?: Record<string, unknown> | null;
+    /** Additional parameters. */
+    extraParameters?: Record<string, unknown> | null;
+    /** Time to first byte in seconds. */
+    ttfb?: number | null;
+    /** Additional attributes to add. */
+    [key: string]: unknown;
+}
+/**
+ * Add LLM-specific attributes to a span.
+ *
+ * @param span The span to add attributes to.
+ * @param options The LLM attributes; any other key is added as an attribute.
+ *   Keys of `parameters` may be camelCase settings names; they are converted
+ *   to snake_case attribute names.
+ */
+export declare function addLlmSpanAttributes(span: OtelSpan, options: LlmSpanAttributesOptions): void;
+export interface GeminiLiveSpanAttributesOptions {
+    /** Name of the service. */
+    serviceName: string;
+    /** Model name/identifier. */
+    model: string;
+    /** Name of the operation (setup, model_turn, tool_call, etc.). */
+    operationName: string;
+    /** Voice identifier used for output. */
+    voiceId?: string | null;
+    /** Language code for the session. */
+    language?: string | null;
+    /** Supported modalities (e.g., "AUDIO", "TEXT"). */
+    modalities?: string | null;
+    /** Service configuration settings. */
+    settings?: ServiceSettings | null;
+    /** Available tools/functions list. */
+    tools?: unknown[] | null;
+    /** JSON-serialized tools for detailed inspection. */
+    toolsSerialized?: string | null;
+    /** Transcription text. */
+    transcript?: string | null;
+    /** Whether transcript is input (true) or output (false). */
+    isInput?: boolean | null;
+    /** Text output from model. */
+    textOutput?: string | null;
+    /** Size of audio data in bytes. */
+    audioDataSize?: number | null;
+    /** Additional attributes to add. */
+    [key: string]: unknown;
+}
+/**
+ * Add Gemini Live specific attributes to a span.
+ *
+ * @param span The span to add attributes to.
+ * @param options The Gemini Live attributes; any other key is added as an attribute.
+ */
+export declare function addGeminiLiveSpanAttributes(span: OtelSpan, options: GeminiLiveSpanAttributesOptions): void;
+export interface OpenaiRealtimeSpanAttributesOptions {
+    /** Name of the service. */
+    serviceName: string;
+    /** Model name/identifier. */
+    model: string;
+    /** Name of the operation (setup, transcription, response, etc.). */
+    operationName: string;
+    /** Session configuration properties. */
+    sessionProperties?: Record<string, unknown> | null;
+    /** Transcription text. */
+    transcript?: string | null;
+    /** Whether transcript is input (true) or output (false). */
+    isInput?: boolean | null;
+    /** JSON-serialized context messages. */
+    contextMessages?: string | null;
+    /** Function calls being made. */
+    functionCalls?: unknown[] | null;
+    /** Available tools/functions list. */
+    tools?: unknown[] | null;
+    /** JSON-serialized tools for detailed inspection. */
+    toolsSerialized?: string | null;
+    /** Size of audio data in bytes. */
+    audioDataSize?: number | null;
+    /** Additional attributes to add. */
+    [key: string]: unknown;
+}
+/**
+ * Add OpenAI Realtime specific attributes to a span.
+ *
+ * @param span The span to add attributes to.
+ * @param options The OpenAI Realtime attributes; any other key is added as an attribute.
+ */
+export declare function addOpenaiRealtimeSpanAttributes(span: OtelSpan, options: OpenaiRealtimeSpanAttributesOptions): void;
+//# sourceMappingURL=service_attributes.d.ts.map