@kernl-sdk/xai 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+
+
+> @kernl-sdk/xai@0.1.0 build /Users/andjones/Documents/projects/kernl/packages/providers/xai
+> tsc && tsc-alias --resolve-full-paths
+

package/dist/__tests__/realtime.integration.test.d.ts

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

package/dist/__tests__/realtime.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime.integration.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/realtime.integration.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/realtime.integration.test.js

@@ -0,0 +1,157 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import { GrokRealtimeModel } from "../realtime/model.js";
+const XAI_API_KEY = process.env.XAI_API_KEY;
+describe.skipIf(!XAI_API_KEY)("Grok Realtime Integration", () => {
+    let model;
+    beforeAll(() => {
+        model = new GrokRealtimeModel({
+            apiKey: XAI_API_KEY,
+        });
+    });
+    it("should connect and receive conversation.created", async () => {
+        const conn = await model.connect();
+        const events = [];
+        const sessionCreated = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error("timeout")), 10000);
+            conn.on("event", (e) => {
+                events.push(e);
+                if (e.kind === "session.created") {
+                    clearTimeout(timeout);
+                    resolve();
+                }
+            });
+        });
+        await sessionCreated;
+        conn.close();
+        expect(events.some((e) => e.kind === "session.created")).toBe(true);
+        expect(conn.sessionId).toBeTruthy();
+    });
+    it("should complete text round-trip", async () => {
+        const conn = await model.connect();
+        const events = [];
+        conn.on("event", (e) => {
+            events.push(e);
+        });
+        // wait for session
+        await waitFor(conn, "session.created");
+        // configure text-only mode
+        conn.send({
+            kind: "session.update",
+            config: {
+                instructions: "You are a helpful assistant. Be very brief.",
+            },
+        });
+        await waitFor(conn, "session.updated");
+        // add user message
+        conn.send({
+            kind: "item.create",
+            item: {
+                kind: "message",
+                id: "test-msg-1",
+                role: "user",
+                content: [{ kind: "text", text: "Say exactly: hello world" }],
+            },
+        });
+        // trigger response
+        conn.send({ kind: "response.create" });
+        // wait for response to complete
+        await waitFor(conn, "response.done", 15000);
+        conn.close();
+        // verify event flow
+        const kinds = events.map((e) => e.kind);
+        expect(kinds).toContain("session.created");
+        expect(kinds).toContain("session.updated");
+        expect(kinds).toContain("response.created");
+        expect(kinds).toContain("response.done");
+        // verify response completed successfully
+        const done = events.find((e) => e.kind === "response.done");
+        if (done?.kind === "response.done") {
+            expect(done.status).toBe("completed");
+        }
+    });
+    it("should handle tool calling", { timeout: 20000 }, async () => {
+        const conn = await model.connect();
+        const events = [];
+        conn.on("event", (e) => {
+            events.push(e);
+        });
+        await waitFor(conn, "session.created");
+        // configure with a tool
+        conn.send({
+            kind: "session.update",
+            config: {
+                instructions: "You have access to tools. Use them when appropriate.",
+                tools: [
+                    {
+                        kind: "function",
+                        name: "get_weather",
+                        description: "Get the current weather for a location",
+                        parameters: {
+                            type: "object",
+                            properties: {
+                                location: { type: "string", description: "City name" },
+                            },
+                            required: ["location"],
+                        },
+                    },
+                ],
+            },
+        });
+        await waitFor(conn, "session.updated");
+        // ask about weather
+        conn.send({
+            kind: "item.create",
+            item: {
+                kind: "message",
+                id: "test-msg-2",
+                role: "user",
+                content: [{ kind: "text", text: "What is the weather in Tokyo?" }],
+            },
+        });
+        conn.send({ kind: "response.create" });
+        // wait for tool call
+        const toolCall = await waitFor(conn, "tool.call", 15000);
+        expect(toolCall.kind).toBe("tool.call");
+        if (toolCall.kind !== "tool.call") {
+            throw new Error("Expected tool.call");
+        }
+        expect(toolCall.toolId).toBe("get_weather");
+        const args = JSON.parse(toolCall.arguments);
+        expect(args.location.toLowerCase()).toContain("tokyo");
+        // wait for first response to complete before sending tool result
+        await waitFor(conn, "response.done", 15000);
+        // send tool result
+        conn.send({
+            kind: "tool.result",
+            callId: toolCall.callId,
+            result: JSON.stringify({ temperature: 22, condition: "sunny" }),
+        });
+        // trigger follow-up response
+        conn.send({ kind: "response.create" });
+        // wait for second response to complete
+        await waitFor(conn, "response.done", 15000);
+        conn.close();
+        // verify we got multiple response.done events (initial + follow-up)
+        const doneEvents = events.filter((e) => e.kind === "response.done");
+        expect(doneEvents.length).toBeGreaterThanOrEqual(2);
+    });
+});
+/**
+ * Wait for a specific event kind.
+ */
+function waitFor(conn, kind, timeout = 10000) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            conn.off("event", handler);
+            reject(new Error(`timeout waiting for ${kind}`));
+        }, timeout);
+        const handler = (e) => {
+            if (e.kind === kind) {
+                clearTimeout(timer);
+                conn.off("event", handler);
+                resolve(e);
+            }
+        };
+        conn.on("event", handler);
+    });
+}

package/dist/__tests__/realtime.test.d.ts

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

package/dist/__tests__/realtime.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/realtime.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/realtime.test.js

@@ -0,0 +1,263 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { EventEmitter } from "node:events";
+import { GrokRealtimeModel } from "../realtime/model.js";
+// Track mock WebSocket instances
+const wsInstances = [];
+function createMockWebSocket() {
+    const emitter = new EventEmitter();
+    emitter.send = vi.fn();
+    emitter.close = vi.fn();
+    emitter.readyState = 1; // OPEN
+    emitter.OPEN = 1;
+    emitter.addEventListener = emitter.on.bind(emitter);
+    emitter.removeEventListener = emitter.off.bind(emitter);
+    return emitter;
+}
+// Mock WebSocket constructor that tracks instances
+const MockWebSocket = function () {
+    const instance = createMockWebSocket();
+    wsInstances.push(instance);
+    return instance;
+};
+describe("GrokRealtimeModel", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        wsInstances.length = 0;
+    });
+    it("should require API key", async () => {
+        const originalEnv = process.env.XAI_API_KEY;
+        delete process.env.XAI_API_KEY;
+        const model = new GrokRealtimeModel();
+        // Connect should fail without API key
+        await expect(model.connect({ websocket: MockWebSocket })).rejects.toThrow("No API key or credential provided");
+        process.env.XAI_API_KEY = originalEnv;
+    });
+    it("should accept API key via options", () => {
+        const model = new GrokRealtimeModel({
+            apiKey: "test-key",
+        });
+        expect(model.modelId).toBe("grok-realtime");
+        expect(model.provider).toBe("xai");
+        expect(model.spec).toBe("1.0");
+    });
+    it("should use XAI_API_KEY env var", () => {
+        const originalEnv = process.env.XAI_API_KEY;
+        process.env.XAI_API_KEY = "env-key";
+        const model = new GrokRealtimeModel();
+        expect(model.modelId).toBe("grok-realtime");
+        process.env.XAI_API_KEY = originalEnv;
+    });
+});
+describe("base64ByteLength", () => {
+    // Test the helper function indirectly through the module
+    // The actual function is not exported, but we can verify the audio length calculation works
+    it("should calculate correct byte length for base64 without padding", () => {
+        // "AAAA" = 3 bytes (no padding needed for 3 bytes)
+        const b64NoPadding = "AAAA";
+        const expectedBytes = 3;
+        const padding = 0;
+        const calculated = (b64NoPadding.length * 3) / 4 - padding;
+        expect(calculated).toBe(expectedBytes);
+    });
+    it("should calculate correct byte length for base64 with single padding", () => {
+        // "AAA=" represents 2 bytes
+        const b64SinglePad = "AAA=";
+        const expectedBytes = 2;
+        const padding = 1;
+        const calculated = (b64SinglePad.length * 3) / 4 - padding;
+        expect(calculated).toBe(expectedBytes);
+    });
+    it("should calculate correct byte length for base64 with double padding", () => {
+        // "AA==" represents 1 byte
+        const b64DoublePad = "AA==";
+        const expectedBytes = 1;
+        const padding = 2;
+        const calculated = (b64DoublePad.length * 3) / 4 - padding;
+        expect(calculated).toBe(expectedBytes);
+    });
+});
+describe("audio length calculation", () => {
+    it("should calculate correct duration for 24kHz PCM16", () => {
+        // 24kHz PCM16 = 24000 samples/sec, 2 bytes/sample = 48000 bytes/sec
+        // 48000 bytes = 1000ms
+        // 4800 bytes = 100ms
+        const bytes = 4800;
+        const expectedMs = (bytes / 2 / 24000) * 1000;
+        expect(expectedMs).toBe(100);
+    });
+    it("should accumulate audio length from multiple chunks", () => {
+        // Simulate multiple audio chunks
+        const chunk1Bytes = 2400; // 50ms
+        const chunk2Bytes = 2400; // 50ms
+        const chunk3Bytes = 2400; // 50ms
+        let totalMs = 0;
+        totalMs += (chunk1Bytes / 2 / 24000) * 1000;
+        totalMs += (chunk2Bytes / 2 / 24000) * 1000;
+        totalMs += (chunk3Bytes / 2 / 24000) * 1000;
+        expect(totalMs).toBe(150);
+    });
+});
+describe("GrokRealtimeConnection (mocked WebSocket)", () => {
+    const apiKey = "test-key";
+    beforeEach(() => {
+        vi.clearAllMocks();
+        wsInstances.length = 0;
+    });
+    const getLastSocket = () => {
+        if (wsInstances.length === 0) {
+            throw new Error("No WebSocket instances were created");
+        }
+        return wsInstances[wsInstances.length - 1];
+    };
+    const emitServerEvent = (socket, event) => {
+        const payload = JSON.stringify(event);
+        socket.emit("message", { data: payload });
+    };
+    const createConnectedRealtime = async () => {
+        const model = new GrokRealtimeModel({ apiKey });
+        const connectPromise = model.connect({ websocket: MockWebSocket });
+        const socket = getLastSocket();
+        // Simulate successful WebSocket open.
+        socket.emit("open");
+        const connection = await connectPromise;
+        return { connection, socket };
+    };
+    it("should process a basic conversation flow and emit events", async () => {
+        const { connection, socket } = await createConnectedRealtime();
+        const statusEvents = [];
+        const realtimeEvents = [];
+        connection.on("status", (status) => {
+            statusEvents.push(status);
+        });
+        connection.on("event", (event) => {
+            realtimeEvents.push(event);
+        });
+        // Verify initial status after open.
+        expect(connection.status).toBe("connected");
+        // conversation.created (Grok's equivalent of session.created)
+        emitServerEvent(socket, {
+            type: "conversation.created",
+            event_id: "evt-1",
+            conversation: { id: "conv-1", object: "realtime.conversation" },
+        });
+        // response.created
+        emitServerEvent(socket, {
+            type: "response.created",
+            event_id: "evt-2",
+            response: { id: "resp-1", object: "realtime.response", status: "in_progress", output: [] },
+        });
+        // small audio delta then done
+        emitServerEvent(socket, {
+            type: "response.output_audio.delta",
+            event_id: "evt-3",
+            response_id: "resp-1",
+            item_id: "item-1",
+            output_index: 0,
+            content_index: 0,
+            delta: "AAAA",
+        });
+        emitServerEvent(socket, {
+            type: "response.output_audio.done",
+            event_id: "evt-4",
+            response_id: "resp-1",
+            item_id: "item-1",
+        });
+        // transcript delta then done
+        emitServerEvent(socket, {
+            type: "response.output_audio_transcript.delta",
+            event_id: "evt-5",
+            response_id: "resp-1",
+            item_id: "item-1",
+            delta: "Hello",
+        });
+        emitServerEvent(socket, {
+            type: "response.output_audio_transcript.done",
+            event_id: "evt-6",
+            response_id: "resp-1",
+            item_id: "item-1",
+        });
+        // input transcription
+        emitServerEvent(socket, {
+            type: "conversation.item.input_audio_transcription.completed",
+            event_id: "evt-7",
+            item_id: "item-1",
+            transcript: "User said hello",
+        });
+        // response.done
+        emitServerEvent(socket, {
+            type: "response.done",
+            event_id: "evt-8",
+            response: {
+                id: "resp-1",
+                object: "realtime.response",
+                status: "completed",
+            },
+        });
+        // Close socket to trigger status change and reset.
+        socket.emit("close");
+        // Status events should include closed (connected is emitted before we subscribe).
+        expect(statusEvents).toContain("closed");
+        // We should have seen several realtime events in a sensible order.
+        const kinds = realtimeEvents.map((e) => e?.kind);
+        expect(kinds).toContain("session.created");
+        expect(kinds).toContain("response.created");
+        expect(kinds).toContain("audio.output.delta");
+        expect(kinds).toContain("audio.output.done");
+        expect(kinds).toContain("transcript.output.delta");
+        expect(kinds).toContain("transcript.output");
+        expect(kinds).toContain("transcript.input");
+        expect(kinds).toContain("response.done");
+    });
+    it("should emit interrupted event on speech start", async () => {
+        const { connection, socket } = await createConnectedRealtime();
+        let interrupted = false;
+        connection.on("interrupted", () => {
+            interrupted = true;
+        });
+        // Mark that a response is in progress with some audio.
+        emitServerEvent(socket, {
+            type: "response.created",
+            event_id: "evt-1",
+            response: { id: "resp-1", object: "realtime.response", status: "in_progress", output: [] },
+        });
+        // Single audio delta chunk
+        emitServerEvent(socket, {
+            type: "response.output_audio.delta",
+            event_id: "evt-2",
+            response_id: "resp-1",
+            item_id: "item-1",
+            output_index: 0,
+            content_index: 0,
+            delta: "AAAA",
+        });
+        // speech_started should trigger interrupt logic
+        emitServerEvent(socket, {
+            type: "input_audio_buffer.speech_started",
+            event_id: "evt-3",
+            item_id: "item-2",
+        });
+        expect(interrupted).toBe(true);
+    });
+    it("should handle tool calls", async () => {
+        const { connection, socket } = await createConnectedRealtime();
+        const realtimeEvents = [];
+        connection.on("event", (event) => {
+            realtimeEvents.push(event);
+        });
+        // function call arguments done
+        emitServerEvent(socket, {
+            type: "response.function_call_arguments.done",
+            event_id: "evt-1",
+            call_id: "call-1",
+            name: "get_weather",
+            arguments: '{"location":"Tokyo"}',
+        });
+        const toolCall = realtimeEvents.find((e) => e.kind === "tool.call");
+        expect(toolCall).toBeDefined();
+        if (toolCall?.kind === "tool.call") {
+            expect(toolCall.toolId).toBe("get_weather");
+            expect(toolCall.callId).toBe("call-1");
+            expect(JSON.parse(toolCall.arguments)).toEqual({ location: "Tokyo" });
+        }
+    });
+});

package/dist/connection.d.ts

@@ -0,0 +1,47 @@
+import { Emitter } from "@kernl-sdk/shared";
+import { type RealtimeConnection, type RealtimeConnectionEvents, type RealtimeClientEvent, type TransportStatus, type WebSocketLike } from "@kernl-sdk/protocol";
+/**
+ * Grok realtime connection implementation.
+ */
+export declare class GrokRealtimeConnection extends Emitter<RealtimeConnectionEvents> implements RealtimeConnection {
+    private ws;
+    private _status;
+    private _muted;
+    private _sessionId;
+    private currid;
+    private faudtime;
+    private audlenms;
+    private responding;
+    constructor(socket: WebSocketLike);
+    get status(): TransportStatus;
+    get muted(): boolean;
+    get sessionId(): string | null;
+    /**
+     * Send a client event to the Grok realtime API.
+     */
+    send(event: RealtimeClientEvent): void;
+    /**
+     * Close the WebSocket connection.
+     */
+    close(): void;
+    /**
+     * Mute audio input.
+     */
+    mute(): void;
+    /**
+     * Unmute audio input.
+     */
+    unmute(): void;
+    /**
+     * Interrupt the current response.
+     *
+     * Note: Grok doesn't support response.cancel or item.truncate,
+     * so we just reset local state and emit the interrupted event.
+     */
+    interrupt(): void;
+    /**
+     * Reset audio tracking state.
+     */
+    private reset;
+}
+//# sourceMappingURL=connection.d.ts.map

package/dist/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAK7B;;GAEG;AACH,qBAAa,sBACX,SAAQ,OAAO,CAAC,wBAAwB,CACxC,YAAW,kBAAkB;IAE7B,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAuB;IAGzC,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,UAAU,CAAkB;gBAExB,MAAM,EAAE,aAAa;IA4DjC,IAAI,MAAM,IAAI,eAAe,CAE5B;IAED,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,IAAI,SAAS,IAAI,MAAM,GAAG,IAAI,CAE7B;IAED;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI;IAOtC;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,IAAI,IAAI,IAAI;IAIZ;;OAEG;IACH,MAAM,IAAI,IAAI;IAId;;;;;OAKG;IACH,SAAS,IAAI,IAAI;IASjB;;OAEG;IACH,OAAO,CAAC,KAAK;CAKd"}

package/dist/connection.js

@@ -0,0 +1,138 @@
+import { Emitter } from "@kernl-sdk/shared";
+import { WS_OPEN, } from "@kernl-sdk/protocol";
+import { CLIENT_EVENT, SERVER_EVENT } from "./convert/event.js";
+/**
+ * Grok realtime connection implementation.
+ */
+export class GrokRealtimeConnection extends Emitter {
+    ws;
+    _status = "connecting";
+    _muted = false;
+    _sessionId = null;
+    // Audio state tracking for interruption
+    currid;
+    faudtime;
+    audlenms = 0;
+    responding = false;
+    constructor(socket) {
+        super();
+        this.ws = socket;
+        socket.addEventListener("message", (event) => {
+            try {
+                const data = event && typeof event === "object" && "data" in event
+                    ? event.data
+                    : String(event);
+                const raw = JSON.parse(data);
+                // track audio state for interruption handling
+                if (raw.type === "response.output_audio.delta") {
+                    this.currid = raw.item_id;
+                    if (this.faudtime === undefined) {
+                        this.faudtime = Date.now();
+                        this.audlenms = 0;
+                    }
+                    // calculate audio length assuming 24kHz PCM16
+                    const bytes = base64ByteLength(raw.delta);
+                    this.audlenms += (bytes / 2 / 24000) * 1000;
+                }
+                else if (raw.type === "response.created") {
+                    this.responding = true;
+                }
+                else if (raw.type === "response.done") {
+                    this.responding = false;
+                    this.reset();
+                }
+                else if (raw.type === "input_audio_buffer.speech_started") {
+                    this.interrupt();
+                }
+                const event_ = SERVER_EVENT.decode(raw);
+                if (event_) {
+                    if (event_.kind === "session.created") {
+                        this._sessionId = event_.session.id;
+                    }
+                    this.emit("event", event_);
+                }
+            }
+            catch (err) {
+                this.emit("error", err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+        socket.addEventListener("open", () => {
+            this._status = "connected";
+            this.emit("status", this._status);
+        });
+        socket.addEventListener("close", () => {
+            this._status = "closed";
+            this.reset();
+            this.emit("status", this._status);
+        });
+        socket.addEventListener("error", (event) => {
+            const err = event instanceof Error ? event : new Error("WebSocket error");
+            this.emit("error", err);
+        });
+    }
+    get status() {
+        return this._status;
+    }
+    get muted() {
+        return this._muted;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    /**
+     * Send a client event to the Grok realtime API.
+     */
+    send(event) {
+        const encoded = CLIENT_EVENT.encode(event);
+        if (encoded && this.ws.readyState === WS_OPEN) {
+            this.ws.send(JSON.stringify(encoded));
+        }
+    }
+    /**
+     * Close the WebSocket connection.
+     */
+    close() {
+        this.reset();
+        this.ws.close();
+    }
+    /**
+     * Mute audio input.
+     */
+    mute() {
+        this._muted = true;
+    }
+    /**
+     * Unmute audio input.
+     */
+    unmute() {
+        this._muted = false;
+    }
+    /**
+     * Interrupt the current response.
+     *
+     * Note: Grok doesn't support response.cancel or item.truncate,
+     * so we just reset local state and emit the interrupted event.
+     */
+    interrupt() {
+        if (this.responding) {
+            this.responding = false;
+        }
+        this.emit("interrupted");
+        this.reset();
+    }
+    /**
+     * Reset audio tracking state.
+     */
+    reset() {
+        this.currid = undefined;
+        this.faudtime = undefined;
+        this.audlenms = 0;
+    }
+}
+/**
+ * Get byte length from base64 string without decoding.
+ */
+function base64ByteLength(b64) {
+    const padding = b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0;
+    return (b64.length * 3) / 4 - padding;
+}

package/dist/convert/event.d.ts

@@ -0,0 +1,28 @@
+import type { Codec } from "@kernl-sdk/shared/lib";
+import type { RealtimeClientEvent, RealtimeServerEvent, RealtimeSessionConfig, TurnDetectionConfig, LanguageModelItem, AudioConfig } from "@kernl-sdk/protocol";
+import type { GrokClientEvent, GrokServerEvent, GrokSessionConfig, GrokTurnDetection, GrokItem, GrokAudioConfig } from "../protocol.js";
+/**
+ * Codec for turn detection config.
+ */
+export declare const TURN_DETECTION: Codec<TurnDetectionConfig, GrokTurnDetection | null>;
+/**
+ * Codec for audio config.
+ */
+export declare const AUDIO_CONFIG: Codec<AudioConfig, GrokAudioConfig>;
+/**
+ * Codec for session config.
+ */
+export declare const SESSION_CONFIG: Codec<RealtimeSessionConfig, GrokSessionConfig>;
+/**
+ * Codec for conversation items.
+ */
+export declare const ITEM: Codec<LanguageModelItem, GrokItem>;
+/**
+ * Codec for client events (kernl → Grok).
+ */
+export declare const CLIENT_EVENT: Codec<RealtimeClientEvent, GrokClientEvent | null>;
+/**
+ * Codec for server events (Grok → kernl).
+ */
+export declare const SERVER_EVENT: Codec<RealtimeServerEvent | null, GrokServerEvent>;
+//# sourceMappingURL=event.d.ts.map

package/dist/convert/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/convert/event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,QAAQ,EAER,eAAe,EAGhB,MAAM,aAAa,CAAC;AAcrB;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAChC,mBAAmB,EACnB,iBAAiB,GAAG,IAAI,CAazB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,WAAW,EAAE,eAAe,CAyC5D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,qBAAqB,EAAE,iBAAiB,CAgC1E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,KAAK,CAAC,iBAAiB,EAAE,QAAQ,CA8DnD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,mBAAmB,EAAE,eAAe,GAAG,IAAI,CAuDzE,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,mBAAmB,GAAG,IAAI,EAAE,eAAe,CAuHzE,CAAC"}