@pipedog/core 0.0.0 → 0.2.0

package/dist/frames/index.d.ts

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

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

package/dist/frames/protobufs/frames_pb2.d.ts

@@ -0,0 +1,229 @@
+/**
+ * Protocol buffer messages for `frames.proto` (package `pipecat`).
+ *
+ * PORTING NOTE: upstream's module is generated by `protoc` and needs the
+ * `protobuf` runtime. Core takes no third-party dependencies, so this is a
+ * hand-written proto3 codec for the same schema, with the same wire format:
+ *
+ * ```proto
+ * message TextFrame { uint64 id = 1; string name = 2; string text = 3; }
+ * message AudioRawFrame {
+ *   uint64 id = 1; string name = 2; bytes audio = 3; uint32 sample_rate = 4;
+ *   uint32 num_channels = 5; optional uint64 pts = 6;
+ * }
+ * message TranscriptionFrame {
+ *   uint64 id = 1; string name = 2; string text = 3; string user_id = 4; string timestamp = 5;
+ * }
+ * message MessageFrame { string data = 1; }
+ * message InterruptionFrame { uint64 id = 1; string name = 2; }
+ * message Frame {
+ *   oneof frame {
+ *     TextFrame text = 1; AudioRawFrame audio = 2; TranscriptionFrame transcription = 3;
+ *     MessageFrame message = 4; InterruptionFrame interruption = 5;
+ *   }
+ * }
+ * ```
+ *
+ * The protobuf Python API maps as: `Message()` / `Message(field=...)` →
+ * `new Message({ field })` (camelCase fields), `msg.SerializeToString()` →
+ * `msg.serializeToString()`, `Message.FromString(data)` →
+ * `Message.fromString(data)`, `msg.WhichOneof("frame")` →
+ * `msg.whichOneof("frame")`, and `Message.DESCRIPTOR.fields_by_name[...]` →
+ * `Message.DESCRIPTOR.fieldsByName[...]`; each field descriptor carries its
+ * proto `name` and the TS property it maps to (`attr`). `uint64` fields are
+ * JS numbers (exact up to 2^53). An unset `optional` field reads `null`.
+ */
+type ScalarKind = "uint64" | "uint32" | "string" | "bytes";
+/** Describes one field of a message. */
+export interface FieldDescriptor {
+    /** The field's proto name (snake_case). */
+    readonly name: string;
+    /** The TS property holding the field. */
+    readonly attr: string;
+    /** The field number. */
+    readonly number: number;
+    /** The field's type. */
+    readonly kind: ScalarKind | "message";
+    /** Whether the field has explicit presence (`optional`). */
+    readonly optional: boolean;
+    /** The message type of a message field. */
+    readonly messageType: MessageDescriptor | null;
+    /** The oneof the field belongs to, if any. */
+    readonly oneof: string | null;
+}
+/** Describes a message type. */
+export interface MessageDescriptor {
+    /** The message's short name. */
+    readonly name: string;
+    /** The message's fully qualified name. */
+    readonly fullName: string;
+    /** The fields, in declaration order. */
+    readonly fields: readonly FieldDescriptor[];
+    /** The fields, by proto name. */
+    readonly fieldsByName: Readonly<Record<string, FieldDescriptor>>;
+}
+/** Encodes the proto wire format. @internal */
+export declare class Writer {
+    #private;
+    varint(value: number): void;
+    tag(number: number, wireType: number): void;
+    bytes(data: Uint8Array): void;
+    finish(): Uint8Array;
+}
+/** Decodes the proto wire format. @internal */
+export declare class Reader {
+    #private;
+    constructor(data: Uint8Array);
+    get done(): boolean;
+    varint(): number;
+    take(length: number): Uint8Array;
+    skip(wireType: number): void;
+}
+/** Base class of the generated-style messages. */
+export declare abstract class Message {
+    #private;
+    /** The message type's descriptor. */
+    static DESCRIPTOR: MessageDescriptor;
+    /** Serialize the message to its binary wire format. */
+    serializeToString(): Uint8Array;
+    /** Replace this message's contents with the parsed binary `data`. */
+    parseFromString(data: Uint8Array): void;
+    /** Reset every field to its default (unset) value. */
+    clear(): void;
+    /** Whether a field with presence (optional, or a message) is set. */
+    hasField(name: string): boolean;
+    /** @internal */
+    _write(writer: Writer): void;
+    /** @internal */
+    _read(reader: Reader): void;
+}
+export interface TextFrameOptions {
+    id?: number;
+    name?: string;
+    text?: string;
+}
+/** `pipecat.TextFrame`. */
+export declare class TextFrame extends Message {
+    static DESCRIPTOR: MessageDescriptor;
+    id: number;
+    name: string;
+    text: string;
+    constructor(options?: TextFrameOptions);
+    /** Parse a `TextFrame` from its binary wire format. */
+    static fromString(data: Uint8Array): TextFrame;
+}
+export interface AudioRawFrameOptions {
+    id?: number;
+    name?: string;
+    audio?: Uint8Array;
+    sampleRate?: number;
+    numChannels?: number;
+    pts?: number | null;
+}
+/** `pipecat.AudioRawFrame`. */
+export declare class AudioRawFrame extends Message {
+    static DESCRIPTOR: MessageDescriptor;
+    id: number;
+    name: string;
+    audio: Uint8Array;
+    sampleRate: number;
+    numChannels: number;
+    pts: number | null;
+    constructor(options?: AudioRawFrameOptions);
+    /** Parse an `AudioRawFrame` from its binary wire format. */
+    static fromString(data: Uint8Array): AudioRawFrame;
+}
+export interface TranscriptionFrameOptions {
+    id?: number;
+    name?: string;
+    text?: string;
+    userId?: string;
+    timestamp?: string;
+}
+/** `pipecat.TranscriptionFrame`. */
+export declare class TranscriptionFrame extends Message {
+    static DESCRIPTOR: MessageDescriptor;
+    id: number;
+    name: string;
+    text: string;
+    userId: string;
+    timestamp: string;
+    constructor(options?: TranscriptionFrameOptions);
+    /** Parse a `TranscriptionFrame` from its binary wire format. */
+    static fromString(data: Uint8Array): TranscriptionFrame;
+}
+export interface MessageFrameOptions {
+    data?: string;
+}
+/** `pipecat.MessageFrame`. */
+export declare class MessageFrame extends Message {
+    static DESCRIPTOR: MessageDescriptor;
+    data: string;
+    constructor(options?: MessageFrameOptions);
+    /** Parse a `MessageFrame` from its binary wire format. */
+    static fromString(data: Uint8Array): MessageFrame;
+}
+export interface InterruptionFrameOptions {
+    id?: number;
+    name?: string;
+}
+/** `pipecat.InterruptionFrame`. */
+export declare class InterruptionFrame extends Message {
+    static DESCRIPTOR: MessageDescriptor;
+    id: number;
+    name: string;
+    constructor(options?: InterruptionFrameOptions);
+    /** Parse an `InterruptionFrame` from its binary wire format. */
+    static fromString(data: Uint8Array): InterruptionFrame;
+}
+/** The members of `Frame`'s `frame` oneof. */
+export type FrameOneofName = "text" | "audio" | "transcription" | "message" | "interruption";
+export interface FrameOptions {
+    text?: TextFrame | null;
+    audio?: AudioRawFrame | null;
+    transcription?: TranscriptionFrame | null;
+    message?: MessageFrame | null;
+    interruption?: InterruptionFrame | null;
+}
+/**
+ * `pipecat.Frame`: exactly one of its members is set (the `frame` oneof).
+ * Setting a member clears the others, as protobuf does.
+ */
+export declare class Frame extends Message {
+    #private;
+    static DESCRIPTOR: MessageDescriptor;
+    constructor(options?: FrameOptions);
+    get text(): TextFrame | null;
+    set text(value: TextFrame | null);
+    get audio(): AudioRawFrame | null;
+    set audio(value: AudioRawFrame | null);
+    get transcription(): TranscriptionFrame | null;
+    set transcription(value: TranscriptionFrame | null);
+    get message(): MessageFrame | null;
+    set message(value: MessageFrame | null);
+    get interruption(): InterruptionFrame | null;
+    set interruption(value: InterruptionFrame | null);
+    /**
+     * The name of the member of oneof `oneofGroup` that is set, or null.
+     *
+     * @param oneofGroup The oneof's name; `Frame` has only `"frame"`.
+     */
+    whichOneof(oneofGroup: "frame"): FrameOneofName | null;
+    /** Parse a `Frame` from its binary wire format. */
+    static fromString(data: Uint8Array): Frame;
+}
+/** The file's descriptor: every message type it declares, by name. */
+export declare const DESCRIPTOR: {
+    readonly name: "frames.proto";
+    readonly package: "pipecat";
+    readonly messageTypesByName: {
+        readonly TextFrame: MessageDescriptor;
+        readonly AudioRawFrame: MessageDescriptor;
+        readonly TranscriptionFrame: MessageDescriptor;
+        readonly MessageFrame: MessageDescriptor;
+        readonly InterruptionFrame: MessageDescriptor;
+        readonly Frame: MessageDescriptor;
+    };
+};
+export {};
+//# sourceMappingURL=frames_pb2.d.ts.map

package/dist/frames/protobufs/frames_pb2.js

@@ -0,0 +1,466 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/frames/protobufs/frames_pb2.py
+function field(name, attr, number, kind, extra = {}) {
+    return {
+        name,
+        attr,
+        number,
+        kind,
+        optional: extra.optional ?? false,
+        messageType: extra.messageType ?? null,
+        oneof: extra.oneof ?? null,
+    };
+}
+function descriptor(name, fields) {
+    return {
+        name,
+        fullName: `pipecat.${name}`,
+        fields,
+        fieldsByName: Object.fromEntries(fields.map((f) => [f.name, f])),
+    };
+}
+//
+// Wire format
+//
+/** Encodes the proto wire format. @internal */
+export class Writer {
+    #chunks = [];
+    varint(value) {
+        let v = Math.floor(value);
+        if (v < 0 || !Number.isFinite(v)) {
+            throw new RangeError(`value out of range for an unsigned varint: ${value}`);
+        }
+        while (v >= 0x80) {
+            this.#chunks.push((v % 0x80) | 0x80);
+            v = Math.floor(v / 0x80);
+        }
+        this.#chunks.push(v);
+    }
+    tag(number, wireType) {
+        this.varint(number * 8 + wireType);
+    }
+    bytes(data) {
+        this.varint(data.length);
+        for (const b of data) {
+            this.#chunks.push(b);
+        }
+    }
+    finish() {
+        return Uint8Array.from(this.#chunks);
+    }
+}
+/** Decodes the proto wire format. @internal */
+export class Reader {
+    #data;
+    #pos = 0;
+    constructor(data) {
+        this.#data = data;
+    }
+    get done() {
+        return this.#pos >= this.#data.length;
+    }
+    varint() {
+        let result = 0;
+        let multiplier = 1;
+        while (true) {
+            if (this.#pos >= this.#data.length) {
+                throw new Error("Error parsing message: truncated varint");
+            }
+            const b = this.#data[this.#pos++];
+            result += (b & 0x7f) * multiplier;
+            if ((b & 0x80) === 0) {
+                return result;
+            }
+            multiplier *= 0x80;
+        }
+    }
+    take(length) {
+        if (this.#pos + length > this.#data.length) {
+            throw new Error("Error parsing message: truncated field");
+        }
+        const out = this.#data.slice(this.#pos, this.#pos + length);
+        this.#pos += length;
+        return out;
+    }
+    skip(wireType) {
+        switch (wireType) {
+            case 0:
+                this.varint();
+                break;
+            case 1:
+                this.take(8);
+                break;
+            case 2:
+                this.take(this.varint());
+                break;
+            case 5:
+                this.take(4);
+                break;
+            default:
+                throw new Error(`Error parsing message: unsupported wire type ${wireType}`);
+        }
+    }
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/** Base class of the generated-style messages. */
+export class Message {
+    /** The message type's descriptor. */
+    static DESCRIPTOR;
+    get #descriptor() {
+        return this.constructor.DESCRIPTOR;
+    }
+    /** Serialize the message to its binary wire format. */
+    serializeToString() {
+        const writer = new Writer();
+        this._write(writer);
+        return writer.finish();
+    }
+    /** Replace this message's contents with the parsed binary `data`. */
+    parseFromString(data) {
+        // As protobuf's `ParseFromString`: clear the message, then merge `data` into it.
+        this.clear();
+        this._read(new Reader(data));
+    }
+    /** Reset every field to its default (unset) value. */
+    clear() {
+        const self = this;
+        for (const f of this.#descriptor.fields) {
+            if (f.optional || f.kind === "message") {
+                self[f.attr] = null;
+            }
+            else if (f.kind === "string") {
+                self[f.attr] = "";
+            }
+            else if (f.kind === "bytes") {
+                self[f.attr] = new Uint8Array(0);
+            }
+            else {
+                self[f.attr] = 0;
+            }
+        }
+    }
+    /** Whether a field with presence (optional, or a message) is set. */
+    hasField(name) {
+        const f = this.#descriptor.fieldsByName[name];
+        if (!f || (!f.optional && f.kind !== "message")) {
+            throw new Error(`Field ${name} does not have presence`);
+        }
+        return this[f.attr] != null;
+    }
+    /** @internal */
+    _write(writer) {
+        const self = this;
+        for (const f of this.#descriptor.fields) {
+            const value = self[f.attr];
+            if (value == null) {
+                continue;
+            }
+            switch (f.kind) {
+                case "uint64":
+                case "uint32":
+                    if (value === 0 && !f.optional)
+                        continue;
+                    writer.tag(f.number, 0);
+                    writer.varint(value);
+                    break;
+                case "string":
+                    if (value === "" && !f.optional)
+                        continue;
+                    writer.tag(f.number, 2);
+                    writer.bytes(encoder.encode(value));
+                    break;
+                case "bytes":
+                    if (value.length === 0 && !f.optional)
+                        continue;
+                    writer.tag(f.number, 2);
+                    writer.bytes(value);
+                    break;
+                case "message":
+                    writer.tag(f.number, 2);
+                    writer.bytes(value.serializeToString());
+                    break;
+            }
+        }
+    }
+    /** @internal */
+    _read(reader) {
+        const self = this;
+        const byNumber = new Map(this.#descriptor.fields.map((f) => [f.number, f]));
+        while (!reader.done) {
+            const key = reader.varint();
+            const number = Math.floor(key / 8);
+            const wireType = key % 8;
+            const f = byNumber.get(number);
+            if (!f) {
+                reader.skip(wireType);
+                continue;
+            }
+            switch (f.kind) {
+                case "uint64":
+                case "uint32": {
+                    const v = reader.varint();
+                    self[f.attr] = f.kind === "uint32" ? v % 2 ** 32 : v;
+                    break;
+                }
+                case "string":
+                    self[f.attr] = decoder.decode(reader.take(reader.varint()));
+                    break;
+                case "bytes":
+                    self[f.attr] = reader.take(reader.varint());
+                    break;
+                case "message": {
+                    const Type = MESSAGE_TYPES[f.messageType?.name ?? ""];
+                    const sub = new Type();
+                    sub.parseFromString(reader.take(reader.varint()));
+                    self[f.attr] = sub;
+                    break;
+                }
+            }
+        }
+    }
+}
+/** `pipecat.TextFrame`. */
+export class TextFrame extends Message {
+    static DESCRIPTOR = descriptor("TextFrame", [
+        field("id", "id", 1, "uint64"),
+        field("name", "name", 2, "string"),
+        field("text", "text", 3, "string"),
+    ]);
+    id;
+    name;
+    text;
+    constructor(options = {}) {
+        super();
+        this.id = options.id ?? 0;
+        this.name = options.name ?? "";
+        this.text = options.text ?? "";
+    }
+    /** Parse a `TextFrame` from its binary wire format. */
+    static fromString(data) {
+        const message = new TextFrame();
+        message.parseFromString(data);
+        return message;
+    }
+}
+/** `pipecat.AudioRawFrame`. */
+export class AudioRawFrame extends Message {
+    static DESCRIPTOR = descriptor("AudioRawFrame", [
+        field("id", "id", 1, "uint64"),
+        field("name", "name", 2, "string"),
+        field("audio", "audio", 3, "bytes"),
+        field("sample_rate", "sampleRate", 4, "uint32"),
+        field("num_channels", "numChannels", 5, "uint32"),
+        field("pts", "pts", 6, "uint64", { optional: true }),
+    ]);
+    id;
+    name;
+    audio;
+    sampleRate;
+    numChannels;
+    pts;
+    constructor(options = {}) {
+        super();
+        this.id = options.id ?? 0;
+        this.name = options.name ?? "";
+        this.audio = options.audio ?? new Uint8Array(0);
+        this.sampleRate = options.sampleRate ?? 0;
+        this.numChannels = options.numChannels ?? 0;
+        this.pts = options.pts ?? null;
+    }
+    /** Parse an `AudioRawFrame` from its binary wire format. */
+    static fromString(data) {
+        const message = new AudioRawFrame();
+        message.parseFromString(data);
+        return message;
+    }
+}
+/** `pipecat.TranscriptionFrame`. */
+export class TranscriptionFrame extends Message {
+    static DESCRIPTOR = descriptor("TranscriptionFrame", [
+        field("id", "id", 1, "uint64"),
+        field("name", "name", 2, "string"),
+        field("text", "text", 3, "string"),
+        field("user_id", "userId", 4, "string"),
+        field("timestamp", "timestamp", 5, "string"),
+    ]);
+    id;
+    name;
+    text;
+    userId;
+    timestamp;
+    constructor(options = {}) {
+        super();
+        this.id = options.id ?? 0;
+        this.name = options.name ?? "";
+        this.text = options.text ?? "";
+        this.userId = options.userId ?? "";
+        this.timestamp = options.timestamp ?? "";
+    }
+    /** Parse a `TranscriptionFrame` from its binary wire format. */
+    static fromString(data) {
+        const message = new TranscriptionFrame();
+        message.parseFromString(data);
+        return message;
+    }
+}
+/** `pipecat.MessageFrame`. */
+export class MessageFrame extends Message {
+    static DESCRIPTOR = descriptor("MessageFrame", [field("data", "data", 1, "string")]);
+    data;
+    constructor(options = {}) {
+        super();
+        this.data = options.data ?? "";
+    }
+    /** Parse a `MessageFrame` from its binary wire format. */
+    static fromString(data) {
+        const message = new MessageFrame();
+        message.parseFromString(data);
+        return message;
+    }
+}
+/** `pipecat.InterruptionFrame`. */
+export class InterruptionFrame extends Message {
+    static DESCRIPTOR = descriptor("InterruptionFrame", [
+        field("id", "id", 1, "uint64"),
+        field("name", "name", 2, "string"),
+    ]);
+    id;
+    name;
+    constructor(options = {}) {
+        super();
+        this.id = options.id ?? 0;
+        this.name = options.name ?? "";
+    }
+    /** Parse an `InterruptionFrame` from its binary wire format. */
+    static fromString(data) {
+        const message = new InterruptionFrame();
+        message.parseFromString(data);
+        return message;
+    }
+}
+/**
+ * `pipecat.Frame`: exactly one of its members is set (the `frame` oneof).
+ * Setting a member clears the others, as protobuf does.
+ */
+export class Frame extends Message {
+    static DESCRIPTOR = descriptor("Frame", [
+        field("text", "text", 1, "message", {
+            messageType: TextFrame.DESCRIPTOR,
+            oneof: "frame",
+        }),
+        field("audio", "audio", 2, "message", {
+            messageType: AudioRawFrame.DESCRIPTOR,
+            oneof: "frame",
+        }),
+        field("transcription", "transcription", 3, "message", {
+            messageType: TranscriptionFrame.DESCRIPTOR,
+            oneof: "frame",
+        }),
+        field("message", "message", 4, "message", {
+            messageType: MessageFrame.DESCRIPTOR,
+            oneof: "frame",
+        }),
+        field("interruption", "interruption", 5, "message", {
+            messageType: InterruptionFrame.DESCRIPTOR,
+            oneof: "frame",
+        }),
+    ]);
+    #which = null;
+    #value = null;
+    constructor(options = {}) {
+        super();
+        for (const name of ["text", "audio", "transcription", "message", "interruption"]) {
+            const value = options[name];
+            if (value != null) {
+                this.#set(name, value);
+            }
+        }
+    }
+    #get(name) {
+        return this.#which === name ? this.#value : null;
+    }
+    #set(name, value) {
+        if (value == null) {
+            if (this.#which === name) {
+                this.#which = null;
+                this.#value = null;
+            }
+            return;
+        }
+        this.#which = name;
+        this.#value = value;
+    }
+    get text() {
+        return this.#get("text");
+    }
+    set text(value) {
+        this.#set("text", value);
+    }
+    get audio() {
+        return this.#get("audio");
+    }
+    set audio(value) {
+        this.#set("audio", value);
+    }
+    get transcription() {
+        return this.#get("transcription");
+    }
+    set transcription(value) {
+        this.#set("transcription", value);
+    }
+    get message() {
+        return this.#get("message");
+    }
+    set message(value) {
+        this.#set("message", value);
+    }
+    get interruption() {
+        return this.#get("interruption");
+    }
+    set interruption(value) {
+        this.#set("interruption", value);
+    }
+    /**
+     * The name of the member of oneof `oneofGroup` that is set, or null.
+     *
+     * @param oneofGroup The oneof's name; `Frame` has only `"frame"`.
+     */
+    whichOneof(oneofGroup) {
+        if (oneofGroup !== "frame") {
+            throw new Error(`Protocol message has no oneof "${oneofGroup}" field.`);
+        }
+        return this.#which;
+    }
+    /** Parse a `Frame` from its binary wire format. */
+    static fromString(data) {
+        const message = new Frame();
+        message.parseFromString(data);
+        return message;
+    }
+}
+const MESSAGE_TYPES = {
+    TextFrame,
+    AudioRawFrame,
+    TranscriptionFrame,
+    MessageFrame,
+    InterruptionFrame,
+    Frame,
+};
+/** The file's descriptor: every message type it declares, by name. */
+export const DESCRIPTOR = {
+    name: "frames.proto",
+    package: "pipecat",
+    messageTypesByName: {
+        TextFrame: TextFrame.DESCRIPTOR,
+        AudioRawFrame: AudioRawFrame.DESCRIPTOR,
+        TranscriptionFrame: TranscriptionFrame.DESCRIPTOR,
+        MessageFrame: MessageFrame.DESCRIPTOR,
+        InterruptionFrame: InterruptionFrame.DESCRIPTOR,
+        Frame: Frame.DESCRIPTOR,
+    },
+};
+//# sourceMappingURL=frames_pb2.js.map