@pipedog/core 0.0.0 → 0.2.0

package/dist/classifiers/typesafe/jev/classifier.d.ts

@@ -0,0 +1,70 @@
+import { LLMTokenUsage } from "../../../metrics/metrics.ts";
+import type { BaseTaskManager } from "../../../utils/asyncio/task_manager.ts";
+import { BaseClassifier, type BaseClassifierOptions, type ClassifierImage, type ClassifierQuestion, type ClassifierResult, type ClassifierValue } from "../../base_classifier.ts";
+import { JevClient } from "./client.ts";
+/** The most options Jev takes in one choice question. */
+export declare const JEV_MAX_CHOICE_OPTIONS = 255;
+export interface JevClassifierOptions extends BaseClassifierOptions {
+    /** Jev API key, when the classifier should have a client of its own. */
+    apiKey?: string | null;
+    /** A client to share. One of `apiKey` and `client` is required. */
+    client?: JevClient | null;
+    /** The Jev model a client of its own asks. */
+    model?: string;
+    /** Where a client of its own sends its questions. */
+    baseUrl?: string;
+    /** Seconds a client of its own waits for an answer. */
+    timeout?: number;
+}
+/**
+ * Answers questions by asking Jev.
+ *
+ * Jev's probabilities are calibrated. Build one with an API key to get a
+ * client of its own, or pass a `JevClient` to share one between several
+ * classifiers. A client the classifier created is closed in `cleanup()`; a
+ * shared one is left to whoever made it.
+ *
+ * Jev can see PNG and JPEG images, 256 to 1568 pixels on each side. It reads
+ * them as part of the state. TypeSafe offers images as a preview, so their
+ * limits may change between Jev releases.
+ *
+ * @example
+ * const client = new JevClient({ apiKey: process.env.TYPESAFE_API_KEY! });
+ * const turnClassifier = new JevClassifier({ client });
+ * const voicemailClassifier = new JevClassifier({ client });
+ */
+export declare class JevClassifier extends BaseClassifier {
+    protected _ownsClient: boolean;
+    protected _client: JevClient;
+    constructor(options?: JevClassifierOptions);
+    /** The client this classifier asks through. */
+    get client(): JevClient;
+    /**
+     * Open the connection to Jev ahead of the first question.
+     *
+     * A connection that cannot be opened now is only a warning: the first
+     * question opens it itself.
+     *
+     * @param taskManager The task manager of the owner.
+     */
+    setup(taskManager: BaseTaskManager): Promise<void>;
+    /** Close the client if this classifier created it. */
+    cleanup(): Promise<void>;
+    /** The Jev model the questions go to. */
+    get model(): string;
+    /** Jev can see images. */
+    get supportsImages(): boolean;
+    /** Answer the questions in one request. */
+    protected _ask(state: ClassifierValue, questions: Readonly<Record<string, ClassifierQuestion>>, images?: readonly ClassifierImage[]): Promise<[Record<string, ClassifierResult>, LLMTokenUsage]>;
+    /** An image in Jev's own format. */
+    protected _asset(image: ClassifierImage): Record<string, unknown>;
+    /** A question in Jev's own format. */
+    protected _toJev(question: ClassifierQuestion): Record<string, unknown>;
+    /** A result built from Jev's answer to the question. */
+    protected _fromJev(question: ClassifierQuestion, answer: Record<string, unknown>): ClassifierResult;
+    /** The number Jev wrote under `key`, or a ClassifierError if it did not. */
+    protected _number(answer: Record<string, unknown>, key: string): number;
+    /** The probability Jev wrote for each key, 0 for the ones it left out. */
+    protected _probabilities(answer: Record<string, unknown>, keys: string[]): Record<string, number>;
+}
+//# sourceMappingURL=classifier.d.ts.map

package/dist/classifiers/typesafe/jev/classifier.js

@@ -0,0 +1,220 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/classifiers/typesafe/jev/classifier.py
+/**
+ * Classifier backed by Jev, TypeSafe's hosted classification model.
+ *
+ * `JevClassifier` turns each question into a request and each reply into a
+ * result, through a `JevClient`.
+ */
+import { rethrowIfCancelled } from "@pipedog/asyncio";
+import { LLMTokenUsage } from "../../../metrics/metrics.js";
+import { logger } from "../../../utils/logger.js";
+import { BaseClassifier, ChoiceQuestion, ChoiceResult, ClassifierError, ScoreLevel, ScoreResult, YesNoQuestion, YesNoResult, } from "../../base_classifier.js";
+import { bytesToBase64, isDict, orEmpty, toFloat } from "../../http_client.js";
+import { DEFAULT_BASE_URL, DEFAULT_MODEL, DEFAULT_TIMEOUT, JevClient } from "./client.js";
+/** The most options Jev takes in one choice question. */
+export const JEV_MAX_CHOICE_OPTIONS = 255;
+/** Jev's name for each image type it reads. */
+const JEV_IMAGE_FORMATS = { "image/png": "png", "image/jpeg": "jpg" };
+/**
+ * Answers questions by asking Jev.
+ *
+ * Jev's probabilities are calibrated. Build one with an API key to get a
+ * client of its own, or pass a `JevClient` to share one between several
+ * classifiers. A client the classifier created is closed in `cleanup()`; a
+ * shared one is left to whoever made it.
+ *
+ * Jev can see PNG and JPEG images, 256 to 1568 pixels on each side. It reads
+ * them as part of the state. TypeSafe offers images as a preview, so their
+ * limits may change between Jev releases.
+ *
+ * @example
+ * const client = new JevClient({ apiKey: process.env.TYPESAFE_API_KEY! });
+ * const turnClassifier = new JevClassifier({ client });
+ * const voicemailClassifier = new JevClassifier({ client });
+ */
+export class JevClassifier extends BaseClassifier {
+    _ownsClient;
+    _client;
+    constructor(options = {}) {
+        super(options);
+        this._ownsClient = options.client == null;
+        let client = options.client ?? null;
+        if (!client) {
+            if (!options.apiKey) {
+                throw new Error("JevClassifier needs an API key or a JevClient");
+            }
+            client = new JevClient({
+                apiKey: options.apiKey,
+                model: options.model ?? DEFAULT_MODEL,
+                baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+                timeout: options.timeout ?? DEFAULT_TIMEOUT,
+            });
+        }
+        this._client = client;
+    }
+    /** The client this classifier asks through. */
+    get client() {
+        return this._client;
+    }
+    /**
+     * Open the connection to Jev ahead of the first question.
+     *
+     * A connection that cannot be opened now is only a warning: the first
+     * question opens it itself.
+     *
+     * @param taskManager The task manager of the owner.
+     */
+    async setup(taskManager) {
+        await super.setup(taskManager);
+        try {
+            await this._client.connect();
+        }
+        catch (e) {
+            if (!(e instanceof ClassifierError)) {
+                throw e;
+            }
+            logger.warning(`${this}: ${e.message}`);
+        }
+    }
+    /** Close the client if this classifier created it. */
+    async cleanup() {
+        await super.cleanup();
+        if (this._ownsClient) {
+            await this._client.close();
+        }
+    }
+    /** The Jev model the questions go to. */
+    get model() {
+        return this._client.model;
+    }
+    /** Jev can see images. */
+    get supportsImages() {
+        return true;
+    }
+    /** Answer the questions in one request. */
+    async _ask(state, questions, images = []) {
+        const assets = {};
+        for (const image of images) {
+            assets[crypto.randomUUID()] = this._asset(image);
+        }
+        let requestState = state;
+        if (Object.keys(assets).length > 0) {
+            // Jev reads an image wherever its reference appears, so the references
+            // go ahead of the state they come with.
+            requestState = { images: Object.keys(assets), state };
+        }
+        const jevQuestions = {};
+        for (const [name, q] of Object.entries(questions)) {
+            jevQuestions[name] = this._toJev(q);
+        }
+        const [answers, usage] = await this._client.ask(requestState, jevQuestions, assets);
+        const results = {};
+        for (const [name, question] of Object.entries(questions)) {
+            results[name] = this._fromJev(question, answers[name]);
+        }
+        return [
+            results,
+            new LLMTokenUsage({
+                promptTokens: usage.inputTokens,
+                completionTokens: usage.outputTokens,
+                totalTokens: usage.inputTokens + usage.outputTokens,
+            }),
+        ];
+    }
+    /** An image in Jev's own format. */
+    _asset(image) {
+        const format = JEV_IMAGE_FORMATS[image.contentType];
+        if (!format) {
+            throw new ClassifierError(`Jev takes PNG or JPEG images, got ${image.contentType}`);
+        }
+        return {
+            type: "image",
+            format,
+            data_base64: bytesToBase64(image.data),
+        };
+    }
+    /** A question in Jev's own format. */
+    _toJev(question) {
+        if (question instanceof YesNoQuestion) {
+            const jev = { type: "noul", instructions: question.instructions };
+            if (question.yes !== null || question.no !== null) {
+                jev.criteria = { true: orEmpty(question.yes), false: orEmpty(question.no) };
+            }
+            return jev;
+        }
+        if (question instanceof ChoiceQuestion) {
+            const count = Object.keys(question.options).length;
+            if (count > JEV_MAX_CHOICE_OPTIONS) {
+                throw new ClassifierError(`Jev takes at most ${JEV_MAX_CHOICE_OPTIONS} options, got ${count}`);
+            }
+            return {
+                type: "choice",
+                instructions: question.instructions,
+                criteria: question.options,
+            };
+        }
+        return { type: "score", instructions: question.instructions, criteria: question.levels };
+    }
+    /** A result built from Jev's answer to the question. */
+    _fromJev(question, answer) {
+        if (question instanceof YesNoQuestion) {
+            return new YesNoResult({ probability: this._number(answer, "noul") });
+        }
+        if (question instanceof ChoiceQuestion) {
+            const choice = String(answer.choice ?? "");
+            if (!Object.hasOwn(question.options, choice)) {
+                throw new ClassifierError(`Jev chose '${choice}', which is not an option`);
+            }
+            const probabilities = this._probabilities(answer, Object.keys(question.options));
+            return new ChoiceResult({
+                choice,
+                probabilities,
+                confidence: this._number(answer, "confidence"),
+            });
+        }
+        // Jev keys level probabilities by position.
+        const positions = question.levels.map((_level, index) => String(index));
+        const probabilities = this._probabilities(answer, positions);
+        return new ScoreResult({
+            score: this._number(answer, "score"),
+            levels: question.levels.map((level, index) => new ScoreLevel({ level, probability: probabilities[positions[index]] ?? 0 })),
+            confidence: this._number(answer, "confidence"),
+        });
+    }
+    /** The number Jev wrote under `key`, or a ClassifierError if it did not. */
+    _number(answer, key) {
+        try {
+            if (!Object.hasOwn(answer, key)) {
+                throw new RangeError(key);
+            }
+            return toFloat(answer[key]);
+        }
+        catch (e) {
+            rethrowIfCancelled(e);
+            throw new ClassifierError(`Jev reply has no usable '${key}'`, { cause: e });
+        }
+    }
+    /** The probability Jev wrote for each key, 0 for the ones it left out. */
+    _probabilities(answer, keys) {
+        // Python's `answer.get("probabilities") or {}`: an empty list is falsy too.
+        const raw = answer.probabilities;
+        const given = !raw || (Array.isArray(raw) && raw.length === 0) ? {} : raw;
+        try {
+            if (!isDict(given)) {
+                throw new TypeError("probabilities is not an object");
+            }
+            return Object.fromEntries(keys.map((key) => [key, toFloat(Object.hasOwn(given, key) ? given[key] : 0.0)]));
+        }
+        catch (e) {
+            rethrowIfCancelled(e);
+            throw new ClassifierError(`Jev reply has an unusable probability: ${e.message}`, {
+                cause: e,
+            });
+        }
+    }
+}
+//# sourceMappingURL=classifier.js.map

package/dist/classifiers/typesafe/jev/client.d.ts

@@ -0,0 +1,105 @@
+/**
+ * HTTP client for Jev, TypeSafe's hosted classification model.
+ *
+ * One `JevClient` holds one connection pool, adds the auth header, retries
+ * when Jev is busy, and counts the tokens every request used. Several
+ * `JevClassifier` instances can share one.
+ *
+ * PORTING NOTE: upstream uses `httpx` with HTTP/2 and a 240 s keep-alive;
+ * here requests go through `fetch` (see `../../http_client.ts`), and
+ * connection reuse is left to the runtime.
+ */
+import { Lock } from "@pipedog/asyncio";
+import { HttpClient, type HttpResponse } from "../../http_client.ts";
+/** Where the API is served. */
+export declare const DEFAULT_BASE_URL = "https://api.typesafe.ai";
+/** The Jev model to ask. Pinned so thresholds tuned against it hold. */
+export declare const DEFAULT_MODEL = "jev-1.13.0";
+/** Seconds to wait for a reply before giving up. */
+export declare const DEFAULT_TIMEOUT = 10;
+export interface JevUsageOptions {
+    /** Tokens sent. */
+    inputTokens?: number;
+    /** Tokens received. */
+    outputTokens?: number;
+}
+/** Tokens Jev used: for one request, or over every request in `JevClient.usage`. */
+export declare class JevUsage {
+    inputTokens: number;
+    outputTokens: number;
+    constructor(options?: JevUsageOptions);
+    /** Build a usage from Jev's wire format (`input_tokens`, `output_tokens`). */
+    static fromDict(data: Record<string, unknown>): JevUsage;
+}
+export interface JevClientOptions {
+    /** Jev API key. */
+    apiKey: string;
+    /** Where the API is served. */
+    baseUrl?: string;
+    /**
+     * The Jev model to ask. Pinned so thresholds tuned against it keep
+     * holding; `jev-latest` follows TypeSafe's newest release.
+     */
+    model?: string;
+    /** Seconds to wait for a reply before giving up. */
+    timeout?: number;
+    /** How many times to retry a request Jev refused because it was busy. */
+    maxRetries?: number;
+    /** The transport requests go through; the global `fetch` by default. */
+    fetch?: typeof fetch;
+}
+/**
+ * HTTP client for Jev's `systemone` endpoint.
+ *
+ * Many small requests can be in flight at the same time. Retries with
+ * backoff when Jev answers 429 or 529. Counts the tokens every request used
+ * in `usage`.
+ *
+ * `connect()` opens the connection ahead of the first question, and
+ * `close()` releases it.
+ */
+export declare class JevClient {
+    protected _model: string;
+    protected _maxRetries: number;
+    protected _usage: JevUsage;
+    protected _connected: boolean;
+    protected _connectLock: Lock;
+    protected _http: HttpClient;
+    constructor(options: JevClientOptions);
+    /** The Jev model the questions go to. */
+    get model(): string;
+    /** Tokens used so far, over every request. */
+    get usage(): JevUsage;
+    /**
+     * Open the connection to Jev.
+     *
+     * Lists the models, the cheapest request there is, so the first question
+     * finds the connection already open. Connects once: a client shared by
+     * several classifiers is asked by each of them, and only the first call
+     * sends anything.
+     *
+     * @throws ClassifierError If Jev could not be reached or refused the request.
+     */
+    connect(): Promise<void>;
+    /** Close the connection pool. */
+    close(): Promise<void>;
+    /**
+     * Send questions about one state and return Jev's answers.
+     *
+     * @param state What the questions are about.
+     * @param questions The questions by name, each in Jev's own format: a
+     *   `type` of `noul`, `choice` or `score`, `instructions`, and `criteria`.
+     * @param assets Images by reference, each in Jev's own format: a `format`
+     *   and the `data_base64` bytes. Each reference must appear in the state or
+     *   the questions, where Jev reads the image in its place.
+     * @returns The answers by the same names, in Jev's own format, and the
+     *   tokens the request used.
+     * @throws ClassifierError If Jev rejected the request, kept refusing it
+     *   because it was busy, could not be reached, or left a question
+     *   unanswered.
+     */
+    ask(state: unknown, questions: Readonly<Record<string, Record<string, unknown>>>, assets?: Readonly<Record<string, Record<string, unknown>>> | null): Promise<[Record<string, Record<string, unknown>>, JevUsage]>;
+    /** The reason Jev gave for rejecting a request, if it gave one. */
+    protected _errorMessage(response: HttpResponse): string | null;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/classifiers/typesafe/jev/client.js

@@ -0,0 +1,233 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/classifiers/typesafe/jev/client.py
+/**
+ * HTTP client for Jev, TypeSafe's hosted classification model.
+ *
+ * One `JevClient` holds one connection pool, adds the auth header, retries
+ * when Jev is busy, and counts the tokens every request used. Several
+ * `JevClassifier` instances can share one.
+ *
+ * PORTING NOTE: upstream uses `httpx` with HTTP/2 and a 240 s keep-alive;
+ * here requests go through `fetch` (see `../../http_client.ts`), and
+ * connection reuse is left to the runtime.
+ */
+import { Lock, rethrowIfCancelled, sleep } from "@pipedog/asyncio";
+import { logger } from "../../../utils/logger.js";
+import { exponentialBackoffTime } from "../../../utils/network.js";
+import { ClassifierError } from "../../base_classifier.js";
+import { errorRepr, HttpClient, HttpError, isDict } from "../../http_client.js";
+/** Jev answers a request with this status when the caller is rate limited. */
+const TOO_MANY_REQUESTS = 429;
+/** Jev answers a request with this status when it is temporarily overloaded. */
+const OVERLOADED = 529;
+/** Jev reads images only in requests that send this header. */
+const IMAGES_HEADER = "TypeSafe-Danger-Zone-Images";
+/** Where the API is served. */
+export const DEFAULT_BASE_URL = "https://api.typesafe.ai";
+/** The Jev model to ask. Pinned so thresholds tuned against it hold. */
+export const DEFAULT_MODEL = "jev-1.13.0";
+/** Seconds to wait for a reply before giving up. */
+export const DEFAULT_TIMEOUT = 10.0;
+/** Tokens Jev used: for one request, or over every request in `JevClient.usage`. */
+export class JevUsage {
+    inputTokens;
+    outputTokens;
+    constructor(options = {}) {
+        this.inputTokens = options.inputTokens ?? 0;
+        this.outputTokens = options.outputTokens ?? 0;
+    }
+    /** Build a usage from Jev's wire format (`input_tokens`, `output_tokens`). */
+    static fromDict(data) {
+        return new JevUsage({
+            inputTokens: data.input_tokens ?? 0,
+            outputTokens: data.output_tokens ?? 0,
+        });
+    }
+}
+/**
+ * HTTP client for Jev's `systemone` endpoint.
+ *
+ * Many small requests can be in flight at the same time. Retries with
+ * backoff when Jev answers 429 or 529. Counts the tokens every request used
+ * in `usage`.
+ *
+ * `connect()` opens the connection ahead of the first question, and
+ * `close()` releases it.
+ */
+export class JevClient {
+    _model;
+    _maxRetries;
+    _usage = new JevUsage();
+    _connected = false;
+    _connectLock = new Lock();
+    _http;
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error("JevClient needs an API key");
+        }
+        this._model = options.model ?? DEFAULT_MODEL;
+        this._maxRetries = options.maxRetries ?? 3;
+        this._http = new HttpClient({
+            baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+            headers: { Authorization: `Bearer ${options.apiKey}` },
+            timeout: options.timeout ?? DEFAULT_TIMEOUT,
+            fetch: options.fetch,
+        });
+    }
+    /** The Jev model the questions go to. */
+    get model() {
+        return this._model;
+    }
+    /** Tokens used so far, over every request. */
+    get usage() {
+        return this._usage;
+    }
+    /**
+     * Open the connection to Jev.
+     *
+     * Lists the models, the cheapest request there is, so the first question
+     * finds the connection already open. Connects once: a client shared by
+     * several classifiers is asked by each of them, and only the first call
+     * sends anything.
+     *
+     * @throws ClassifierError If Jev could not be reached or refused the request.
+     */
+    async connect() {
+        await this._connectLock.run(async () => {
+            if (this._connected) {
+                return;
+            }
+            let response;
+            try {
+                response = await this._http.get("/v1/models");
+            }
+            catch (e) {
+                if (e instanceof HttpError) {
+                    throw new ClassifierError(`could not connect to Jev: ${e.message}`, { cause: e });
+                }
+                throw e;
+            }
+            if (response.statusCode !== 200) {
+                throw new ClassifierError(`Jev refused the connection: HTTP ${response.statusCode}`);
+            }
+            this._connected = true;
+        });
+    }
+    /** Close the connection pool. */
+    async close() {
+        this._connected = false;
+        await this._http.aclose();
+    }
+    /**
+     * Send questions about one state and return Jev's answers.
+     *
+     * @param state What the questions are about.
+     * @param questions The questions by name, each in Jev's own format: a
+     *   `type` of `noul`, `choice` or `score`, `instructions`, and `criteria`.
+     * @param assets Images by reference, each in Jev's own format: a `format`
+     *   and the `data_base64` bytes. Each reference must appear in the state or
+     *   the questions, where Jev reads the image in its place.
+     * @returns The answers by the same names, in Jev's own format, and the
+     *   tokens the request used.
+     * @throws ClassifierError If Jev rejected the request, kept refusing it
+     *   because it was busy, could not be reached, or left a question
+     *   unanswered.
+     */
+    async ask(state, questions, assets = null) {
+        const body = {
+            model: this._model,
+            state,
+            questions: { ...questions },
+        };
+        const headers = {};
+        if (assets && Object.keys(assets).length > 0) {
+            body.assets = { ...assets };
+            headers[IMAGES_HEADER] = "true";
+        }
+        let attempt = 0;
+        while (true) {
+            attempt += 1;
+            let response;
+            try {
+                response = await this._http.post("/v1/systemone", { json: body, headers });
+            }
+            catch (e) {
+                if (e instanceof HttpError) {
+                    // Some errors, such as a timeout, carry no useful message.
+                    throw new ClassifierError(`Jev request failed: ${errorRepr(e)}`, { cause: e });
+                }
+                throw e;
+            }
+            if (response.statusCode === TOO_MANY_REQUESTS || response.statusCode === OVERLOADED) {
+                if (attempt > this._maxRetries) {
+                    throw new ClassifierError(`Jev is busy (HTTP ${response.statusCode}) after ${attempt} attempts`);
+                }
+                const wait = exponentialBackoffTime(attempt, 0.25, 2.0, 0.25);
+                logger.debug(`Jev answered ${response.statusCode}, retrying in ${wait}s`);
+                await sleep(wait);
+                continue;
+            }
+            if (response.statusCode !== 200) {
+                let message = `Jev rejected the request: HTTP ${response.statusCode}`;
+                const reason = this._errorMessage(response);
+                if (reason) {
+                    message += `: ${reason}`;
+                }
+                throw new ClassifierError(message);
+            }
+            let data;
+            try {
+                data = response.json();
+            }
+            catch (e) {
+                rethrowIfCancelled(e);
+                throw new ClassifierError(`Jev reply is not valid JSON: ${e.message}`, {
+                    cause: e,
+                });
+            }
+            if (!isDict(data)) {
+                throw new ClassifierError("Jev reply is not a JSON object");
+            }
+            const usage = data.usage;
+            const requestUsage = isDict(usage) ? JevUsage.fromDict(usage) : new JevUsage();
+            this._usage.inputTokens += requestUsage.inputTokens;
+            this._usage.outputTokens += requestUsage.outputTokens;
+            const answers = data.answers;
+            if (!isDict(answers)) {
+                throw new ClassifierError("Jev reply has no answers");
+            }
+            const missing = Object.keys(questions).filter((name) => !isDict(answers[name]));
+            if (missing.length > 0) {
+                throw new ClassifierError(`Jev reply has no answer for ${missing.join(", ")}`);
+            }
+            const result = {};
+            for (const name of Object.keys(questions)) {
+                result[name] = answers[name];
+            }
+            return [result, requestUsage];
+        }
+    }
+    /** The reason Jev gave for rejecting a request, if it gave one. */
+    _errorMessage(response) {
+        let detail;
+        try {
+            const data = response.json();
+            if (!isDict(data)) {
+                return null;
+            }
+            detail = data.detail;
+        }
+        catch (e) {
+            rethrowIfCancelled(e);
+            return null;
+        }
+        if (isDict(detail)) {
+            detail = detail.message;
+        }
+        return typeof detail === "string" && detail ? detail : null;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/classifiers/typesafe/jev/index.d.ts

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

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

package/dist/clocks/base_clock.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Abstract base class for clock implementations.
+ *
+ * Provides a common interface for timing operations used in Pipecat
+ * for synchronization, scheduling, and time-based processing.
+ */
+export declare abstract class BaseClock {
+    /** Get the current time value (unit and reference depend on the implementation). */
+    abstract getTime(): number;
+    /** Start or initialize the clock. Call before `getTime()`. */
+    abstract start(): void;
+}
+//# sourceMappingURL=base_clock.d.ts.map

package/dist/clocks/base_clock.js

@@ -0,0 +1,14 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/clocks/base_clock.py
+/**
+ * Abstract base class for clock implementations.
+ *
+ * Provides a common interface for timing operations used in Pipecat
+ * for synchronization, scheduling, and time-based processing.
+ */
+export class BaseClock {
+}
+//# sourceMappingURL=base_clock.js.map

package/dist/clocks/index.d.ts

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

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