@pipedog/core 0.0.0 → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Whether to emit the import-time version banner.
+ *
+ * The banner is a handy startup marker for bots and interactive use, but it's
+ * just noise for the `pipecat` / `pc` CLI — it even corrupts `--help` output —
+ * so suppress it there.
+ */
+export declare function _shouldLogVersionBanner(): boolean;
+/** Returns the pipedog version (shared by every @pipedog package). */
+export declare function version(): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,56 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/__init__.py
+/**
+ * The `@pipedog/core` package entry point.
+ *
+ * Porting notes:
+ * - The version is this package's version (upstream reads the installed
+ *   `pipecat-ai` distribution's metadata); keep it in sync with package.json.
+ * - The check for a separately installed `pipecat-ai-flows` package is Python
+ *   packaging specific and is not ported.
+ * - The `asyncio.wait_for` replacement for Python < 3.12 has no JS
+ *   counterpart (`waitFor` from `@pipedog/asyncio` is used everywhere).
+ */
+import { logger } from "./utils/logger.js";
+import { VERSION } from "./version.js";
+const __version__ = VERSION;
+function currentProcess() {
+    return globalThis.process;
+}
+/** A short description of the JavaScript runtime, for the version banner. */
+function runtimeDescription() {
+    const g = globalThis;
+    if (g.Bun)
+        return `Bun ${g.Bun.version}`;
+    if (g.Deno)
+        return `Deno ${g.Deno.version.deno}`;
+    const node = currentProcess()?.versions?.node;
+    if (node)
+        return `Node ${node}`;
+    return g.navigator?.userAgent ?? "unknown runtime";
+}
+/**
+ * Whether to emit the import-time version banner.
+ *
+ * The banner is a handy startup marker for bots and interactive use, but it's
+ * just noise for the `pipecat` / `pc` CLI — it even corrupts `--help` output —
+ * so suppress it there.
+ */
+export function _shouldLogVersionBanner() {
+    const script = currentProcess()?.argv?.[1] ?? "";
+    const base = script.split(/[\\/]/).pop() ?? "";
+    const program = base.replace(/\.[^.]*$/, "");
+    return program !== "pipecat" && program !== "pc";
+}
+if (_shouldLogVersionBanner()) {
+    // Upstream prints "ᓚᘏᗢ Pipecat <version> ᓚᘏᗢ"; this is pipedog, with its own version.
+    logger.info(`pipedog ${__version__} (${runtimeDescription()})`);
+}
+/** Returns the pipedog version (shared by every @pipedog package). */
+export function version() {
+    return __version__;
+}
+//# sourceMappingURL=index.js.map

package/dist/metrics/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/metrics/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/metrics/__init__.py
+// Upstream's `__init__.py` is empty: import the package's modules directly.
+export {};
+//# sourceMappingURL=index.js.map

package/dist/metrics/metrics.d.ts

@@ -0,0 +1,276 @@
+/**
+ * Metrics data models for Pipecat framework.
+ *
+ * Defines models for various types of metrics data collected throughout the
+ * pipeline, including timing, token usage, and processing statistics.
+ */
+export interface MetricsDataOptions {
+    /** Name of the processor generating the metrics. */
+    processor: string;
+    /** Optional model name associated with the metrics. */
+    model?: string | null;
+}
+/**
+ * Base class for all metrics data.
+ *
+ * - `processor`: name of the processor generating the metrics.
+ * - `model`: optional model name associated with the metrics.
+ */
+export declare class MetricsData {
+    processor: string;
+    model: string | null;
+    constructor(options: MetricsDataOptions);
+}
+export interface TTFBMetricsDataOptions extends MetricsDataOptions {
+    /** TTFB measurement in seconds. */
+    value: number;
+}
+/**
+ * Time To First Byte (TTFB) metrics data.
+ *
+ * - `value`: TTFB measurement in seconds.
+ */
+export declare class TTFBMetricsData extends MetricsData {
+    value: number;
+    constructor(options: TTFBMetricsDataOptions);
+}
+export interface TTFAMetricsDataOptions extends MetricsDataOptions {
+    /** TTFA measurement in seconds (`ttfb` plus `leadingSilence`). */
+    ttfa: number;
+    /** Time-to-first-byte that TTFA builds on, in seconds. */
+    ttfb: number;
+    /** Silence padding before the first audible sample, in seconds. */
+    leadingSilence: number;
+}
+/**
+ * Time To First Audio (TTFA) metrics data.
+ *
+ * Measures the time from a TTS request to the first audible audio sample,
+ * i.e. time-to-first-byte plus any leading silence the service pads onto the
+ * start of its response. `ttfa` is reported with its breakdown so consumers
+ * can see how much of the perceived latency is silence padding rather than
+ * service response time, without correlating a separate `TTFBMetricsData`.
+ *
+ * - `ttfa`: TTFA measurement in seconds (`ttfb` plus `leadingSilence`).
+ * - `ttfb`: time-to-first-byte that TTFA builds on, in seconds. This mirrors
+ *   the standalone `TTFBMetricsData` (emitted earlier) for convenience; it is
+ *   not a separate measurement, so don't aggregate both.
+ * - `leadingSilence`: silence padding before the first audible sample, in
+ *   seconds (`ttfa` minus `ttfb`).
+ */
+export declare class TTFAMetricsData extends MetricsData {
+    ttfa: number;
+    ttfb: number;
+    leadingSilence: number;
+    constructor(options: TTFAMetricsDataOptions);
+}
+export interface TTFATMetricsDataOptions extends MetricsDataOptions {
+    /** TTFAT measurement in seconds (`ttfb` plus `thinkingTime`). */
+    ttfat: number;
+    /** Time-to-first-byte that TTFAT builds on, in seconds. */
+    ttfb: number;
+    /** Time between the model's first output and the first answer token, in seconds. */
+    thinkingTime: number;
+}
+/**
+ * Time To First Answer Token (TTFAT) metrics data.
+ *
+ * Measures the time from an LLM request to the first token of the answer the
+ * caller sees, i.e. time-to-first-byte plus any reasoning the model streamed
+ * first. `ttfat` is reported with its breakdown so consumers can see how much
+ * of the perceived latency is the model thinking rather than responding,
+ * without correlating a separate `TTFBMetricsData`.
+ *
+ * A turn that answers with a tool call rather than text ends the measurement at
+ * the call, taken where it first appears in the stream. Answering from a tool
+ * result takes a second inference, so such a turn reports twice — once for the
+ * call, once for the answer built from its result. Each figure covers one
+ * inference; consumers wanting one per user turn keep the first, which is the
+ * one that measures how quickly the model began responding at all.
+ *
+ * Reported only by LLM services that answer in text. Speech-to-speech services
+ * answer in audio, which has no answer token to measure to.
+ *
+ * - `ttfat`: TTFAT measurement in seconds (`ttfb` plus `thinkingTime`).
+ * - `ttfb`: time-to-first-byte that TTFAT builds on, in seconds. This mirrors
+ *   the standalone `TTFBMetricsData` (emitted earlier) for convenience; it is
+ *   not a separate measurement, so don't aggregate both.
+ * - `thinkingTime`: time between the model's first output and the first answer
+ *   token, in seconds (`ttfat` minus `ttfb`). Reasoning is the usual reason a
+ *   model streams something before it starts answering, though a model that
+ *   reasons none still spends a little time here.
+ */
+export declare class TTFATMetricsData extends MetricsData {
+    ttfat: number;
+    ttfb: number;
+    thinkingTime: number;
+    constructor(options: TTFATMetricsDataOptions);
+}
+export interface ProcessingMetricsDataOptions extends MetricsDataOptions {
+    /** Processing time measurement in seconds. */
+    value: number;
+}
+/**
+ * General processing time metrics data.
+ *
+ * - `value`: processing time measurement in seconds.
+ */
+export declare class ProcessingMetricsData extends MetricsData {
+    value: number;
+    constructor(options: ProcessingMetricsDataOptions);
+}
+export interface LLMTokenUsageOptions {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cacheReadInputTokens?: number | null;
+    cacheCreationInputTokens?: number | null;
+    reasoningTokens?: number | null;
+    inputAudioTokens?: number | null;
+    outputAudioTokens?: number | null;
+    cacheReadInputAudioTokens?: number | null;
+}
+/**
+ * Token usage statistics for LLM operations.
+ *
+ * Services differ in whether their input count is reported net or gross of the
+ * prompt cache. Anthropic and Bedrock report `promptTokens` net, with the
+ * cache counts alongside it; OpenAI-compatible services report it gross, with
+ * the cache counts already inside it. `totalTokens` is the gross figure
+ * either way, so it stays comparable across services, and it is therefore not
+ * always `promptTokens + completionTokens`. Read the cache fields for the
+ * breakdown rather than subtracting.
+ *
+ * Per-bucket cost accounting has to account for that difference: adding the
+ * cache counts to `promptTokens` double-counts them on a service that
+ * reports gross.
+ *
+ * - `promptTokens`: number of tokens in the input prompt, net or gross of the
+ *   cache counts depending on the service. Includes tool results the
+ *   provider feeds back to the model, which are billed as input.
+ * - `completionTokens`: number of tokens in the generated completion,
+ *   including any reasoning tokens.
+ * - `totalTokens`: total number of tokens used, including any cached input
+ *   tokens.
+ * - `cacheReadInputTokens`: number of tokens read from cache, if applicable.
+ *   Billed below the input rate.
+ * - `cacheCreationInputTokens`: number of tokens written to cache, if
+ *   applicable. Billed at or above the input rate.
+ * - `reasoningTokens`: number of completion tokens used for reasoning, if applicable.
+ * - `inputAudioTokens`: number of prompt tokens that were audio, if applicable.
+ * - `outputAudioTokens`: number of completion tokens that were audio, if applicable.
+ * - `cacheReadInputAudioTokens`: number of cache-read tokens that were audio, if applicable.
+ */
+export declare class LLMTokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cacheReadInputTokens: number | null;
+    cacheCreationInputTokens: number | null;
+    reasoningTokens: number | null;
+    inputAudioTokens: number | null;
+    outputAudioTokens: number | null;
+    cacheReadInputAudioTokens: number | null;
+    constructor(options: LLMTokenUsageOptions);
+}
+export interface LLMUsageMetricsDataOptions extends MetricsDataOptions {
+    /** Token usage statistics for the LLM operation. */
+    value: LLMTokenUsage;
+}
+/**
+ * LLM token usage metrics data.
+ *
+ * - `value`: token usage statistics for the LLM operation.
+ */
+export declare class LLMUsageMetricsData extends MetricsData {
+    value: LLMTokenUsage;
+    constructor(options: LLMUsageMetricsDataOptions);
+}
+export interface STTUsageOptions {
+    /** Client-measured seconds of audio submitted since the last usage report. */
+    audioSeconds: number;
+}
+/**
+ * Usage statistics for STT operations.
+ *
+ * Reports raw usage, not cost. Values are incremental deltas since the
+ * previous usage report; consumers sum them across a session.
+ *
+ * Continuous STT services stream all input audio (including silence), so
+ * their summed `audioSeconds` approximates the stream duration — which
+ * is what most streaming providers bill. Segmented STT services submit
+ * only the detected speech segments, so their sum covers just those
+ * segments.
+ *
+ * - `audioSeconds`: client-measured seconds of audio submitted to the
+ *   service since the last usage report.
+ */
+export declare class STTUsage {
+    audioSeconds: number;
+    constructor(options: STTUsageOptions);
+}
+export interface STTUsageMetricsDataOptions extends MetricsDataOptions {
+    /** Usage statistics for the STT operation. */
+    value: STTUsage;
+}
+/**
+ * Speech-to-Text usage metrics data.
+ *
+ * - `value`: usage statistics for the STT operation.
+ */
+export declare class STTUsageMetricsData extends MetricsData {
+    value: STTUsage;
+    constructor(options: STTUsageMetricsDataOptions);
+}
+export interface TTSUsageMetricsDataOptions extends MetricsDataOptions {
+    /** Number of characters processed by TTS. */
+    value: number;
+}
+/**
+ * Text-to-Speech usage metrics data.
+ *
+ * - `value`: number of characters processed by TTS.
+ */
+export declare class TTSUsageMetricsData extends MetricsData {
+    value: number;
+    constructor(options: TTSUsageMetricsDataOptions);
+}
+export interface TextAggregationMetricsDataOptions extends MetricsDataOptions {
+    /** Aggregation time in seconds. */
+    value: number;
+}
+/**
+ * Text aggregation time metrics data.
+ *
+ * Measures the time from the first LLM token to the first complete sentence,
+ * representing the latency cost of sentence aggregation in the TTS pipeline.
+ *
+ * - `value`: aggregation time in seconds.
+ */
+export declare class TextAggregationMetricsData extends MetricsData {
+    value: number;
+    constructor(options: TextAggregationMetricsDataOptions);
+}
+export interface TurnMetricsDataOptions extends MetricsDataOptions {
+    /** Whether the turn is predicted to be complete. */
+    isComplete: boolean;
+    /** Confidence probability of the turn completion prediction. */
+    probability: number;
+    /** End-to-end processing time in milliseconds. */
+    e2eProcessingTimeMs: number;
+}
+/**
+ * Metrics data for turn detection predictions.
+ *
+ * - `isComplete`: whether the turn is predicted to be complete.
+ * - `probability`: confidence probability of the turn completion prediction.
+ * - `e2eProcessingTimeMs`: end-to-end processing time in milliseconds,
+ *   measured from VAD speech-to-silence transition to turn completion.
+ */
+export declare class TurnMetricsData extends MetricsData {
+    isComplete: boolean;
+    probability: number;
+    e2eProcessingTimeMs: number;
+    constructor(options: TurnMetricsDataOptions);
+}
+//# sourceMappingURL=metrics.d.ts.map

package/dist/metrics/metrics.js

@@ -0,0 +1,254 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/metrics/metrics.py
+/**
+ * Base class for all metrics data.
+ *
+ * - `processor`: name of the processor generating the metrics.
+ * - `model`: optional model name associated with the metrics.
+ */
+export class MetricsData {
+    processor;
+    model;
+    constructor(options) {
+        this.processor = options.processor;
+        this.model = options.model ?? null;
+    }
+}
+/**
+ * Time To First Byte (TTFB) metrics data.
+ *
+ * - `value`: TTFB measurement in seconds.
+ */
+export class TTFBMetricsData extends MetricsData {
+    value;
+    constructor(options) {
+        super(options);
+        this.value = options.value;
+    }
+}
+/**
+ * Time To First Audio (TTFA) metrics data.
+ *
+ * Measures the time from a TTS request to the first audible audio sample,
+ * i.e. time-to-first-byte plus any leading silence the service pads onto the
+ * start of its response. `ttfa` is reported with its breakdown so consumers
+ * can see how much of the perceived latency is silence padding rather than
+ * service response time, without correlating a separate `TTFBMetricsData`.
+ *
+ * - `ttfa`: TTFA measurement in seconds (`ttfb` plus `leadingSilence`).
+ * - `ttfb`: time-to-first-byte that TTFA builds on, in seconds. This mirrors
+ *   the standalone `TTFBMetricsData` (emitted earlier) for convenience; it is
+ *   not a separate measurement, so don't aggregate both.
+ * - `leadingSilence`: silence padding before the first audible sample, in
+ *   seconds (`ttfa` minus `ttfb`).
+ */
+export class TTFAMetricsData extends MetricsData {
+    ttfa;
+    ttfb;
+    leadingSilence;
+    constructor(options) {
+        super(options);
+        this.ttfa = options.ttfa;
+        this.ttfb = options.ttfb;
+        this.leadingSilence = options.leadingSilence;
+    }
+}
+/**
+ * Time To First Answer Token (TTFAT) metrics data.
+ *
+ * Measures the time from an LLM request to the first token of the answer the
+ * caller sees, i.e. time-to-first-byte plus any reasoning the model streamed
+ * first. `ttfat` is reported with its breakdown so consumers can see how much
+ * of the perceived latency is the model thinking rather than responding,
+ * without correlating a separate `TTFBMetricsData`.
+ *
+ * A turn that answers with a tool call rather than text ends the measurement at
+ * the call, taken where it first appears in the stream. Answering from a tool
+ * result takes a second inference, so such a turn reports twice — once for the
+ * call, once for the answer built from its result. Each figure covers one
+ * inference; consumers wanting one per user turn keep the first, which is the
+ * one that measures how quickly the model began responding at all.
+ *
+ * Reported only by LLM services that answer in text. Speech-to-speech services
+ * answer in audio, which has no answer token to measure to.
+ *
+ * - `ttfat`: TTFAT measurement in seconds (`ttfb` plus `thinkingTime`).
+ * - `ttfb`: time-to-first-byte that TTFAT builds on, in seconds. This mirrors
+ *   the standalone `TTFBMetricsData` (emitted earlier) for convenience; it is
+ *   not a separate measurement, so don't aggregate both.
+ * - `thinkingTime`: time between the model's first output and the first answer
+ *   token, in seconds (`ttfat` minus `ttfb`). Reasoning is the usual reason a
+ *   model streams something before it starts answering, though a model that
+ *   reasons none still spends a little time here.
+ */
+export class TTFATMetricsData extends MetricsData {
+    ttfat;
+    ttfb;
+    thinkingTime;
+    constructor(options) {
+        super(options);
+        this.ttfat = options.ttfat;
+        this.ttfb = options.ttfb;
+        this.thinkingTime = options.thinkingTime;
+    }
+}
+/**
+ * General processing time metrics data.
+ *
+ * - `value`: processing time measurement in seconds.
+ */
+export class ProcessingMetricsData extends MetricsData {
+    value;
+    constructor(options) {
+        super(options);
+        this.value = options.value;
+    }
+}
+/**
+ * Token usage statistics for LLM operations.
+ *
+ * Services differ in whether their input count is reported net or gross of the
+ * prompt cache. Anthropic and Bedrock report `promptTokens` net, with the
+ * cache counts alongside it; OpenAI-compatible services report it gross, with
+ * the cache counts already inside it. `totalTokens` is the gross figure
+ * either way, so it stays comparable across services, and it is therefore not
+ * always `promptTokens + completionTokens`. Read the cache fields for the
+ * breakdown rather than subtracting.
+ *
+ * Per-bucket cost accounting has to account for that difference: adding the
+ * cache counts to `promptTokens` double-counts them on a service that
+ * reports gross.
+ *
+ * - `promptTokens`: number of tokens in the input prompt, net or gross of the
+ *   cache counts depending on the service. Includes tool results the
+ *   provider feeds back to the model, which are billed as input.
+ * - `completionTokens`: number of tokens in the generated completion,
+ *   including any reasoning tokens.
+ * - `totalTokens`: total number of tokens used, including any cached input
+ *   tokens.
+ * - `cacheReadInputTokens`: number of tokens read from cache, if applicable.
+ *   Billed below the input rate.
+ * - `cacheCreationInputTokens`: number of tokens written to cache, if
+ *   applicable. Billed at or above the input rate.
+ * - `reasoningTokens`: number of completion tokens used for reasoning, if applicable.
+ * - `inputAudioTokens`: number of prompt tokens that were audio, if applicable.
+ * - `outputAudioTokens`: number of completion tokens that were audio, if applicable.
+ * - `cacheReadInputAudioTokens`: number of cache-read tokens that were audio, if applicable.
+ */
+export class LLMTokenUsage {
+    promptTokens;
+    completionTokens;
+    totalTokens;
+    cacheReadInputTokens;
+    cacheCreationInputTokens;
+    reasoningTokens;
+    inputAudioTokens;
+    outputAudioTokens;
+    cacheReadInputAudioTokens;
+    constructor(options) {
+        this.promptTokens = options.promptTokens;
+        this.completionTokens = options.completionTokens;
+        this.totalTokens = options.totalTokens;
+        this.cacheReadInputTokens = options.cacheReadInputTokens ?? null;
+        this.cacheCreationInputTokens = options.cacheCreationInputTokens ?? null;
+        this.reasoningTokens = options.reasoningTokens ?? null;
+        this.inputAudioTokens = options.inputAudioTokens ?? null;
+        this.outputAudioTokens = options.outputAudioTokens ?? null;
+        this.cacheReadInputAudioTokens = options.cacheReadInputAudioTokens ?? null;
+    }
+}
+/**
+ * LLM token usage metrics data.
+ *
+ * - `value`: token usage statistics for the LLM operation.
+ */
+export class LLMUsageMetricsData extends MetricsData {
+    value;
+    constructor(options) {
+        super(options);
+        this.value = options.value;
+    }
+}
+/**
+ * Usage statistics for STT operations.
+ *
+ * Reports raw usage, not cost. Values are incremental deltas since the
+ * previous usage report; consumers sum them across a session.
+ *
+ * Continuous STT services stream all input audio (including silence), so
+ * their summed `audioSeconds` approximates the stream duration — which
+ * is what most streaming providers bill. Segmented STT services submit
+ * only the detected speech segments, so their sum covers just those
+ * segments.
+ *
+ * - `audioSeconds`: client-measured seconds of audio submitted to the
+ *   service since the last usage report.
+ */
+export class STTUsage {
+    audioSeconds;
+    constructor(options) {
+        this.audioSeconds = options.audioSeconds;
+    }
+}
+/**
+ * Speech-to-Text usage metrics data.
+ *
+ * - `value`: usage statistics for the STT operation.
+ */
+export class STTUsageMetricsData extends MetricsData {
+    value;
+    constructor(options) {
+        super(options);
+        this.value = options.value;
+    }
+}
+/**
+ * Text-to-Speech usage metrics data.
+ *
+ * - `value`: number of characters processed by TTS.
+ */
+export class TTSUsageMetricsData extends MetricsData {
+    value;
+    constructor(options) {
+        super(options);
+        this.value = options.value;
+    }
+}
+/**
+ * Text aggregation time metrics data.
+ *
+ * Measures the time from the first LLM token to the first complete sentence,
+ * representing the latency cost of sentence aggregation in the TTS pipeline.
+ *
+ * - `value`: aggregation time in seconds.
+ */
+export class TextAggregationMetricsData extends MetricsData {
+    value;
+    constructor(options) {
+        super(options);
+        this.value = options.value;
+    }
+}
+/**
+ * Metrics data for turn detection predictions.
+ *
+ * - `isComplete`: whether the turn is predicted to be complete.
+ * - `probability`: confidence probability of the turn completion prediction.
+ * - `e2eProcessingTimeMs`: end-to-end processing time in milliseconds,
+ *   measured from VAD speech-to-silence transition to turn completion.
+ */
+export class TurnMetricsData extends MetricsData {
+    isComplete;
+    probability;
+    e2eProcessingTimeMs;
+    constructor(options) {
+        super(options);
+        this.isComplete = options.isComplete;
+        this.probability = options.probability;
+        this.e2eProcessingTimeMs = options.e2eProcessingTimeMs;
+    }
+}
+//# sourceMappingURL=metrics.js.map