@pipedog/core 0.0.0 → 0.2.0

package/dist/classifiers/cloudflare/clef/client.d.ts

@@ -0,0 +1,104 @@
+/**
+ * HTTP client for Clef, Cloudflare's decision model on Workers AI.
+ *
+ * One `ClefClient` holds one connection pool, adds the auth header, retries
+ * when Workers AI is busy, and counts the tokens every request used. Several
+ * `ClefClassifier` 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 Cloudflare's API is served. */
+export declare const CLOUDFLARE_API_URL = "https://api.cloudflare.com/client/v4";
+/** The Clef model to ask. */
+export declare const DEFAULT_MODEL = "clef";
+/** Seconds to wait for a reply before giving up. */
+export declare const DEFAULT_TIMEOUT = 10;
+export interface ClefUsageOptions {
+    /** Tokens sent. */
+    inputTokens?: number;
+    /** Tokens received. */
+    outputTokens?: number;
+}
+/** Tokens Clef used: for one request, or over every request in `ClefClient.usage`. */
+export declare class ClefUsage {
+    inputTokens: number;
+    outputTokens: number;
+    constructor(options?: ClefUsageOptions);
+    /** Build a usage from Clef's wire format (`input_tokens`, `output_tokens`). */
+    static fromDict(data: Record<string, unknown>): ClefUsage;
+}
+export interface ClefClientOptions {
+    /** Cloudflare account ID. */
+    accountId: string;
+    /** Cloudflare API token with Workers AI access. */
+    apiKey: string;
+    /** The Clef model to ask: `clef`, or `clef-flash` for faster answers. */
+    model?: string;
+    /** Seconds to wait for a reply before giving up. */
+    timeout?: number;
+    /** How many times to retry a request Workers AI refused because it was busy. */
+    maxRetries?: number;
+    /** The transport requests go through; the global `fetch` by default. */
+    fetch?: typeof fetch;
+}
+/**
+ * HTTP client for Clef on Workers AI.
+ *
+ * Many small requests can be in flight at the same time. Retries with
+ * backoff when Workers AI answers 429. Counts the tokens every request used
+ * in `usage`. Errors carry the reasons Cloudflare gave.
+ *
+ * `connect()` opens the connection ahead of the first question, and
+ * `close()` releases it.
+ */
+export declare class ClefClient {
+    protected _model: string;
+    protected _maxRetries: number;
+    protected _usage: ClefUsage;
+    protected _connected: boolean;
+    protected _connectLock: Lock;
+    protected _http: HttpClient;
+    constructor(options: ClefClientOptions);
+    /** The Clef model the questions go to. */
+    get model(): string;
+    /** Tokens used so far, over every request. */
+    get usage(): ClefUsage;
+    /**
+     * Open the connection to Workers AI.
+     *
+     * Asks for the model's schema, a cheap request that also checks the token
+     * and the model name. Connects once: a client shared by several
+     * classifiers is asked by each of them, and only the first call sends
+     * anything.
+     *
+     * @throws ClassifierError If Workers AI 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 Clef's answers.
+     *
+     * @param state What the questions are about.
+     * @param questions The questions by name, each in Clef's own format: a
+     *   `type` of `noul`, `choice` or `score`, `instructions`, and `criteria`.
+     * @param images Images the questions can look at, each in Clef's own
+     *   format: a `content_type` and the `base64` bytes.
+     * @returns The answers by the same names, in Clef's own format, and the
+     *   tokens the request used.
+     * @throws ClassifierError If Clef 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>>>, images?: readonly Readonly<Record<string, string>>[]): Promise<[Record<string, Record<string, unknown>>, ClefUsage]>;
+    /** The reply inside Cloudflare's `result` envelope. */
+    protected _result(response: HttpResponse): Record<string, unknown>;
+    /** A failed response's HTTP status and the reasons Cloudflare gave. */
+    protected _failure(response: HttpResponse): string;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/classifiers/cloudflare/clef/client.js

@@ -0,0 +1,234 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/classifiers/cloudflare/clef/client.py
+/**
+ * HTTP client for Clef, Cloudflare's decision model on Workers AI.
+ *
+ * One `ClefClient` holds one connection pool, adds the auth header, retries
+ * when Workers AI is busy, and counts the tokens every request used. Several
+ * `ClefClassifier` 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";
+/** Workers AI answers a request with this status when it is out of capacity. */
+const TOO_MANY_REQUESTS = 429;
+/** Where Cloudflare's API is served. */
+export const CLOUDFLARE_API_URL = "https://api.cloudflare.com/client/v4";
+/** The Clef model to ask. */
+export const DEFAULT_MODEL = "clef";
+/** Seconds to wait for a reply before giving up. */
+export const DEFAULT_TIMEOUT = 10.0;
+/** Tokens Clef used: for one request, or over every request in `ClefClient.usage`. */
+export class ClefUsage {
+    inputTokens;
+    outputTokens;
+    constructor(options = {}) {
+        this.inputTokens = options.inputTokens ?? 0;
+        this.outputTokens = options.outputTokens ?? 0;
+    }
+    /** Build a usage from Clef's wire format (`input_tokens`, `output_tokens`). */
+    static fromDict(data) {
+        return new ClefUsage({
+            inputTokens: data.input_tokens ?? 0,
+            outputTokens: data.output_tokens ?? 0,
+        });
+    }
+}
+/**
+ * HTTP client for Clef on Workers AI.
+ *
+ * Many small requests can be in flight at the same time. Retries with
+ * backoff when Workers AI answers 429. Counts the tokens every request used
+ * in `usage`. Errors carry the reasons Cloudflare gave.
+ *
+ * `connect()` opens the connection ahead of the first question, and
+ * `close()` releases it.
+ */
+export class ClefClient {
+    _model;
+    _maxRetries;
+    _usage = new ClefUsage();
+    _connected = false;
+    _connectLock = new Lock();
+    _http;
+    constructor(options) {
+        if (!options.accountId) {
+            throw new Error("ClefClient needs a Cloudflare account ID");
+        }
+        if (!options.apiKey) {
+            throw new Error("ClefClient needs a Cloudflare API token");
+        }
+        this._model = options.model ?? DEFAULT_MODEL;
+        this._maxRetries = options.maxRetries ?? 3;
+        this._http = new HttpClient({
+            baseUrl: `${CLOUDFLARE_API_URL}/accounts/${options.accountId}/ai`,
+            headers: { Authorization: `Bearer ${options.apiKey}` },
+            timeout: options.timeout ?? DEFAULT_TIMEOUT,
+            fetch: options.fetch,
+        });
+    }
+    /** The Clef 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 Workers AI.
+     *
+     * Asks for the model's schema, a cheap request that also checks the token
+     * and the model name. Connects once: a client shared by several
+     * classifiers is asked by each of them, and only the first call sends
+     * anything.
+     *
+     * @throws ClassifierError If Workers AI 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("/models/schema", {
+                    params: { model: `@cf/cloudflare/${this._model}` },
+                });
+            }
+            catch (e) {
+                if (e instanceof HttpError) {
+                    throw new ClassifierError(`could not connect to Clef: ${e.message}`, { cause: e });
+                }
+                throw e;
+            }
+            if (response.statusCode !== 200) {
+                throw new ClassifierError(`Clef refused the connection: ${this._failure(response)}`);
+            }
+            this._connected = true;
+        });
+    }
+    /** Close the connection pool. */
+    async close() {
+        this._connected = false;
+        await this._http.aclose();
+    }
+    /**
+     * Send questions about one state and return Clef's answers.
+     *
+     * @param state What the questions are about.
+     * @param questions The questions by name, each in Clef's own format: a
+     *   `type` of `noul`, `choice` or `score`, `instructions`, and `criteria`.
+     * @param images Images the questions can look at, each in Clef's own
+     *   format: a `content_type` and the `base64` bytes.
+     * @returns The answers by the same names, in Clef's own format, and the
+     *   tokens the request used.
+     * @throws ClassifierError If Clef rejected the request, kept refusing it
+     *   because it was busy, could not be reached, or left a question
+     *   unanswered.
+     */
+    async ask(state, questions, images = []) {
+        const body = {
+            model: this._model,
+            state,
+            questions: { ...questions },
+        };
+        if (images.length > 0) {
+            body.images = images.map((image) => ({ ...image }));
+        }
+        let attempt = 0;
+        while (true) {
+            attempt += 1;
+            let response;
+            try {
+                response = await this._http.post(`/run/@cf/cloudflare/${this._model}`, { json: body });
+            }
+            catch (e) {
+                if (e instanceof HttpError) {
+                    // Some errors, such as a timeout, carry no useful message.
+                    throw new ClassifierError(`Clef request failed: ${errorRepr(e)}`, { cause: e });
+                }
+                throw e;
+            }
+            if (response.statusCode === TOO_MANY_REQUESTS) {
+                if (attempt > this._maxRetries) {
+                    throw new ClassifierError(`Clef is busy (${this._failure(response)}) after ${attempt} attempts`);
+                }
+                const wait = exponentialBackoffTime(attempt, 0.25, 2.0, 0.25);
+                logger.debug(`Clef answered ${response.statusCode}, retrying in ${wait}s`);
+                await sleep(wait);
+                continue;
+            }
+            if (response.statusCode !== 200) {
+                throw new ClassifierError(`Clef rejected the request: ${this._failure(response)}`);
+            }
+            const result = this._result(response);
+            const usage = result.usage;
+            const requestUsage = isDict(usage) ? ClefUsage.fromDict(usage) : new ClefUsage();
+            this._usage.inputTokens += requestUsage.inputTokens;
+            this._usage.outputTokens += requestUsage.outputTokens;
+            const answers = result.answers;
+            if (!isDict(answers)) {
+                throw new ClassifierError("Clef reply has no answers");
+            }
+            const missing = Object.keys(questions).filter((name) => !isDict(answers[name]));
+            if (missing.length > 0) {
+                throw new ClassifierError(`Clef reply has no answer for ${missing.join(", ")}`);
+            }
+            const answered = {};
+            for (const name of Object.keys(questions)) {
+                answered[name] = answers[name];
+            }
+            return [answered, requestUsage];
+        }
+    }
+    /** The reply inside Cloudflare's `result` envelope. */
+    _result(response) {
+        let data;
+        try {
+            data = response.json();
+        }
+        catch (e) {
+            rethrowIfCancelled(e);
+            throw new ClassifierError(`Clef reply is not valid JSON: ${e.message}`, {
+                cause: e,
+            });
+        }
+        const result = isDict(data) ? data.result : null;
+        if (!isDict(result)) {
+            throw new ClassifierError("Clef reply has no result");
+        }
+        return result;
+    }
+    /** A failed response's HTTP status and the reasons Cloudflare gave. */
+    _failure(response) {
+        const status = `HTTP ${response.statusCode}`;
+        let errors;
+        try {
+            const data = response.json();
+            if (!isDict(data)) {
+                return status;
+            }
+            errors = data.errors;
+        }
+        catch (e) {
+            rethrowIfCancelled(e);
+            return status;
+        }
+        const reasons = (Array.isArray(errors) ? errors : [])
+            .filter((error) => isDict(error) && error.message)
+            .map((error) => String(error.message));
+        return reasons.length > 0 ? `${status}: ${reasons.join("; ")}` : status;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/classifiers/cloudflare/clef/index.d.ts

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

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

package/dist/classifiers/cloudflare/index.d.ts

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

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

package/dist/classifiers/http_client.d.ts

@@ -0,0 +1,70 @@
+/** A request could not be sent or answered (upstream's `httpx.HTTPError`). */
+export declare class HttpError extends Error {
+    name: string;
+}
+/** The request was not answered in time (upstream's `httpx.TimeoutException`). */
+export declare class HttpTimeoutError extends HttpError {
+    name: string;
+}
+/** Python's `repr()` of an exception: `Name('message')`. */
+export declare function errorRepr(e: unknown): string;
+/** A received response, its body already read. */
+export declare class HttpResponse {
+    readonly statusCode: number;
+    readonly text: string;
+    constructor(statusCode: number, text: string);
+    /** The body parsed as JSON; throws a SyntaxError if it is not JSON. */
+    json(): unknown;
+}
+export interface HttpClientOptions {
+    /** Prepended to every request path. */
+    baseUrl: string;
+    /** Headers sent with every request. */
+    headers?: Record<string, string>;
+    /** Seconds to wait for a reply before giving up. */
+    timeout?: number;
+    /** The transport; the global `fetch` by default. */
+    fetch?: typeof fetch;
+}
+export interface HttpRequestOptions {
+    /** Query parameters. */
+    params?: Record<string, string>;
+    /** A body to send as JSON. */
+    json?: unknown;
+    /** Headers for this request, on top of the client's. */
+    headers?: Record<string, string>;
+}
+/** Sends requests to one API. */
+export declare class HttpClient {
+    /** The transport requests go through; replace it to answer them in tests. */
+    transport: typeof fetch;
+    protected _baseUrl: string;
+    protected _headers: Record<string, string>;
+    protected _timeout: number;
+    protected _closed: boolean;
+    constructor(options: HttpClientOptions);
+    /** Whether the client has been closed. */
+    get isClosed(): boolean;
+    /** Send a GET request. */
+    get(path: string, options?: HttpRequestOptions): Promise<HttpResponse>;
+    /** Send a POST request. */
+    post(path: string, options?: HttpRequestOptions): Promise<HttpResponse>;
+    /**
+     * Send a request and read its whole body.
+     *
+     * @throws HttpError If the request could not be sent, or was not answered
+     *   within the timeout (`HttpTimeoutError`).
+     */
+    request(method: string, path: string, options?: HttpRequestOptions): Promise<HttpResponse>;
+    /** Close the client; later requests throw. */
+    aclose(): Promise<void>;
+}
+/** Base64 of `data`, without `Buffer`. */
+export declare function bytesToBase64(data: Uint8Array): string;
+/** Whether `value` is a JSON object (a Python dict). */
+export declare function isDict(value: unknown): value is Record<string, unknown>;
+/** Python's `float(value)`: a number from a number or numeric string, else a TypeError/ValueError. */
+export declare function toFloat(value: unknown): number;
+/** Python's `value or ""`: the value, or an empty string when it is falsy (null, "", {} or []). */
+export declare function orEmpty(value: unknown): unknown;
+//# sourceMappingURL=http_client.d.ts.map

package/dist/classifiers/http_client.js

@@ -0,0 +1,161 @@
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// A small fetch-based HTTP client for the hosted classifier clients, standing
+// in for the parts of `httpx.AsyncClient` they use: a base URL, default
+// headers, a per-request timeout, JSON bodies, and a swappable transport so
+// tests can answer requests without a network (as upstream tests swap in an
+// `httpx.MockTransport`).
+//
+// HTTP/2 and connection keep-alive are left to the runtime's `fetch`.
+import { abortable, currentSignal, rethrowIfCancelled } from "@pipedog/asyncio";
+/** A request could not be sent or answered (upstream's `httpx.HTTPError`). */
+export class HttpError extends Error {
+    name = "HttpError";
+}
+/** The request was not answered in time (upstream's `httpx.TimeoutException`). */
+export class HttpTimeoutError extends HttpError {
+    name = "HttpTimeoutError";
+}
+/** Python's `repr()` of an exception: `Name('message')`. */
+export function errorRepr(e) {
+    if (e instanceof Error) {
+        return `${e.name}('${e.message}')`;
+    }
+    return String(e);
+}
+/** A received response, its body already read. */
+export class HttpResponse {
+    statusCode;
+    text;
+    constructor(statusCode, text) {
+        this.statusCode = statusCode;
+        this.text = text;
+    }
+    /** The body parsed as JSON; throws a SyntaxError if it is not JSON. */
+    json() {
+        return JSON.parse(this.text);
+    }
+}
+/** Sends requests to one API. */
+export class HttpClient {
+    /** The transport requests go through; replace it to answer them in tests. */
+    transport;
+    _baseUrl;
+    _headers;
+    _timeout;
+    _closed = false;
+    constructor(options) {
+        this._baseUrl = options.baseUrl.replace(/\/+$/, "");
+        this._headers = options.headers ?? {};
+        this._timeout = options.timeout ?? 5.0;
+        this.transport = options.fetch ?? ((input, init) => fetch(input, init));
+    }
+    /** Whether the client has been closed. */
+    get isClosed() {
+        return this._closed;
+    }
+    /** Send a GET request. */
+    async get(path, options = {}) {
+        return await this.request("GET", path, options);
+    }
+    /** Send a POST request. */
+    async post(path, options = {}) {
+        return await this.request("POST", path, options);
+    }
+    /**
+     * Send a request and read its whole body.
+     *
+     * @throws HttpError If the request could not be sent, or was not answered
+     *   within the timeout (`HttpTimeoutError`).
+     */
+    async request(method, path, options = {}) {
+        if (this._closed) {
+            throw new Error("Cannot send a request, as the client has been closed.");
+        }
+        let url = `${this._baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+        if (options.params && Object.keys(options.params).length > 0) {
+            url += `?${new URLSearchParams(options.params).toString()}`;
+        }
+        const headers = { ...this._headers, ...(options.headers ?? {}) };
+        let body;
+        if (options.json !== undefined) {
+            body = JSON.stringify(options.json);
+            headers["Content-Type"] = "application/json";
+        }
+        const timeoutSignal = AbortSignal.timeout(this._timeout * 1000);
+        const signal = AbortSignal.any([currentSignal(), timeoutSignal]);
+        try {
+            return await abortable((async () => {
+                const response = await this.transport(url, { method, headers, body, signal });
+                const text = await response.text();
+                return new HttpResponse(response.status, text);
+            })());
+        }
+        catch (e) {
+            rethrowIfCancelled(e);
+            if (timeoutSignal.aborted) {
+                throw new HttpTimeoutError(`timed out after ${this._timeout}s`, { cause: e });
+            }
+            if (e instanceof HttpError) {
+                throw e;
+            }
+            throw new HttpError(e instanceof Error ? e.message : String(e), { cause: e });
+        }
+    }
+    /** Close the client; later requests throw. */
+    async aclose() {
+        this._closed = true;
+    }
+}
+/** Base64 of `data`, without `Buffer`. */
+export function bytesToBase64(data) {
+    let binary = "";
+    const chunk = 0x8000;
+    for (let i = 0; i < data.length; i += chunk) {
+        binary += String.fromCharCode(...data.subarray(i, i + chunk));
+    }
+    return btoa(binary);
+}
+/** Whether `value` is a JSON object (a Python dict). */
+export function isDict(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Python's `float(value)`: a number from a number or numeric string, else a TypeError/ValueError. */
+export function toFloat(value) {
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "boolean") {
+        return value ? 1 : 0;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim().toLowerCase();
+        if (/^[+-]?(inf|infinity)$/.test(trimmed)) {
+            return trimmed.startsWith("-") ? -Infinity : Infinity;
+        }
+        if (trimmed === "nan" || trimmed === "+nan" || trimmed === "-nan") {
+            return Number.NaN;
+        }
+        const n = Number(trimmed);
+        if (trimmed !== "" && Number.isFinite(n)) {
+            return n;
+        }
+        throw new RangeError(`could not convert string to float: '${value}'`);
+    }
+    throw new TypeError(`float() argument must be a string or a real number, not '${value === null ? "NoneType" : typeof value}'`);
+}
+/** Python's `value or ""`: the value, or an empty string when it is falsy (null, "", {} or []). */
+export function orEmpty(value) {
+    if (value === null || value === undefined || value === "") {
+        return "";
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0 ? "" : value;
+    }
+    if (isDict(value) && Object.keys(value).length === 0) {
+        return "";
+    }
+    return value;
+}
+//# sourceMappingURL=http_client.js.map

package/dist/classifiers/index.d.ts

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * PORTING NOTE: upstream's `pipecat.classifiers.jev.classifier` is a deprecated
+ * alias (since 1.13.0, removed in 2.0.0) that re-exports
+ * `pipecat.classifiers.typesafe.jev.classifier`. Deprecated aliases are not
+ * ported: import `classifiers/typesafe/jev/classifier.ts` instead.
+ */
+export {};
+//# sourceMappingURL=classifier.d.ts.map

package/dist/classifiers/jev/classifier.js

@@ -0,0 +1,13 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/classifiers/jev/classifier.py
+/**
+ * PORTING NOTE: upstream's `pipecat.classifiers.jev.classifier` is a deprecated
+ * alias (since 1.13.0, removed in 2.0.0) that re-exports
+ * `pipecat.classifiers.typesafe.jev.classifier`. Deprecated aliases are not
+ * ported: import `classifiers/typesafe/jev/classifier.ts` instead.
+ */
+export {};
+//# sourceMappingURL=classifier.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * PORTING NOTE: upstream's `pipecat.classifiers.jev.client` is a deprecated
+ * alias (since 1.13.0, removed in 2.0.0) that re-exports
+ * `pipecat.classifiers.typesafe.jev.client`. Deprecated aliases are not
+ * ported: import `classifiers/typesafe/jev/client.ts` instead.
+ */
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/classifiers/jev/client.js

@@ -0,0 +1,13 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/classifiers/jev/client.py
+/**
+ * PORTING NOTE: upstream's `pipecat.classifiers.jev.client` is a deprecated
+ * alias (since 1.13.0, removed in 2.0.0) that re-exports
+ * `pipecat.classifiers.typesafe.jev.client`. Deprecated aliases are not
+ * ported: import `classifiers/typesafe/jev/client.ts` instead.
+ */
+export {};
+//# sourceMappingURL=client.js.map

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

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

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