@providerprotocol/ai 0.0.33 → 0.0.35

package/dist/types-C8Gciizr.d.ts

@@ -0,0 +1,168 @@
+import { S as StreamEvent } from './stream-CecfVCPO.js';
+
+/**
+ * @fileoverview Pub-sub middleware types for stream resumption.
+ *
+ * Defines interfaces for temporary stream storage, replay, and
+ * multi-client broadcast during active generation.
+ *
+ * @module middleware/pubsub/types
+ */
+
+/**
+ * Stored stream state.
+ */
+interface StoredStream {
+    readonly streamId: string;
+    readonly modelId: string;
+    readonly provider: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly completed: boolean;
+    readonly events: readonly StreamEvent[];
+}
+/**
+ * Subscription callback for live events.
+ *
+ * @param event - Stream event payload
+ * @param cursor - Zero-based event index when adapter supports cursors
+ */
+type SubscriptionCallback = (event: StreamEvent, cursor?: number) => void;
+/**
+ * Unsubscribe function returned by subscribe.
+ */
+type Unsubscribe = () => void;
+/**
+ * Storage adapter interface for pub-sub middleware.
+ *
+ * Implement this interface for custom backends (Redis, etc.).
+ *
+ * @example
+ * ```typescript
+ * const redisAdapter: PubSubAdapter = {
+ *   async create(streamId, metadata) {
+ *     await redis.hset(`stream:${streamId}`, metadata);
+ *   },
+ *   // ... other methods
+ * };
+ * ```
+ */
+interface PubSubAdapter {
+    /**
+     * Checks if a stream exists.
+     *
+     * @param streamId - Stream identifier to check
+     * @returns True if the stream exists
+     */
+    exists(streamId: string): Promise<boolean>;
+    /**
+     * Creates a stream entry.
+     *
+     * @param streamId - Unique stream identifier
+     * @param metadata - Stream metadata (modelId, provider)
+     */
+    create(streamId: string, metadata: {
+        modelId: string;
+        provider: string;
+    }): Promise<void>;
+    /**
+     * Appends an event to the stream.
+     *
+     * @param streamId - Stream to append to
+     * @param event - Stream event to store
+     */
+    append(streamId: string, event: StreamEvent): Promise<void>;
+    /**
+     * Marks stream as completed.
+     *
+     * @param streamId - Stream to mark complete
+     */
+    markCompleted(streamId: string): Promise<void>;
+    /**
+     * Checks if stream is completed.
+     *
+     * @param streamId - Stream to check
+     * @returns True if stream is completed
+     */
+    isCompleted(streamId: string): Promise<boolean>;
+    /**
+     * Fetches all events for replay.
+     *
+     * @param streamId - Stream to fetch events from
+     * @returns Array of events or null if stream doesn't exist
+     */
+    getEvents(streamId: string): Promise<StreamEvent[] | null>;
+    /**
+     * Gets stream metadata.
+     *
+     * @param streamId - Stream to get
+     * @returns Stream metadata or null if not found
+     */
+    getStream(streamId: string): Promise<StoredStream | null>;
+    /**
+     * Subscribes to live events for a stream.
+     *
+     * @param streamId - Stream to subscribe to
+     * @param callback - Function called for each new event
+     * @param callback.cursor - Zero-based index of the event when supported
+     * @returns Unsubscribe function
+     */
+    subscribe(streamId: string, callback: SubscriptionCallback): Unsubscribe;
+    /**
+     * Publishes event to all subscribers.
+     *
+     * @param streamId - Stream to publish to
+     * @param event - Event to broadcast
+     */
+    publish(streamId: string, event: StreamEvent): void;
+    /**
+     * Removes a stream (cleanup).
+     *
+     * @param streamId - Stream to remove
+     */
+    remove(streamId: string): Promise<void>;
+    /**
+     * Removes streams older than maxAge.
+     *
+     * @param maxAge - Maximum age in milliseconds
+     */
+    cleanup(maxAge: number): Promise<void>;
+}
+/**
+ * Options for pub-sub middleware.
+ */
+interface PubSubOptions {
+    /**
+     * Storage adapter instance.
+     * @default memoryAdapter()
+     */
+    adapter?: PubSubAdapter;
+    /**
+     * Stream identifier for reconnection support.
+     *
+     * When provided:
+     * - If stream exists in adapter → Reconnection, replay buffered events
+     * - If stream doesn't exist → New request, create entry and proceed
+     *
+     * When not provided:
+     * - No pub/sub behavior, middleware is effectively disabled
+     */
+    streamId?: string;
+    /**
+     * TTL for stored streams in milliseconds.
+     * @default 600000 (10 minutes)
+     */
+    ttl?: number;
+}
+/**
+ * Options for memory adapter.
+ */
+interface MemoryAdapterOptions {
+    /**
+     * Max streams to keep (LRU eviction).
+     * @default 1000
+     */
+    maxStreams?: number;
+}
+
+export type { MemoryAdapterOptions as M, PubSubAdapter as P, StoredStream as S, Unsubscribe as U, PubSubOptions as a, SubscriptionCallback as b };

package/dist/utils/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Partial JSON parser for streaming LLM responses.
+ *
+ * Enables incremental parsing of JSON data as it streams from LLM providers,
+ * allowing consumers to access usable partial objects during streaming rather
+ * than waiting for complete JSON.
+ *
+ * @module utils/partial-json
+ */
+/**
+ * Result of parsing partial JSON.
+ *
+ * @typeParam T - The expected type of the parsed value
+ */
+interface PartialParseResult<T = unknown> {
+    /** The parsed value, or undefined if parsing failed */
+    value: T | undefined;
+    /** Whether the JSON was complete and valid */
+    isComplete: boolean;
+}
+/**
+ * Parses potentially incomplete JSON, returning as much as can be extracted.
+ *
+ * Handles common incomplete states during streaming:
+ * - Incomplete strings: `{"name":"Jo` → `{name: "Jo"}`
+ * - Incomplete objects: `{"a":1,"b":` → `{a: 1}`
+ * - Incomplete arrays: `[1,2,` → `[1, 2]`
+ * - Incomplete numbers, booleans, null literals
+ * - Nested structures with partial completion
+ * - Unicode escape sequences
+ *
+ * @typeParam T - The expected type of the parsed value
+ * @param json - The potentially incomplete JSON string
+ * @returns A PartialParseResult with the parsed value and completion status
+ *
+ * @example
+ * ```typescript
+ * // Complete JSON
+ * parsePartialJson('{"name":"John"}');
+ * // => { value: { name: "John" }, isComplete: true }
+ *
+ * // Incomplete object
+ * parsePartialJson('{"user":{"firstName":"Jo');
+ * // => { value: { user: { firstName: "Jo" } }, isComplete: false }
+ *
+ * // Incomplete array
+ * parsePartialJson('[1, 2, 3');
+ * // => { value: [1, 2, 3], isComplete: false }
+ * ```
+ */
+declare function parsePartialJson<T = unknown>(json: string): PartialParseResult<T>;
+
+export { type PartialParseResult, parsePartialJson };

package/dist/utils/index.js

@@ -0,0 +1,7 @@
+import {
+  parsePartialJson
+} from "../chunk-I53CI6ZZ.js";
+export {
+  parsePartialJson
+};
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/xai/index.d.ts

@@ -1,4 +1,5 @@
-import { P as Provider } from '../llm-BQJZj3cD.js';
+import { d as Provider } from '../llm-DwbUK7un.js';
+import '../stream-CecfVCPO.js';
 
 /**
  * xAI Chat Completions API parameters (OpenAI-compatible).