@umituz/web-ai 1.0.11 → 1.2.0

package/dist/remote-chat-client-LrNlew4n.d.cts

@@ -0,0 +1,70 @@
+interface StreamCallbacks<TToolCall = unknown> {
+    onDelta(channel: 'answer' | 'reasoning', text: string): void;
+    onUsage?(usage: {
+        inputTokens: number;
+        outputTokens: number;
+        reasoningTokens?: number;
+    }): void;
+    onToolCall?(toolCall: TToolCall): void;
+    onDone?(messageId: string): void;
+    onError?(code: string, message: string): void;
+}
+type ParsedSseEvent<TToolCall = unknown> = {
+    readonly type: 'delta';
+    readonly channel: 'answer' | 'reasoning';
+    readonly text: string;
+} | {
+    readonly type: 'usage';
+    readonly usage: {
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+        readonly reasoningTokens?: number;
+    };
+} | {
+    readonly type: 'tool_call';
+    readonly toolCall: TToolCall;
+} | {
+    readonly type: 'done';
+    readonly messageId: string;
+} | {
+    readonly type: 'error';
+    readonly code: string;
+    readonly message: string;
+};
+declare function parseSseEvent<TToolCall = unknown>(rawEvent: string): ParsedSseEvent<TToolCall> | null;
+declare function readSseResponse<TToolCall = unknown>(response: Response, callbacks: StreamCallbacks<TToolCall>): Promise<void>;
+
+/** Body the backend chat endpoint expects. Kept generic on purpose —
+ *  `settings` is whatever the app's API contract defines. */
+interface RemoteChatStreamBody {
+    readonly mode?: "append" | "regenerate";
+    readonly content?: string;
+    readonly modelId?: string;
+    readonly settings?: Record<string, unknown>;
+}
+/** Endpoint templates; both are required so the client never guesses URL
+ *  shapes. Example:
+ *  `{ stream: (id) => \`/api/conversations/${id}/stream\`,
+ *     resolveToolCall: (id, callId) => \`/api/conversations/${id}/tool-calls/${callId}/resolve\` }` */
+interface RemoteChatUrls {
+    readonly stream: (conversationId: string) => string;
+    readonly resolveToolCall: (conversationId: string, toolCallId: string) => string;
+}
+interface RemoteChatClientOptions {
+    readonly urls: RemoteChatUrls;
+    readonly fetchImpl?: typeof fetch;
+}
+interface RemoteStreamHandle {
+    readonly promise: Promise<void>;
+    abort(): void;
+}
+interface RemoteChatClient {
+    /** POST the chat request and dispatch the SSE stream to `callbacks`. */
+    streamChat<TToolCall = unknown>(conversationId: string, body: RemoteChatStreamBody, callbacks: StreamCallbacks<TToolCall>): RemoteStreamHandle;
+    /** Approve/reject a pending tool call. Resolves true when the server
+     *  answered with a continuation stream (consumed into `callbacks`). */
+    resolveToolCall<TToolCall = unknown>(conversationId: string, toolCallId: string, approved: boolean, callbacks: StreamCallbacks<TToolCall>): Promise<boolean>;
+}
+declare function createRemoteChatClient(options: RemoteChatClientOptions): RemoteChatClient;
+
+export { type ParsedSseEvent as P, type RemoteChatClient as R, type StreamCallbacks as S, type RemoteChatClientOptions as a, type RemoteChatStreamBody as b, type RemoteChatUrls as c, type RemoteStreamHandle as d, createRemoteChatClient as e, parseSseEvent as p, readSseResponse as r };

package/dist/remote-chat-client-LrNlew4n.d.ts

@@ -0,0 +1,70 @@
+interface StreamCallbacks<TToolCall = unknown> {
+    onDelta(channel: 'answer' | 'reasoning', text: string): void;
+    onUsage?(usage: {
+        inputTokens: number;
+        outputTokens: number;
+        reasoningTokens?: number;
+    }): void;
+    onToolCall?(toolCall: TToolCall): void;
+    onDone?(messageId: string): void;
+    onError?(code: string, message: string): void;
+}
+type ParsedSseEvent<TToolCall = unknown> = {
+    readonly type: 'delta';
+    readonly channel: 'answer' | 'reasoning';
+    readonly text: string;
+} | {
+    readonly type: 'usage';
+    readonly usage: {
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+        readonly reasoningTokens?: number;
+    };
+} | {
+    readonly type: 'tool_call';
+    readonly toolCall: TToolCall;
+} | {
+    readonly type: 'done';
+    readonly messageId: string;
+} | {
+    readonly type: 'error';
+    readonly code: string;
+    readonly message: string;
+};
+declare function parseSseEvent<TToolCall = unknown>(rawEvent: string): ParsedSseEvent<TToolCall> | null;
+declare function readSseResponse<TToolCall = unknown>(response: Response, callbacks: StreamCallbacks<TToolCall>): Promise<void>;
+
+/** Body the backend chat endpoint expects. Kept generic on purpose —
+ *  `settings` is whatever the app's API contract defines. */
+interface RemoteChatStreamBody {
+    readonly mode?: "append" | "regenerate";
+    readonly content?: string;
+    readonly modelId?: string;
+    readonly settings?: Record<string, unknown>;
+}
+/** Endpoint templates; both are required so the client never guesses URL
+ *  shapes. Example:
+ *  `{ stream: (id) => \`/api/conversations/${id}/stream\`,
+ *     resolveToolCall: (id, callId) => \`/api/conversations/${id}/tool-calls/${callId}/resolve\` }` */
+interface RemoteChatUrls {
+    readonly stream: (conversationId: string) => string;
+    readonly resolveToolCall: (conversationId: string, toolCallId: string) => string;
+}
+interface RemoteChatClientOptions {
+    readonly urls: RemoteChatUrls;
+    readonly fetchImpl?: typeof fetch;
+}
+interface RemoteStreamHandle {
+    readonly promise: Promise<void>;
+    abort(): void;
+}
+interface RemoteChatClient {
+    /** POST the chat request and dispatch the SSE stream to `callbacks`. */
+    streamChat<TToolCall = unknown>(conversationId: string, body: RemoteChatStreamBody, callbacks: StreamCallbacks<TToolCall>): RemoteStreamHandle;
+    /** Approve/reject a pending tool call. Resolves true when the server
+     *  answered with a continuation stream (consumed into `callbacks`). */
+    resolveToolCall<TToolCall = unknown>(conversationId: string, toolCallId: string, approved: boolean, callbacks: StreamCallbacks<TToolCall>): Promise<boolean>;
+}
+declare function createRemoteChatClient(options: RemoteChatClientOptions): RemoteChatClient;
+
+export { type ParsedSseEvent as P, type RemoteChatClient as R, type StreamCallbacks as S, type RemoteChatClientOptions as a, type RemoteChatStreamBody as b, type RemoteChatUrls as c, type RemoteStreamHandle as d, createRemoteChatClient as e, parseSseEvent as p, readSseResponse as r };

package/dist/{requestQueue-D89wx91Q.d.cts → requestQueue--h2uZ-Q3.d.cts}

@@ -2,7 +2,7 @@ import { f as AspectRatio, o as ImageQuality, w as VideoQuality, t as SentimentA
 import { B as BlogGenerationRequest, G as GeneratedBlog, m as SocialContentRequest, h as GeneratedSocialContent, q as VideoScriptRequest, i as GeneratedVideoScript, c as ContentTone, b as ContentCalendarEntry, n as SocialPlatform, E as Emotion } from './index-BulSkB2L.cjs';
 import { c as ITextGenerator, e as ProviderFactory, T as TextGenerationOptions } from './provider.factory-Ce6Een1G.cjs';
 import { d as ProviderConfig, I as ImageGenerationRequest, G as GeneratedContent, V as VideoGenerationRequest, a as ImageToVideoRequest, b as VideoToVideoRequest } from './ProviderConfig-DIFa9nmG.cjs';
-import { A as AIProviderConfig } from './create-ai-DRysRImc.cjs';
+import { A as AIProviderConfig } from './create-ai-DDyTVzef.cjs';
 import { T as TextRequest, G as GenerationResult } from './index-OhvYUTXf.cjs';
 
 declare function resolveDimensionsForAspectRatio(ratio: AspectRatio): {

package/dist/{requestQueue-AP6n_bRH.d.ts → requestQueue-BGeCy4Fd.d.ts}

@@ -2,7 +2,7 @@ import { f as AspectRatio, o as ImageQuality, w as VideoQuality, t as SentimentA
 import { B as BlogGenerationRequest, G as GeneratedBlog, m as SocialContentRequest, h as GeneratedSocialContent, q as VideoScriptRequest, i as GeneratedVideoScript, c as ContentTone, b as ContentCalendarEntry, n as SocialPlatform, E as Emotion } from './index-BUVULo3h.js';
 import { c as ITextGenerator, e as ProviderFactory, T as TextGenerationOptions } from './provider.factory-B9RNUTYj.js';
 import { d as ProviderConfig, I as ImageGenerationRequest, G as GeneratedContent, V as VideoGenerationRequest, a as ImageToVideoRequest, b as VideoToVideoRequest } from './ProviderConfig-DIFa9nmG.js';
-import { A as AIProviderConfig } from './create-ai-D-oEWzf9.js';
+import { A as AIProviderConfig } from './create-ai-Cq3HkJxd.js';
 import { T as TextRequest, G as GenerationResult } from './index-OhvYUTXf.js';
 
 declare function resolveDimensionsForAspectRatio(ratio: AspectRatio): {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-ai",
-  "version": "1.0.11",
+  "version": "1.2.0",
   "description": "Provider-agnostic AI engine for web and edge — text, chat, structured output and streaming over swappable providers (Anthropic, Groq, Gemini, fal, Pruna), plus a content generation suite",
   "type": "module",
   "main": "./dist/index.cjs",

package/dist/tool-call-accumulator-C7KhaXZA.d.cts

@@ -1,69 +0,0 @@
-interface RetryOptions {
-    readonly maxAttempts?: number;
-    readonly initialDelay?: number;
-    readonly maxDelay?: number;
-    readonly backoffMultiplier?: number;
-    readonly jitterFactor?: number;
-    readonly shouldRetry?: (error: Error) => boolean;
-}
-declare class RetryManager {
-    private readonly defaults;
-    constructor();
-    execute<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-    private shouldRetry;
-    private delay;
-}
-declare const retryManager: RetryManager;
-declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-
-interface QueueOptions {
-    readonly maxConcurrent?: number;
-    readonly defaultPriority?: number;
-    readonly requestTimeout?: number;
-}
-declare class RequestQueue {
-    private queue;
-    private readonly activeRequests;
-    private readonly maxConcurrent;
-    private readonly defaultPriority;
-    private readonly requestTimeout;
-    private requestIdCounter;
-    constructor(options?: QueueOptions);
-    add<T>(requestFn: () => Promise<T>, priority?: number): Promise<T>;
-    cancelAll(): void;
-    private sortQueue;
-    private process;
-    private executeRequest;
-}
-declare const requestQueue: RequestQueue;
-
-declare class RequestDeduplicator {
-    private readonly pendingRequests;
-    private readonly ttl;
-    constructor(ttl?: number);
-    execute<T>(key: string, requestFn: () => Promise<T>): Promise<T>;
-    cancelAll(): void;
-    private cleanup;
-}
-declare const requestDeduplicator: RequestDeduplicator;
-
-interface WireToolCallDelta {
-    readonly index?: number;
-    readonly id?: string;
-    readonly function?: {
-        readonly name?: string;
-        readonly arguments?: string;
-    };
-}
-interface AssistantToolCall {
-    readonly id: string;
-    readonly name: string;
-    readonly arguments: string;
-}
-declare class ToolCallAccumulator {
-    private readonly slots;
-    push(delta: WireToolCallDelta): void;
-    finish(): AssistantToolCall[];
-}
-
-export { type AssistantToolCall as A, type QueueOptions as Q, RequestDeduplicator as R, ToolCallAccumulator as T, type WireToolCallDelta as W, RequestQueue as a, RetryManager as b, type RetryOptions as c, requestQueue as d, retryManager as e, requestDeduplicator as r, withRetry as w };

package/dist/tool-call-accumulator-C7KhaXZA.d.ts

@@ -1,69 +0,0 @@
-interface RetryOptions {
-    readonly maxAttempts?: number;
-    readonly initialDelay?: number;
-    readonly maxDelay?: number;
-    readonly backoffMultiplier?: number;
-    readonly jitterFactor?: number;
-    readonly shouldRetry?: (error: Error) => boolean;
-}
-declare class RetryManager {
-    private readonly defaults;
-    constructor();
-    execute<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-    private shouldRetry;
-    private delay;
-}
-declare const retryManager: RetryManager;
-declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-
-interface QueueOptions {
-    readonly maxConcurrent?: number;
-    readonly defaultPriority?: number;
-    readonly requestTimeout?: number;
-}
-declare class RequestQueue {
-    private queue;
-    private readonly activeRequests;
-    private readonly maxConcurrent;
-    private readonly defaultPriority;
-    private readonly requestTimeout;
-    private requestIdCounter;
-    constructor(options?: QueueOptions);
-    add<T>(requestFn: () => Promise<T>, priority?: number): Promise<T>;
-    cancelAll(): void;
-    private sortQueue;
-    private process;
-    private executeRequest;
-}
-declare const requestQueue: RequestQueue;
-
-declare class RequestDeduplicator {
-    private readonly pendingRequests;
-    private readonly ttl;
-    constructor(ttl?: number);
-    execute<T>(key: string, requestFn: () => Promise<T>): Promise<T>;
-    cancelAll(): void;
-    private cleanup;
-}
-declare const requestDeduplicator: RequestDeduplicator;
-
-interface WireToolCallDelta {
-    readonly index?: number;
-    readonly id?: string;
-    readonly function?: {
-        readonly name?: string;
-        readonly arguments?: string;
-    };
-}
-interface AssistantToolCall {
-    readonly id: string;
-    readonly name: string;
-    readonly arguments: string;
-}
-declare class ToolCallAccumulator {
-    private readonly slots;
-    push(delta: WireToolCallDelta): void;
-    finish(): AssistantToolCall[];
-}
-
-export { type AssistantToolCall as A, type QueueOptions as Q, RequestDeduplicator as R, ToolCallAccumulator as T, type WireToolCallDelta as W, RequestQueue as a, RetryManager as b, type RetryOptions as c, requestQueue as d, retryManager as e, requestDeduplicator as r, withRetry as w };