@fencyai/js 0.1.191 → 0.1.193

package/lib/stream/StreamEventManager.js

@@ -0,0 +1,271 @@
+import { base64Decode } from '../utils/base64Decode';
+import { EventStreamContentType, fetchEventSource, } from '@microsoft/fetch-event-source';
+import { createStreamWorkerCode } from './createStreamWorkerCode';
+function streamFailureMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    return 'Unknown stream error';
+}
+/**
+ * Centralized manager for EventSource connections to streams.
+ * Ensures only one connection per stream regardless of how many hooks subscribe.
+ *
+ * When a Web Worker is available, the main thread performs fetch (correct CORS origin)
+ * and transfers the response body to the worker for parsing, so the read loop is not
+ * stalled by background tab throttling. Otherwise falls back to fetchEventSource on
+ * the main thread with openWhenHidden so the connection is not aborted on tab switch.
+ * @public
+ */
+export class StreamEventManager {
+    constructor(fency) {
+        this.activeConnections = new Map();
+        this.subscribers = new Map();
+        this.worker = null;
+        this.workerBlobUrl = null;
+        this.workerSupported = false;
+        this.fency = fency;
+        this.tryInitWorker();
+    }
+    tryInitWorker() {
+        try {
+            if (typeof Worker === 'undefined' ||
+                typeof Blob === 'undefined' ||
+                typeof URL === 'undefined' ||
+                typeof URL.createObjectURL !== 'function' ||
+                typeof ReadableStream === 'undefined') {
+                return;
+            }
+            const code = createStreamWorkerCode();
+            const blob = new Blob([code], { type: 'application/javascript' });
+            const blobUrl = URL.createObjectURL(blob);
+            const worker = new Worker(blobUrl);
+            worker.onmessage = (e) => {
+                this.handleWorkerMessage(e.data);
+            };
+            worker.onerror = (event) => {
+                console.error('Fency stream worker error:', event.message);
+            };
+            this.worker = worker;
+            this.workerBlobUrl = blobUrl;
+            this.workerSupported = true;
+        }
+        catch {
+            this.workerSupported = false;
+            this.worker = null;
+            if (this.workerBlobUrl) {
+                URL.revokeObjectURL(this.workerBlobUrl);
+                this.workerBlobUrl = null;
+            }
+        }
+    }
+    handleWorkerMessage(data) {
+        if (!data || typeof data !== 'object')
+            return;
+        const msg = data;
+        switch (msg.type) {
+            case 'message':
+                if (msg.data && msg.streamId) {
+                    const decodedData = base64Decode(msg.data);
+                    this.broadcast(decodedData, msg.streamId);
+                }
+                break;
+            case 'error':
+                if (msg.streamId) {
+                    this.activeConnections.delete(msg.streamId);
+                    this.broadcastError(msg.streamId, msg.error);
+                }
+                break;
+            case 'open':
+                break;
+            default:
+                break;
+        }
+    }
+    /**
+     * Called by FencyProvider when activeStreams changes.
+     * Creates new connections and removes old ones.
+     */
+    updateStreams(streams) {
+        streams.forEach((streamCache) => {
+            const streamId = streamCache.stream.id;
+            if (!this.activeConnections.has(streamId)) {
+                this.connectStream(streamCache);
+            }
+        });
+        const activeStreamIds = new Set(streams.map((s) => s.stream.id));
+        this.activeConnections.forEach((connection, streamId) => {
+            if (!activeStreamIds.has(streamId)) {
+                connection.abort();
+                this.activeConnections.delete(streamId);
+            }
+        });
+    }
+    connectStream(streamCache) {
+        if (this.workerSupported && this.worker) {
+            this.connectStreamInWorker(streamCache);
+        }
+        else {
+            this.connectStreamOnMainThread(streamCache);
+        }
+    }
+    connectStreamInWorker(streamCache) {
+        const streamId = streamCache.stream.id;
+        const url = `${this.fency.baseUrl}/sse/streams/${streamId}`;
+        const fetchAbort = new AbortController();
+        const headers = {
+            accept: EventStreamContentType,
+            'X-Fency-Publishable-Key': this.fency.publishableKey,
+            'X-Fency-Stream-Token': streamCache.stream.token,
+        };
+        this.activeConnections.set(streamId, {
+            abort: () => {
+                fetchAbort.abort();
+                this.worker?.postMessage({ command: 'disconnect', streamId });
+            },
+        });
+        void this.startWorkerStream(streamId, url, headers, fetchAbort, streamCache);
+    }
+    async startWorkerStream(streamId, url, headers, fetchAbort, streamCache) {
+        const worker = this.worker;
+        if (!worker)
+            return;
+        const fail = (message) => {
+            if (fetchAbort.signal.aborted)
+                return;
+            this.activeConnections.delete(streamId);
+            this.broadcastError(streamId, message);
+        };
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers,
+                signal: fetchAbort.signal,
+            });
+            if (!response.ok) {
+                if (response.status >= 400 &&
+                    response.status < 500 &&
+                    response.status !== 429) {
+                    fail(`Client error ${response.status}`);
+                }
+                else {
+                    fail(`HTTP ${response.status}`);
+                }
+                return;
+            }
+            const body = response.body;
+            if (!body) {
+                fail('No response body');
+                return;
+            }
+            if (!this.activeConnections.has(streamId)) {
+                await body.cancel().catch(() => {
+                    // ignore
+                });
+                return;
+            }
+            try {
+                worker.postMessage({ command: 'start', streamId, readableStream: body }, [body]);
+            }
+            catch {
+                // ReadableStream transfer not supported (e.g. Safari).
+                // Disable worker for this session and fall back to main-thread SSE.
+                this.workerSupported = false;
+                body.cancel().catch(() => { });
+                this.activeConnections.delete(streamId);
+                this.connectStreamOnMainThread(streamCache);
+            }
+        }
+        catch (err) {
+            if (fetchAbort.signal.aborted)
+                return;
+            fail(streamFailureMessage(err));
+        }
+    }
+    connectStreamOnMainThread(streamCache) {
+        const streamId = streamCache.stream.id;
+        const abortController = new AbortController();
+        this.activeConnections.set(streamId, {
+            abort: () => abortController.abort(),
+        });
+        const url = `${this.fency.baseUrl}/sse/streams/${streamId}`;
+        const headers = {
+            'X-Fency-Publishable-Key': this.fency.publishableKey,
+            'X-Fency-Stream-Token': streamCache.stream.token,
+        };
+        fetchEventSource(url, {
+            headers,
+            signal: abortController.signal,
+            openWhenHidden: true,
+            onopen: async (response) => {
+                if (response.ok) {
+                    return;
+                }
+                if (response.status >= 400 &&
+                    response.status < 500 &&
+                    response.status !== 429) {
+                    this.activeConnections.delete(streamId);
+                    throw new Error(`Client error ${response.status}`);
+                }
+            },
+            onmessage: (message) => {
+                if (message.data) {
+                    const decodedData = base64Decode(message.data);
+                    this.broadcast(decodedData, streamId);
+                }
+            },
+            onerror: (error) => {
+                console.error('EventSource error for stream', streamId, ':', error);
+                this.activeConnections.delete(streamId);
+                this.broadcastError(streamId, streamFailureMessage(error));
+                throw error;
+            },
+            onclose() {
+                // Connection closed by server
+            },
+        });
+    }
+    /**
+     * Subscribe to events from all active streams.
+     * Returns an unsubscribe function.
+     */
+    subscribe(subscriberId, callbacks) {
+        this.subscribers.set(subscriberId, callbacks);
+        return () => {
+            this.subscribers.delete(subscriberId);
+        };
+    }
+    broadcast(data, streamId) {
+        this.subscribers.forEach((subscription) => {
+            subscription.onMessage(data, streamId);
+        });
+    }
+    broadcastError(streamId, errorMessage) {
+        this.subscribers.forEach((subscription) => {
+            subscription.onError(streamId, errorMessage);
+        });
+    }
+    /**
+     * Cleanup all connections and subscriptions
+     */
+    cleanup() {
+        this.activeConnections.forEach((connection) => connection.abort());
+        this.activeConnections.clear();
+        if (this.worker) {
+            try {
+                this.worker.postMessage({ command: 'cleanup' });
+            }
+            catch {
+                // ignore
+            }
+            this.worker = null;
+        }
+        if (this.workerBlobUrl) {
+            URL.revokeObjectURL(this.workerBlobUrl);
+            this.workerBlobUrl = null;
+        }
+        this.workerSupported = false;
+        this.subscribers.clear();
+    }
+}

package/lib/stream/createStreamWorkerCode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the source code for the inline SSE stream Web Worker.
+ * Consumes a ReadableStream transferred from the main thread (same-origin fetch + CORS)
+ * so the read loop runs off the main thread and is not stalled by tab throttling.
+ * @public
+ */
+export declare function createStreamWorkerCode(): string;
+//# sourceMappingURL=createStreamWorkerCode.d.ts.map

package/lib/stream/createStreamWorkerCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStreamWorkerCode.d.ts","sourceRoot":"","sources":["../../src/stream/createStreamWorkerCode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAiJ/C"}

package/lib/stream/createStreamWorkerCode.js

@@ -0,0 +1,152 @@
+/**
+ * Returns the source code for the inline SSE stream Web Worker.
+ * Consumes a ReadableStream transferred from the main thread (same-origin fetch + CORS)
+ * so the read loop runs off the main thread and is not stalled by tab throttling.
+ * @public
+ */
+export function createStreamWorkerCode() {
+    return `
+var connections = new Map();
+
+function disconnectStream(streamId) {
+  var entry = connections.get(streamId);
+  if (entry) {
+    try {
+      entry.cancel();
+    } catch (e) {}
+    connections.delete(streamId);
+  }
+}
+
+function findEventBoundary(buf) {
+  var iCRLF = buf.indexOf("\\r\\n\\r\\n");
+  var iLF = buf.indexOf("\\n\\n");
+  if (iCRLF !== -1 && (iLF === -1 || iCRLF < iLF)) {
+    return { index: iCRLF, len: 4 };
+  }
+  if (iLF !== -1) {
+    return { index: iLF, len: 2 };
+  }
+  return null;
+}
+
+function parseSseBuffer(buffer) {
+  var events = [];
+  var rest = buffer;
+  while (true) {
+    var boundary = findEventBoundary(rest);
+    if (!boundary) break;
+    var rawEvent = rest.slice(0, boundary.index);
+    rest = rest.slice(boundary.index + boundary.len);
+    if (!rawEvent.trim()) continue;
+
+    var eventType = "";
+    var eventId = "";
+    var dataLines = [];
+    var lines = rawEvent.split(/\\r\\n|\\r|\\n/);
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i];
+      if (line.charAt(0) === ":") continue;
+      var colon = line.indexOf(":");
+      if (colon === -1) continue;
+      var field = line.slice(0, colon);
+      var value = line.slice(colon + 1);
+      if (value.charAt(0) === " ") value = value.slice(1);
+      if (field === "data") dataLines.push(value);
+      else if (field === "event") eventType = value;
+      else if (field === "id") eventId = value;
+    }
+    var data = dataLines.join("\\n");
+    if (data.length > 0) {
+      events.push({ data: data, event: eventType, id: eventId });
+    }
+  }
+  return { events: events, rest: rest };
+}
+
+async function readStream(streamId, readableStream) {
+  disconnectStream(streamId);
+  if (!readableStream || typeof readableStream.getReader !== "function") {
+    self.postMessage({
+      type: "error",
+      streamId: streamId,
+      error: "No readable stream",
+    });
+    return;
+  }
+  var reader = readableStream.getReader();
+  connections.set(streamId, {
+    cancel: function () {
+      reader.cancel().catch(function () {});
+    },
+  });
+  try {
+    var decoder = new TextDecoder();
+    var buf = "";
+    while (true) {
+      var readResult = await reader.read();
+      var done = readResult.done;
+      var value = readResult.value;
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      var parsed = parseSseBuffer(buf);
+      buf = parsed.rest;
+      for (var j = 0; j < parsed.events.length; j++) {
+        var ev = parsed.events[j];
+        self.postMessage({
+          type: "message",
+          streamId: streamId,
+          data: ev.data,
+          event: ev.event || undefined,
+          id: ev.id || undefined,
+        });
+      }
+    }
+    buf += decoder.decode();
+    var finalParsed = parseSseBuffer(buf);
+    for (var k = 0; k < finalParsed.events.length; k++) {
+      var fev = finalParsed.events[k];
+      self.postMessage({
+        type: "message",
+        streamId: streamId,
+        data: fev.data,
+        event: fev.event || undefined,
+        id: fev.id || undefined,
+      });
+    }
+  } catch (err) {
+    if (err && err.name === "AbortError") {
+      return;
+    }
+    var msg = err && err.message ? String(err.message) : String(err);
+    self.postMessage({ type: "error", streamId: streamId, error: msg });
+  } finally {
+    connections.delete(streamId);
+  }
+}
+
+self.onmessage = function (e) {
+  var d = e.data;
+  if (!d || !d.command) return;
+  switch (d.command) {
+    case "start":
+      readStream(d.streamId, d.readableStream);
+      break;
+    case "disconnect":
+      disconnectStream(d.streamId);
+      break;
+    case "cleanup":
+      connections.forEach(function (entry) {
+        try {
+          entry.cancel();
+        } catch (e2) {}
+      });
+      connections.clear();
+      self.close();
+      break;
+    default:
+      break;
+  }
+};
+`.trim();
+}

package/lib/stream/toStreamData.d.ts

@@ -0,0 +1,4 @@
+import { StreamData } from '../types/StreamData';
+/** @public */
+export declare const toStreamData: (data: string) => StreamData | null;
+//# sourceMappingURL=toStreamData.d.ts.map

package/lib/stream/toStreamData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toStreamData.d.ts","sourceRoot":"","sources":["../../src/stream/toStreamData.ts"],"names":[],"mappings":"AAWA,OAAO,EAEH,UAAU,EAGb,MAAM,qBAAqB,CAAA;AAE5B,cAAc;AACd,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,KAAG,UAAU,GAAG,IAQxD,CAAA"}

package/lib/stream/toStreamData.js

@@ -0,0 +1,61 @@
+import { isAgentTaskProgressItemUpdatedEvent, isStreamNotFoundEvent, isStreamTimeoutEvent, } from '../utils/streamEventTypes';
+import { parseAgentTaskEventData } from '../parsing/AgentTaskEventDataSchemas';
+/** @public */
+export const toStreamData = (data) => {
+    try {
+        const json = JSON.parse(data);
+        return toStreamDataRaw(json);
+    }
+    catch (error) {
+        console.error('Error parsing message:', error);
+        return null;
+    }
+};
+const toStreamDataRaw = (data) => {
+    if (isStreamTimeoutEvent(data)) {
+        return toStreamTimeout(data);
+    }
+    if (isStreamNotFoundEvent(data)) {
+        return toStreamNotFound(data);
+    }
+    if (isAgentTaskProgressItemUpdatedEvent(data)) {
+        return toAgentTaskProgressItemUpdated(data);
+    }
+    return null;
+};
+const toStreamTimeout = (data) => {
+    return {
+        type: 'STREAM_TIMEOUT',
+        streamId: data.streamId,
+        timestamp: data.timestamp,
+    };
+};
+const toStreamNotFound = (data) => {
+    return {
+        type: 'STREAM_NOT_FOUND',
+        streamId: data.streamId,
+        timestamp: data.timestamp,
+    };
+};
+const toAgentTaskProgressItemUpdated = (data) => {
+    let raw;
+    try {
+        raw = JSON.parse(data.data);
+    }
+    catch (error) {
+        console.warn('[fency] Invalid JSON in AGENT_TASK_PROGRESS_ITEM_UPDATED data payload:', error);
+        return null;
+    }
+    const parsed = parseAgentTaskEventData(raw);
+    if (parsed === null)
+        return null;
+    return {
+        type: 'AGENT_TASK_PROGRESS_ITEM_UPDATED',
+        streamId: data.streamId,
+        agentTaskId: data.agentTaskId,
+        progressItemId: data.progressItemId,
+        timestamp: data.timestamp,
+        createdAt: data.createdAt,
+        data: parsed,
+    };
+};

package/lib/task/mapCreateAgentTaskParams.d.ts

@@ -0,0 +1,18 @@
+import type { AgentTaskEventData } from '../AgentTaskEventData';
+import type { ApiError } from '../types/ApiError';
+import type { CreateAgentTaskRequest } from '../types/CreateAgentTaskRequest';
+import type { CreateAgentTaskParams } from '../types/CreateAgentTaskParams';
+import type { CreateAgentTaskResponse } from '../types/CreateAgentTaskResponse';
+/** @public */
+export declare function mapCreateAgentTaskParams(params: CreateAgentTaskParams): CreateAgentTaskRequest;
+/** @public */
+export declare function isTerminalAgentTaskEventData(data: AgentTaskEventData): data is Extract<AgentTaskEventData, {
+    eventType: 'Completed' | 'Error';
+}>;
+/** @public */
+export declare function shouldAppendCompletedToProgress(data: AgentTaskEventData): boolean;
+/** @public */
+export declare function agentTaskErrorFromEventData(data: AgentTaskEventData): ApiError | null;
+/** @public */
+export declare function getTerminalCreateAgentTaskResponse(streamId: string, agentTaskId: string, data: AgentTaskEventData): CreateAgentTaskResponse | null;
+//# sourceMappingURL=mapCreateAgentTaskParams.d.ts.map

package/lib/task/mapCreateAgentTaskParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapCreateAgentTaskParams.d.ts","sourceRoot":"","sources":["../../src/task/mapCreateAgentTaskParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAA;AAC7E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAA;AAC3E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAA;AAE/E,cAAc;AACd,wBAAgB,wBAAwB,CACpC,MAAM,EAAE,qBAAqB,GAC9B,sBAAsB,CAiDxB;AAED,cAAc;AACd,wBAAgB,4BAA4B,CACxC,IAAI,EAAE,kBAAkB,GACzB,IAAI,IAAI,OAAO,CAAC,kBAAkB,EAAE;IAAE,SAAS,EAAE,WAAW,GAAG,OAAO,CAAA;CAAE,CAAC,CAE3E;AAED,cAAc;AACd,wBAAgB,+BAA+B,CAC3C,IAAI,EAAE,kBAAkB,GACzB,OAAO,CAMT;AAED,cAAc;AACd,wBAAgB,2BAA2B,CACvC,IAAI,EAAE,kBAAkB,GACzB,QAAQ,GAAG,IAAI,CASjB;AAED,cAAc;AACd,wBAAgB,kCAAkC,CAC9C,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,kBAAkB,GACzB,uBAAuB,GAAG,IAAI,CAoBhC"}

package/lib/task/mapCreateAgentTaskParams.js

@@ -0,0 +1,84 @@
+/** @public */
+export function mapCreateAgentTaskParams(params) {
+    return {
+        streamingChatCompletionTask: params.type === 'StreamingChatCompletion'
+            ? {
+                messages: params.messages,
+                model: params.model,
+                ...(params.temperature !== undefined
+                    ? { temperature: params.temperature }
+                    : {}),
+                ...(params.topP !== undefined ? { topP: params.topP } : {}),
+            }
+            : undefined,
+        structuredChatCompletionTask: params.type === 'StructuredChatCompletion'
+            ? {
+                messages: params.messages,
+                jsonSchema: params.jsonSchema,
+                model: params.model,
+                ...(params.temperature !== undefined
+                    ? { temperature: params.temperature }
+                    : {}),
+                ...(params.topP !== undefined ? { topP: params.topP } : {}),
+            }
+            : undefined,
+        memoryChatTask: params.type === 'MemoryChat'
+            ? {
+                messages: params.messages,
+                model: params.model,
+                language: params.language ?? 'en',
+                chunkLimit: params.chunkLimit ?? 10,
+                memoryScanLimit: params.memoryScanLimit ?? 3,
+            }
+            : undefined,
+        memorySearchTask: params.type === 'MemorySearch'
+            ? {
+                query: params.query,
+                model: params.model,
+                language: params.language ?? 'en',
+                chunkLimit: params.chunkLimit ?? 10,
+                contextExpansion: params.contextExpansion,
+                ...(params.queryExpansion != null
+                    ? { queryExpansion: params.queryExpansion }
+                    : {}),
+            }
+            : undefined,
+    };
+}
+/** @public */
+export function isTerminalAgentTaskEventData(data) {
+    return data.eventType === 'Completed' || data.eventType === 'Error';
+}
+/** @public */
+export function shouldAppendCompletedToProgress(data) {
+    return ((data.taskType === 'MemorySearch' && data.eventType === 'Completed') ||
+        (data.taskType === 'StructuredChatCompletion' &&
+            data.eventType === 'Completed'));
+}
+/** @public */
+export function agentTaskErrorFromEventData(data) {
+    if (data.eventType !== 'Error')
+        return null;
+    return {
+        code: 'AgentTaskError',
+        message: 'message' in data && typeof data.message === 'string'
+            ? data.message
+            : 'Agent task failed',
+    };
+}
+/** @public */
+export function getTerminalCreateAgentTaskResponse(streamId, agentTaskId, data) {
+    if (data.eventType === 'Error') {
+        const error = agentTaskErrorFromEventData(data);
+        return error ? { type: 'error', error } : null;
+    }
+    if (data.eventType === 'Completed') {
+        return {
+            type: 'success',
+            streamId,
+            agentTaskId,
+            response: data,
+        };
+    }
+    return null;
+}

package/lib/task/progressItems.d.ts

@@ -0,0 +1,5 @@
+import type { AgentTaskEventData } from '../AgentTaskEventData';
+import type { AgentTaskProgressItemUpdated } from '../types/StreamData';
+export declare function upsertProgressItem(progressItems: AgentTaskProgressItemUpdated[], item: AgentTaskProgressItemUpdated): AgentTaskProgressItemUpdated[];
+export declare function createSyntheticCompletedProgressItem(agentTaskId: string, streamId: string, data: AgentTaskEventData): AgentTaskProgressItemUpdated;
+//# sourceMappingURL=progressItems.d.ts.map

package/lib/task/progressItems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progressItems.d.ts","sourceRoot":"","sources":["../../src/task/progressItems.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAC/D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAA;AAEvE,wBAAgB,kBAAkB,CAC9B,aAAa,EAAE,4BAA4B,EAAE,EAC7C,IAAI,EAAE,4BAA4B,GACnC,4BAA4B,EAAE,CAUhC;AAED,wBAAgB,oCAAoC,CAChD,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,kBAAkB,GACzB,4BAA4B,CAW9B"}

package/lib/task/progressItems.js

@@ -0,0 +1,19 @@
+export function upsertProgressItem(progressItems, item) {
+    const alreadyExists = progressItems.some((p) => p.progressItemId === item.progressItemId);
+    if (alreadyExists) {
+        return progressItems.map((p) => p.progressItemId === item.progressItemId ? item : p);
+    }
+    return [...progressItems, item];
+}
+export function createSyntheticCompletedProgressItem(agentTaskId, streamId, data) {
+    const timestamp = new Date().toISOString();
+    return {
+        type: 'AGENT_TASK_PROGRESS_ITEM_UPDATED',
+        streamId,
+        agentTaskId,
+        progressItemId: `completed-${agentTaskId}`,
+        timestamp,
+        createdAt: timestamp,
+        data,
+    };
+}

package/lib/task/taskReducer.d.ts

@@ -0,0 +1,7 @@
+import type { TaskEvent, TaskStoreState } from './types';
+/** @public */
+export declare const initialTaskStoreState: TaskStoreState;
+/** @public */
+export declare function taskReducer(state: TaskStoreState, event: TaskEvent): TaskStoreState;
+export { agentTaskErrorFromEventData, getTerminalCreateAgentTaskResponse, isTerminalAgentTaskEventData, mapCreateAgentTaskParams, shouldAppendCompletedToProgress, } from './mapCreateAgentTaskParams';
+//# sourceMappingURL=taskReducer.d.ts.map

package/lib/task/taskReducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskReducer.d.ts","sourceRoot":"","sources":["../../src/task/taskReducer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAOxD,cAAc;AACd,eAAO,MAAM,qBAAqB,EAAE,cAA8B,CAAA;AAElE,cAAc;AACd,wBAAgB,WAAW,CACvB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,SAAS,GACjB,cAAc,CA+GhB;AAED,OAAO,EACH,2BAA2B,EAC3B,kCAAkC,EAClC,4BAA4B,EAC5B,wBAAwB,EACxB,+BAA+B,GAClC,MAAM,4BAA4B,CAAA"}