@loggie-ai/openclaw-plugin 0.1.0

package/dist/src/channel.js

@@ -0,0 +1,105 @@
+import { createChannelPluginBase, } from "openclaw/plugin-sdk/channel-core";
+import { applyLoggieAccountConfig, inspectLoggieAccount, listLoggieAccountIds, resolveDefaultLoggieAccountId, resolveLoggieAccount, } from "./account.js";
+import { loggieChannelConfigSchema } from "./config-schema.js";
+import { loggieDoctor } from "./doctor.js";
+import { buildLoggieAccountStatusSnapshot, defaultLoggieRuntimeState, } from "./status.js";
+const base = createChannelPluginBase({
+    id: "loggie",
+    meta: {
+        label: "Loggie",
+        selectionLabel: "Loggie",
+        blurb: "Receives durable Loggie meeting transcript events over WebSocket.",
+        docsPath: "/plugins/loggie",
+    },
+    capabilities: {
+        chatTypes: ["group"],
+        threads: false,
+        media: false,
+        reply: false,
+    },
+    configSchema: loggieChannelConfigSchema,
+    setup: {
+        resolveAccountId: ({ accountId }) => accountId ?? "default",
+        applyAccountConfig: ({ cfg, accountId, input, }) => applyLoggieAccountConfig({
+            cfg,
+            accountId,
+            input: input,
+        }),
+    },
+    config: {
+        listAccountIds: listLoggieAccountIds,
+        resolveAccount: (cfg, accountId) => resolveLoggieAccount(cfg, accountId),
+        inspectAccount: inspectLoggieAccount,
+        defaultAccountId: resolveDefaultLoggieAccountId,
+        isEnabled: (account) => account.enabled,
+        isConfigured: (account) => account.configured,
+        unconfiguredReason: (account) => account.tokenStatus.status !== "available"
+            ? `Loggie token ${account.tokenStatus.status}`
+            : "Loggie baseUrl and agentProfileId are required",
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            tokenStatus: account.tokenStatus.status,
+            tokenSource: account.tokenStatus.source,
+            extra: {
+                baseUrl: account.baseUrl,
+                agentId: account.agentId,
+                agentProfileId: account.agentProfileId,
+            },
+        }),
+    },
+});
+export const loggiePlugin = {
+    ...base,
+    status: {
+        defaultRuntime: defaultLoggieRuntimeState,
+        buildAccountSnapshot: ({ account, runtime, }) => buildLoggieAccountStatusSnapshot({
+            account,
+            runtime: runtime,
+        }),
+    },
+    doctor: loggieDoctor,
+    secrets: {
+        secretTargetRegistryEntries: [
+            {
+                id: "channels.loggie.credentialRef",
+                targetType: "channels.loggie.credentialRef",
+                configFile: "openclaw.json",
+                pathPattern: "channels.loggie.credentialRef",
+                secretShape: "secret_input",
+                expectedResolvedValue: "string",
+                includeInPlan: true,
+                includeInConfigure: true,
+                includeInAudit: true,
+            },
+            {
+                id: "channels.loggie.accounts.*.credentialRef",
+                targetType: "channels.loggie.accounts.*.credentialRef",
+                configFile: "openclaw.json",
+                pathPattern: "channels.loggie.accounts.*.credentialRef",
+                secretShape: "secret_input",
+                expectedResolvedValue: "string",
+                includeInPlan: true,
+                includeInConfigure: true,
+                includeInAudit: true,
+            },
+        ],
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const { monitorLoggieAccount } = await import("./monitor/connection.js");
+            return monitorLoggieAccount({
+                account: ctx.account,
+                cfg: ctx.cfg,
+                runtime: ctx.runtime,
+                channelRuntime: ctx.channelRuntime,
+                abortSignal: ctx.abortSignal,
+                setStatus: ctx.setStatus,
+                getStatus: ctx.getStatus,
+                log: ctx.log,
+            });
+        },
+    },
+};

package/dist/src/config-schema.d.ts

@@ -0,0 +1,98 @@
+export declare const LOGGIE_CHANNEL_ID = "loggie";
+export declare const DEFAULT_LOGGIE_ACCOUNT_ID = "default";
+export declare const DEFAULT_LOGGIE_AGENT_ID = "main";
+export declare const DEFAULT_LOGGIE_SOCKET_PATH = "/api/events/socket";
+export declare const DEFAULT_LOGGIE_TOKEN_ENV = "LOGGIE_AGENT_TOKEN";
+export declare const DEFAULT_LOGGIE_BASE_URL_ENV = "LOGGIE_BASE_URL";
+export declare const DEFAULT_LOGGIE_HEARTBEAT_TIMEOUT_MS = 120000;
+export declare const loggieEntryConfigSchema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {};
+};
+export declare const loggieChannelConfigSchema: {
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly properties: {
+        readonly enabled: {
+            readonly type: "boolean";
+            readonly default: true;
+        };
+        readonly baseUrl: {
+            readonly type: "string";
+        };
+        readonly socketPath: {
+            readonly type: "string";
+            readonly default: "/api/events/socket";
+        };
+        readonly accountId: {
+            readonly type: "string";
+            readonly default: "default";
+        };
+        readonly agentId: {
+            readonly type: "string";
+            readonly default: "main";
+        };
+        readonly agentProfileId: {
+            readonly type: "string";
+        };
+        readonly credentialRef: {};
+        readonly token: {
+            readonly type: "string";
+        };
+        readonly authHeader: {
+            readonly type: "string";
+            readonly enum: readonly ["authorization", "x-api-key"];
+            readonly default: "authorization";
+        };
+        readonly accounts: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "object";
+            };
+        };
+        readonly reconnect: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly minMs: {
+                    readonly type: "integer";
+                    readonly minimum: 100;
+                    readonly default: 1000;
+                };
+                readonly maxMs: {
+                    readonly type: "integer";
+                    readonly minimum: 1000;
+                    readonly default: 60000;
+                };
+            };
+        };
+        readonly heartbeat: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly timeoutMs: {
+                    readonly type: "integer";
+                    readonly minimum: 1000;
+                    readonly default: 120000;
+                };
+            };
+        };
+        readonly transcript: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly activation: {
+                    readonly type: "string";
+                    readonly enum: readonly ["final-only"];
+                    readonly default: "final-only";
+                };
+                readonly debounceMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly default: 5000;
+                };
+            };
+        };
+    };
+};

package/dist/src/config-schema.js

@@ -0,0 +1,55 @@
+export const LOGGIE_CHANNEL_ID = "loggie";
+export const DEFAULT_LOGGIE_ACCOUNT_ID = "default";
+export const DEFAULT_LOGGIE_AGENT_ID = "main";
+export const DEFAULT_LOGGIE_SOCKET_PATH = "/api/events/socket";
+export const DEFAULT_LOGGIE_TOKEN_ENV = "LOGGIE_AGENT_TOKEN";
+export const DEFAULT_LOGGIE_BASE_URL_ENV = "LOGGIE_BASE_URL";
+export const DEFAULT_LOGGIE_HEARTBEAT_TIMEOUT_MS = 120_000;
+export const loggieEntryConfigSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {},
+};
+export const loggieChannelConfigSchema = {
+    type: "object",
+    additionalProperties: true,
+    properties: {
+        enabled: { type: "boolean", default: true },
+        baseUrl: { type: "string" },
+        socketPath: { type: "string", default: DEFAULT_LOGGIE_SOCKET_PATH },
+        accountId: { type: "string", default: DEFAULT_LOGGIE_ACCOUNT_ID },
+        agentId: { type: "string", default: DEFAULT_LOGGIE_AGENT_ID },
+        agentProfileId: { type: "string" },
+        credentialRef: {},
+        token: { type: "string" },
+        authHeader: { type: "string", enum: ["authorization", "x-api-key"], default: "authorization" },
+        accounts: { type: "object", additionalProperties: { type: "object" } },
+        reconnect: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                minMs: { type: "integer", minimum: 100, default: 1000 },
+                maxMs: { type: "integer", minimum: 1000, default: 60000 },
+            },
+        },
+        heartbeat: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                timeoutMs: {
+                    type: "integer",
+                    minimum: 1000,
+                    default: DEFAULT_LOGGIE_HEARTBEAT_TIMEOUT_MS,
+                },
+            },
+        },
+        transcript: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                activation: { type: "string", enum: ["final-only"], default: "final-only" },
+                debounceMs: { type: "integer", minimum: 0, default: 5000 },
+            },
+        },
+    },
+};

package/dist/src/cursor-store.d.ts

@@ -0,0 +1,86 @@
+import type { LoggieEventEnvelope } from "./event-types.js";
+export type LoggieCursorRecord = {
+    accountId: string;
+    agentProfileId: string;
+    lastEventId?: string;
+    lastCursor?: string;
+    lastSequence?: number;
+    lastConnectedAt?: number;
+    lastCaughtUpAt?: number;
+    lastError?: string;
+    failedEvents?: LoggieFailedEvent[];
+    deadLetteredEvents?: LoggieDeadLetteredEvent[];
+    seenEventIds: string[];
+    updatedAt: string;
+};
+export type LoggieFailedEvent = {
+    eventId: string;
+    cursor?: string;
+    eventType: string;
+    attempts: number;
+    firstFailedAt: string;
+    lastFailedAt: string;
+    lastReason: string;
+};
+export type LoggieDeadLetteredEvent = {
+    eventId: string;
+    cursor?: string;
+    eventType: string;
+    attempts: number;
+    reason: string;
+    deadLetteredAt: string;
+};
+export type LoggieCursorDecision = {
+    action: "process";
+} | {
+    action: "skip";
+    reason: "duplicate_event" | "cursor_regression";
+};
+export type LoggieCursorStore = {
+    load(accountId: string, agentProfileId: string): Promise<LoggieCursorRecord | undefined>;
+    save(record: LoggieCursorRecord): Promise<void>;
+};
+export declare function createEmptyCursorRecord(params: {
+    accountId: string;
+    agentProfileId: string;
+}): LoggieCursorRecord;
+export declare function decideCursor(record: LoggieCursorRecord | undefined, event: LoggieEventEnvelope): LoggieCursorDecision;
+export declare function advanceCursor(params: {
+    record: LoggieCursorRecord | undefined;
+    event: LoggieEventEnvelope;
+    accountId: string;
+    agentProfileId: string;
+    now?: Date;
+}): LoggieCursorRecord;
+export declare function recordEventFailure(params: {
+    record: LoggieCursorRecord | undefined;
+    event: LoggieEventEnvelope;
+    accountId: string;
+    agentProfileId: string;
+    reason: string;
+    now?: Date;
+}): {
+    record: LoggieCursorRecord;
+    attempts: number;
+};
+export declare function deadLetterEvent(params: {
+    record: LoggieCursorRecord | undefined;
+    event: LoggieEventEnvelope;
+    accountId: string;
+    agentProfileId: string;
+    reason: string;
+    attempts: number;
+    now?: Date;
+}): LoggieCursorRecord;
+export declare function createMemoryCursorStore(initial?: LoggieCursorRecord[]): LoggieCursorStore;
+export declare function createRuntimeCursorStore(runtime: {
+    state?: {
+        openKeyedStore?: <T>(opts: {
+            namespace: string;
+            maxEntries: number;
+        }) => {
+            lookup(key: string): Promise<T | undefined>;
+            register(key: string, value: T): Promise<void>;
+        };
+    };
+}): LoggieCursorStore;

package/dist/src/cursor-store.js

@@ -0,0 +1,141 @@
+const MAX_SEEN_EVENT_IDS = 500;
+const MAX_FAILED_EVENTS = 50;
+const MAX_DEAD_LETTERED_EVENTS = 100;
+export function createEmptyCursorRecord(params) {
+    return {
+        accountId: params.accountId,
+        agentProfileId: params.agentProfileId,
+        seenEventIds: [],
+        updatedAt: new Date(0).toISOString(),
+    };
+}
+export function decideCursor(record, event) {
+    if (record?.seenEventIds.includes(event.eventId)) {
+        return { action: "skip", reason: "duplicate_event" };
+    }
+    const eventCursor = parseCursor(event.cursor);
+    const recordCursor = parseCursor(readStoredCursor(record));
+    if (eventCursor !== undefined && recordCursor !== undefined && eventCursor < recordCursor) {
+        return { action: "skip", reason: "cursor_regression" };
+    }
+    return { action: "process" };
+}
+export function advanceCursor(params) {
+    const base = params.record ??
+        createEmptyCursorRecord({
+            accountId: params.accountId,
+            agentProfileId: params.agentProfileId,
+        });
+    const seen = [params.event.eventId, ...base.seenEventIds.filter((id) => id !== params.event.eventId)].slice(0, MAX_SEEN_EVENT_IDS);
+    const failedEvents = base.failedEvents?.filter((entry) => entry.eventId !== params.event.eventId);
+    return {
+        ...base,
+        lastEventId: params.event.eventId,
+        lastCursor: params.event.cursor ?? base.lastCursor,
+        lastSequence: typeof params.event.sequence === "number"
+            ? params.event.sequence
+            : base.lastSequence,
+        lastCaughtUpAt: (params.now ?? new Date()).getTime(),
+        lastError: undefined,
+        failedEvents: failedEvents?.length ? failedEvents : undefined,
+        seenEventIds: seen,
+        updatedAt: (params.now ?? new Date()).toISOString(),
+    };
+}
+export function recordEventFailure(params) {
+    const now = (params.now ?? new Date()).toISOString();
+    const base = params.record ??
+        createEmptyCursorRecord({
+            accountId: params.accountId,
+            agentProfileId: params.agentProfileId,
+        });
+    const existing = base.failedEvents?.find((entry) => entry.eventId === params.event.eventId);
+    const nextFailure = {
+        eventId: params.event.eventId,
+        cursor: params.event.cursor,
+        eventType: params.event.eventType,
+        attempts: (existing?.attempts ?? 0) + 1,
+        firstFailedAt: existing?.firstFailedAt ?? now,
+        lastFailedAt: now,
+        lastReason: params.reason,
+    };
+    const failedEvents = [
+        nextFailure,
+        ...(base.failedEvents ?? []).filter((entry) => entry.eventId !== params.event.eventId),
+    ].slice(0, MAX_FAILED_EVENTS);
+    return {
+        attempts: nextFailure.attempts,
+        record: {
+            ...base,
+            lastError: params.reason,
+            failedEvents,
+            updatedAt: now,
+        },
+    };
+}
+export function deadLetterEvent(params) {
+    const now = params.now ?? new Date();
+    const advanced = advanceCursor({
+        record: params.record,
+        event: params.event,
+        accountId: params.accountId,
+        agentProfileId: params.agentProfileId,
+        now,
+    });
+    return {
+        ...advanced,
+        deadLetteredEvents: [
+            {
+                eventId: params.event.eventId,
+                cursor: params.event.cursor,
+                eventType: params.event.eventType,
+                attempts: params.attempts,
+                reason: params.reason,
+                deadLetteredAt: now.toISOString(),
+            },
+            ...(advanced.deadLetteredEvents ?? []),
+        ].slice(0, MAX_DEAD_LETTERED_EVENTS),
+    };
+}
+export function createMemoryCursorStore(initial) {
+    const records = new Map();
+    for (const record of initial ?? []) {
+        records.set(cursorKey(record.accountId, record.agentProfileId), record);
+    }
+    return {
+        async load(accountId, agentProfileId) {
+            return records.get(cursorKey(accountId, agentProfileId));
+        },
+        async save(record) {
+            records.set(cursorKey(record.accountId, record.agentProfileId), record);
+        },
+    };
+}
+export function createRuntimeCursorStore(runtime) {
+    const store = runtime.state?.openKeyedStore?.({
+        namespace: "loggie-cursors",
+        maxEntries: 1000,
+    });
+    if (!store) {
+        throw new Error("Loggie durable cursor store is unavailable");
+    }
+    return {
+        load: (accountId, agentProfileId) => store.lookup(cursorKey(accountId, agentProfileId)),
+        save: (record) => store.register(cursorKey(record.accountId, record.agentProfileId), record),
+    };
+}
+function cursorKey(accountId, agentProfileId) {
+    return `${accountId}:${agentProfileId}`;
+}
+function parseCursor(value) {
+    if (!value || !/^\d+$/.test(value)) {
+        return undefined;
+    }
+    return BigInt(value);
+}
+function readStoredCursor(record) {
+    if (!record) {
+        return undefined;
+    }
+    return record.lastCursor ?? (typeof record.lastSequence === "number" ? String(record.lastSequence) : undefined);
+}

package/dist/src/doctor.d.ts

@@ -0,0 +1,11 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/channel-core";
+export declare function collectLoggieDoctorWarnings(params: {
+    cfg: OpenClawConfig;
+    env?: NodeJS.ProcessEnv;
+}): string[];
+export declare const loggieDoctor: {
+    collectPreviewWarnings: (params: {
+        cfg: OpenClawConfig;
+        env?: NodeJS.ProcessEnv;
+    }) => string[];
+};

package/dist/src/doctor.js

@@ -0,0 +1,29 @@
+import { listLoggieAccountIds, resolveLoggieAccount } from "./account.js";
+export function collectLoggieDoctorWarnings(params) {
+    const warnings = [];
+    const accountIds = listLoggieAccountIds(params.cfg);
+    if (accountIds.length === 0) {
+        return ["channels.loggie has no configured accounts."];
+    }
+    for (const accountId of accountIds) {
+        const account = resolveLoggieAccount(params.cfg, accountId, params.env);
+        const prefix = `channels.loggie account ${account.accountId}`;
+        if (!account.enabled) {
+            warnings.push(`${prefix} is disabled.`);
+            continue;
+        }
+        if (!account.baseUrl) {
+            warnings.push(`${prefix} is missing baseUrl or LOGGIE_BASE_URL.`);
+        }
+        if (!account.agentProfileId) {
+            warnings.push(`${prefix} is missing agentProfileId.`);
+        }
+        if (account.tokenStatus.status !== "available") {
+            warnings.push(`${prefix} token is ${account.tokenStatus.status} (${account.tokenStatus.source}).`);
+        }
+    }
+    return warnings;
+}
+export const loggieDoctor = {
+    collectPreviewWarnings: (params) => collectLoggieDoctorWarnings(params),
+};

package/dist/src/event-types.d.ts

@@ -0,0 +1,113 @@
+import { z } from "zod";
+export declare const LOGGIE_TRANSCRIPT_READY_EVENT = "meeting.transcript.ready";
+declare const transcriptPayloadSchema: z.ZodObject<{
+    eventId: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    meetingId: z.ZodOptional<z.ZodString>;
+    meetingScheduleId: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    meetingDate: z.ZodOptional<z.ZodString>;
+    hasTranscript: z.ZodOptional<z.ZodBoolean>;
+    detailPath: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    eventId: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    meetingId: z.ZodOptional<z.ZodString>;
+    meetingScheduleId: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    meetingDate: z.ZodOptional<z.ZodString>;
+    hasTranscript: z.ZodOptional<z.ZodBoolean>;
+    detailPath: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    eventId: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    meetingId: z.ZodOptional<z.ZodString>;
+    meetingScheduleId: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    meetingDate: z.ZodOptional<z.ZodString>;
+    hasTranscript: z.ZodOptional<z.ZodBoolean>;
+    detailPath: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const loggieEventEnvelopeSchema: z.ZodEffects<z.ZodObject<{
+    eventId: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodString;
+    agentProfileId: z.ZodOptional<z.ZodString>;
+    meetingId: z.ZodOptional<z.ZodString>;
+    meetingScheduleId: z.ZodOptional<z.ZodString>;
+    eventType: z.ZodString;
+    occurredAt: z.ZodString;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    payload: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    eventId: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodString;
+    agentProfileId: z.ZodOptional<z.ZodString>;
+    meetingId: z.ZodOptional<z.ZodString>;
+    meetingScheduleId: z.ZodOptional<z.ZodString>;
+    eventType: z.ZodString;
+    occurredAt: z.ZodString;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    payload: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    eventId: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodString;
+    agentProfileId: z.ZodOptional<z.ZodString>;
+    meetingId: z.ZodOptional<z.ZodString>;
+    meetingScheduleId: z.ZodOptional<z.ZodString>;
+    eventType: z.ZodString;
+    occurredAt: z.ZodString;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    payload: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+    eventId: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodString;
+    agentProfileId: z.ZodOptional<z.ZodString>;
+    meetingId: z.ZodOptional<z.ZodString>;
+    meetingScheduleId: z.ZodOptional<z.ZodString>;
+    eventType: z.ZodString;
+    occurredAt: z.ZodString;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    payload: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    eventId: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodString;
+    agentProfileId: z.ZodOptional<z.ZodString>;
+    meetingId: z.ZodOptional<z.ZodString>;
+    meetingScheduleId: z.ZodOptional<z.ZodString>;
+    eventType: z.ZodString;
+    occurredAt: z.ZodString;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    payload: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type LoggieEventEnvelope = z.infer<typeof loggieEventEnvelopeSchema>;
+export type LoggieTranscriptReadyEvent = LoggieEventEnvelope & {
+    eventType: typeof LOGGIE_TRANSCRIPT_READY_EVENT;
+    payload: z.infer<typeof transcriptPayloadSchema>;
+};
+export type ParseLoggieEventResult = {
+    ok: true;
+    event: LoggieEventEnvelope;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function parseLoggieEventEnvelope(raw: unknown): ParseLoggieEventResult;
+export declare function isTranscriptReadyEvent(event: LoggieEventEnvelope): event is LoggieTranscriptReadyEvent;
+export {};