@ekairos/events 1.22.67-beta.development.0 → 1.22.68-beta.development.0

package/dist/react.context-event-parts.d.ts

@@ -0,0 +1,18 @@
+type ActionStatus = "started" | "completed" | "failed";
+export type ContextActionPartInfo = {
+    actionName: string;
+    actionCallId: string;
+    status: ActionStatus;
+    input?: unknown;
+    output?: unknown;
+    errorText?: string;
+};
+export declare function normalizeContextEventParts(parts: unknown[]): Record<string, unknown>[];
+export declare function getActionPartInfo(part: unknown): ContextActionPartInfo | null;
+export declare function getCreateMessageText(part: unknown): string;
+export declare function getPartText(part: unknown): string;
+export declare function getReasoningText(part: unknown): string;
+export declare function getReasoningState(part: unknown): string;
+export declare function getSourceParts(part: unknown): any[];
+export declare function findNormalizedToolPart(parts: unknown[], toolName: string): Record<string, unknown> | null;
+export {};

package/dist/react.context-event-parts.js

@@ -0,0 +1,509 @@
+function asRecord(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    return value;
+}
+function asText(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function cleanRecord(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+function buildFileUrl(block) {
+    if (typeof block.url === "string" && block.url.length > 0) {
+        return block.url;
+    }
+    if (typeof block.data === "string" && block.data.length > 0) {
+        return block.data.startsWith("data:")
+            ? block.data
+            : `data:${block.mediaType};base64,${block.data}`;
+    }
+    if (typeof block.fileId === "string" && block.fileId.length > 0) {
+        return block.fileId;
+    }
+    return "";
+}
+function readTextPayload(value) {
+    const record = asRecord(value);
+    if (!record)
+        return asText(value);
+    return (asText(record.text) ||
+        asText(record.message) ||
+        asText(record.summary) ||
+        asText(asRecord(record.content)?.text) ||
+        asText(asRecord(record.content)?.message));
+}
+function normalizeContentBlock(value) {
+    const record = asRecord(value);
+    if (!record || typeof record.type !== "string")
+        return null;
+    if (record.type === "text") {
+        const text = asText(record.text);
+        return text ? { type: "text", text } : null;
+    }
+    if (record.type === "file") {
+        const mediaType = asText(record.mediaType) || "application/octet-stream";
+        const file = cleanRecord({
+            type: "file",
+            mediaType,
+            filename: asText(record.filename) || undefined,
+            data: asText(record.data) || undefined,
+            url: buildFileUrl({
+                mediaType,
+                data: asText(record.data) || undefined,
+                url: asText(record.url) || undefined,
+                fileId: asText(record.fileId) || undefined,
+            }) || undefined,
+            fileId: asText(record.fileId) || undefined,
+        });
+        return file.url || file.data || file.fileId ? file : null;
+    }
+    if (record.type === "json") {
+        return { type: "json", value: record.value };
+    }
+    if (record.type === "source-url") {
+        const url = asText(record.url);
+        if (!url)
+            return null;
+        return cleanRecord({
+            type: "source-url",
+            sourceId: asText(record.sourceId) || "source-url",
+            url,
+            title: asText(record.title) || undefined,
+        });
+    }
+    if (record.type === "source-document") {
+        return cleanRecord({
+            type: "source-document",
+            sourceId: asText(record.sourceId) || "source-document",
+            mediaType: asText(record.mediaType) || "application/octet-stream",
+            title: asText(record.title) || "Document",
+            filename: asText(record.filename) || undefined,
+        });
+    }
+    return null;
+}
+function normalizeBlocks(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((block) => normalizeContentBlock(block))
+        .filter((block) => Boolean(block));
+}
+function blocksToMessageContent(blocks) {
+    const text = blocks
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n")
+        .trim();
+    const hasNonText = blocks.some((block) => block.type !== "text");
+    return cleanRecord({
+        text: text || undefined,
+        blocks: hasNonText ? blocks : undefined,
+    });
+}
+function blocksToValue(blocks) {
+    if (blocks.length === 0)
+        return undefined;
+    if (blocks.length === 1) {
+        const first = blocks[0];
+        if (first.type === "json")
+            return first.value;
+        if (first.type === "text")
+            return first.text;
+        if (first.type === "file")
+            return first;
+    }
+    return {
+        type: "content",
+        value: blocks,
+    };
+}
+function blocksToErrorText(blocks) {
+    const text = blocks
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n\n")
+        .trim();
+    if (text)
+        return text;
+    const jsonBlock = blocks.find((block) => block.type === "json");
+    if (jsonBlock) {
+        return JSON.stringify(jsonBlock.value, null, 2);
+    }
+    return "";
+}
+function normalizeMessagePart(part) {
+    const content = asRecord(part.content) ?? {};
+    const rawBlocks = Array.isArray(content.blocks)
+        ? content.blocks
+        : Array.isArray(part.content)
+            ? part.content
+            : [];
+    const blocks = normalizeBlocks(rawBlocks);
+    const text = readTextPayload(content) || readTextPayload(part);
+    if (text) {
+        blocks.unshift({ type: "text", text });
+    }
+    const messageContent = blocksToMessageContent(blocks);
+    return Object.keys(messageContent).length > 0
+        ? [{ type: "message", content: messageContent }]
+        : [];
+}
+function normalizeReasoningPart(part) {
+    const content = part.content;
+    const contentRecord = asRecord(content);
+    const text = Array.isArray(content)
+        ? normalizeBlocks(content)
+            .filter((block) => block.type === "text")
+            .map((block) => block.text)
+            .join("\n\n")
+        : readTextPayload(contentRecord) || asText(part.text);
+    const state = asText(contentRecord?.state) ||
+        asText(part.state) ||
+        undefined;
+    return text || state
+        ? [
+            {
+                type: "reasoning",
+                content: cleanRecord({
+                    text,
+                    state,
+                }),
+            },
+        ]
+        : [];
+}
+function normalizeSourcePart(part) {
+    const content = part.content;
+    const rawSources = Array.isArray(content)
+        ? content
+        : Array.isArray(asRecord(content)?.sources)
+            ? asRecord(content)?.sources
+            : [];
+    const sources = normalizeBlocks(rawSources).filter((block) => block.type === "source-url" || block.type === "source-document");
+    return sources.length > 0
+        ? [
+            {
+                type: "source",
+                content: { sources },
+            },
+        ]
+        : [];
+}
+function normalizeActionStatus(value, fallback) {
+    const status = (asText(value) || asText(fallback)).toLowerCase();
+    if (status === "failed" || status === "error" || status === "output-error") {
+        return "failed";
+    }
+    if (status === "completed" ||
+        status === "complete" ||
+        status === "output-available") {
+        return "completed";
+    }
+    return "started";
+}
+function normalizeActionPart(part) {
+    const content = asRecord(part.content) ?? {};
+    const actionName = asText(content.actionName) ||
+        asText(content.toolName) ||
+        asText(part.actionName) ||
+        asText(part.toolName);
+    if (!actionName)
+        return [];
+    const output = content.output ?? part.output;
+    const error = content.error ?? content.errorText ?? part.error ?? part.errorText;
+    const status = normalizeActionStatus(content.status ?? part.status, error !== undefined ? "failed" : output !== undefined ? "completed" : "started");
+    const actionCallId = asText(content.actionCallId) ||
+        asText(content.toolCallId) ||
+        asText(content.actionRef) ||
+        asText(part.actionCallId) ||
+        asText(part.toolCallId) ||
+        asText(part.actionRef) ||
+        actionName;
+    if (status === "failed") {
+        return [
+            {
+                type: "action",
+                content: {
+                    status,
+                    actionName,
+                    actionCallId,
+                    error: {
+                        message: readTextPayload(error) || "Action failed.",
+                    },
+                },
+            },
+        ];
+    }
+    if (status === "completed") {
+        return [
+            {
+                type: "action",
+                content: {
+                    status,
+                    actionName,
+                    actionCallId,
+                    output,
+                },
+            },
+        ];
+    }
+    return [
+        {
+            type: "action",
+            content: {
+                status,
+                actionName,
+                actionCallId,
+                input: content.input ?? part.input,
+            },
+        },
+    ];
+}
+function normalizeLegacyToolPart(part) {
+    const type = asText(part.type);
+    if (!type.startsWith("tool-"))
+        return [];
+    const actionName = type.slice("tool-".length);
+    const actionCallId = asText(part.toolCallId) || asText(part.actionCallId) || actionName;
+    const state = asText(part.state).toLowerCase();
+    const input = part.input ?? part.args;
+    const parts = [
+        {
+            type: "action",
+            content: {
+                status: "started",
+                actionName,
+                actionCallId,
+                input,
+            },
+        },
+    ];
+    if (state === "output-error") {
+        parts.push({
+            type: "action",
+            content: {
+                status: "failed",
+                actionName,
+                actionCallId,
+                error: {
+                    message: readTextPayload(part.errorText ?? part.error) || "Action failed.",
+                },
+            },
+        });
+    }
+    else if (state === "output-available") {
+        parts.push({
+            type: "action",
+            content: {
+                status: "completed",
+                actionName,
+                actionCallId,
+                output: part.output,
+            },
+        });
+    }
+    return parts;
+}
+function normalizeLegacyToolCallPart(part) {
+    const toolName = asText(part.toolName);
+    const toolCallId = asText(part.toolCallId);
+    if (!toolName || !toolCallId)
+        return [];
+    const content = normalizeBlocks(part.content);
+    return [
+        {
+            type: "action",
+            content: {
+                status: "started",
+                actionName: toolName,
+                actionCallId: toolCallId,
+                input: blocksToValue(content),
+            },
+        },
+    ];
+}
+function normalizeLegacyToolResultPart(part) {
+    const toolName = asText(part.toolName);
+    const toolCallId = asText(part.toolCallId);
+    if (!toolName || !toolCallId)
+        return [];
+    const content = normalizeBlocks(part.content);
+    const state = asText(part.state).toLowerCase();
+    const failed = state === "output-error";
+    return [
+        failed
+            ? {
+                type: "action",
+                content: {
+                    status: "failed",
+                    actionName: toolName,
+                    actionCallId: toolCallId,
+                    error: {
+                        message: blocksToErrorText(content) || "Action failed.",
+                    },
+                },
+            }
+            : {
+                type: "action",
+                content: {
+                    status: "completed",
+                    actionName: toolName,
+                    actionCallId: toolCallId,
+                    output: blocksToValue(content),
+                },
+            },
+    ];
+}
+function normalizePart(part) {
+    const record = asRecord(part);
+    if (!record || typeof record.type !== "string") {
+        return record ? [record] : [];
+    }
+    if (record.type === "text" || record.type === "file") {
+        return [record];
+    }
+    if (record.type === "source-url" || record.type === "source-document") {
+        const source = normalizeContentBlock(record);
+        return source ? [source] : [];
+    }
+    if (record.type === "content") {
+        const blocks = normalizeBlocks(record.content);
+        const content = blocksToMessageContent(blocks);
+        return Object.keys(content).length > 0
+            ? [{ type: "message", content }]
+            : [];
+    }
+    if (record.type === "message") {
+        return normalizeMessagePart(record);
+    }
+    if (record.type === "reasoning") {
+        return normalizeReasoningPart(record);
+    }
+    if (record.type === "source") {
+        return normalizeSourcePart(record);
+    }
+    if (record.type === "action" || record.type === "action_result") {
+        return normalizeActionPart(record);
+    }
+    if (record.type === "tool-call") {
+        return normalizeLegacyToolCallPart(record);
+    }
+    if (record.type === "tool-result") {
+        return normalizeLegacyToolResultPart(record);
+    }
+    if (record.type.startsWith("tool-")) {
+        return normalizeLegacyToolPart(record);
+    }
+    if (record.type.startsWith("data-")) {
+        return [
+            {
+                type: "message",
+                content: {
+                    blocks: [{ type: "json", value: record.data }],
+                },
+            },
+        ];
+    }
+    return [record];
+}
+export function normalizeContextEventParts(parts) {
+    return (Array.isArray(parts) ? parts : []).flatMap(normalizePart);
+}
+export function getActionPartInfo(part) {
+    const record = asRecord(part);
+    if (!record)
+        return null;
+    if (typeof record.type === "string" && record.type.startsWith("tool-")) {
+        const actionName = record.type.slice("tool-".length);
+        const status = normalizeActionStatus(record.state);
+        return {
+            actionName,
+            actionCallId: asText(record.toolCallId) || asText(record.actionCallId) || actionName,
+            status,
+            input: record.input ?? record.args,
+            output: record.output,
+            errorText: readTextPayload(record.errorText ?? record.error),
+        };
+    }
+    if (record.type !== "action" && record.type !== "action_result") {
+        return null;
+    }
+    const content = asRecord(record.content) ?? {};
+    const actionName = asText(content.actionName) ||
+        asText(content.toolName) ||
+        asText(record.actionName) ||
+        asText(record.toolName);
+    if (!actionName)
+        return null;
+    const output = content.output ?? record.output;
+    const error = content.error ?? content.errorText ?? record.error ?? record.errorText;
+    const status = normalizeActionStatus(content.status ?? record.status, error !== undefined ? "failed" : output !== undefined ? "completed" : "started");
+    return {
+        actionName,
+        actionCallId: asText(content.actionCallId) ||
+            asText(content.toolCallId) ||
+            asText(content.actionRef) ||
+            asText(record.actionCallId) ||
+            asText(record.toolCallId) ||
+            asText(record.actionRef) ||
+            actionName,
+        status,
+        input: content.input ?? record.input,
+        output,
+        errorText: readTextPayload(error),
+    };
+}
+export function getCreateMessageText(part) {
+    const action = getActionPartInfo(part);
+    if (!action || action.actionName !== "createMessage")
+        return "";
+    if (action.status === "completed") {
+        return readTextPayload(action.output) || readTextPayload(action.input);
+    }
+    return readTextPayload(action.input) || readTextPayload(action.output);
+}
+export function getPartText(part) {
+    const record = asRecord(part);
+    if (!record)
+        return "";
+    if (record.type === "text")
+        return asText(record.text);
+    if (record.type === "message")
+        return readTextPayload(record.content) || readTextPayload(record);
+    return "";
+}
+export function getReasoningText(part) {
+    const record = asRecord(part);
+    if (!record || record.type !== "reasoning")
+        return "";
+    return readTextPayload(record.content) || asText(record.text);
+}
+export function getReasoningState(part) {
+    const record = asRecord(part);
+    if (!record || record.type !== "reasoning")
+        return "";
+    return asText(asRecord(record.content)?.state) || asText(record.state);
+}
+export function getSourceParts(part) {
+    const record = asRecord(part);
+    if (!record)
+        return [];
+    if (record.type === "source-url" || record.type === "source-document") {
+        return [record];
+    }
+    if (record.type !== "source")
+        return [];
+    const sources = asRecord(record.content)?.sources;
+    return Array.isArray(sources)
+        ? sources.filter((source) => asRecord(source))
+        : [];
+}
+export function findNormalizedToolPart(parts, toolName) {
+    const normalized = normalizeContextEventParts(parts);
+    return (normalized.find((part) => {
+        const action = getActionPartInfo(part);
+        return action?.actionName === toolName;
+    }) ?? null);
+}

package/dist/react.d.ts

@@ -1,42 +1,7 @@
-import type { ContextStatus } from "./context.contract.js";
-export type ContextSnapshot<Context = unknown, Item = Record<string, unknown>> = {
-    context: {
-        id: string;
-        key: string | null;
-        name?: string | null;
-        status: ContextStatus;
-        content: Context;
-        createdAt: string | null;
-        updatedAt: string | null;
-    } | null;
-    items: Item[];
-};
-export type ContextStreamChunk = {
-    type: `data-context.${string}`;
-    data?: {
-        contextId?: string;
-    };
-} | {
-    type: string;
-    [key: string]: unknown;
-};
-export type UseContextOptions<Context = unknown, Item = Record<string, unknown>> = {
-    contextKey: string;
-    orgId?: string;
-    endpoint?: string;
-    refreshMs?: number;
-    ensure?: boolean;
-    enabled?: boolean;
-    initialData?: ContextSnapshot<Context, Item> | null;
-    fetchImpl?: typeof fetch;
-};
-export declare function useContext<Context = unknown, Item = Record<string, unknown>>(options: UseContextOptions<Context, Item>): {
-    data: ContextSnapshot<Context, Item> | null;
-    isLoading: boolean;
-    error: string | null;
-    refresh: () => Promise<void>;
-    setData: import("react").Dispatch<import("react").SetStateAction<ContextSnapshot<Context, Item> | null>>;
-    contextId: string | null;
-    applyChunk: (chunk: ContextStreamChunk) => void;
-    url: string;
-};
+export { mergeContextStepPartsForUI, useContext } from "./react.use-context";
+export type { AppendArgs, ContextEventForUI, ContextFirstLevel, ContextStepForUI, ContextStepRuntime, ContextStepStreamInfo, ContextStepStreamReaderInfo, ContextStatus, ContextValue, ReasoningLevel, SendStatus, UseContextArgs, UseContextOptions, UseContextState, UseContextStateHook, } from "./react.types";
+export { ASSISTANT_MESSAGE_TYPE, INPUT_TEXT_ITEM_TYPE } from "./react.types";
+export { findNormalizedToolPart, getActionPartInfo, getCreateMessageText, getPartText, getReasoningState, getReasoningText, getSourceParts, normalizeContextEventParts, } from "./react.context-event-parts";
+export type { ContextActionPartInfo } from "./react.context-event-parts";
+export { buildContextStepViews, buildEventStepsIndex, buildLiveEventFromStepChunks, consumePersistedContextStepStream, extractPersistedContextTree, isUserEvent, } from "./react.step-stream";
+export type { PersistedContextTree } from "./react.step-stream";

package/dist/react.js

@@ -1,88 +1,5 @@
 "use client";
-import { useCallback, useEffect, useMemo, useState } from "react";
-function toErrorMessage(error) {
-    if (error instanceof Error)
-        return error.message;
-    return String(error ?? "unknown_error");
-}
-function buildContextUrl(options) {
-    const base = String(options.endpoint || "/api/context").replace(/\/+$/, "");
-    const key = encodeURIComponent(options.contextKey);
-    const params = new URLSearchParams();
-    if (options.orgId)
-        params.set("orgId", options.orgId);
-    if (options.ensure)
-        params.set("ensure", "1");
-    const query = params.toString();
-    return query.length > 0 ? `${base}/${key}?${query}` : `${base}/${key}`;
-}
-export function useContext(options) {
-    const [data, setData] = useState(options.initialData ?? null);
-    const [isLoading, setIsLoading] = useState(true);
-    const [error, setError] = useState(null);
-    const [contextId, setContextId] = useState(null);
-    const enabled = options.enabled ?? true;
-    const url = useMemo(() => {
-        if (!enabled || !options.contextKey)
-            return "";
-        return buildContextUrl(options);
-    }, [enabled, options.endpoint, options.orgId, options.contextKey, options.ensure]);
-    const refresh = useCallback(async () => {
-        if (!enabled || !options.contextKey)
-            return;
-        setIsLoading(true);
-        setError(null);
-        const fetchImpl = options.fetchImpl ?? fetch;
-        try {
-            const response = await fetchImpl(url, { cache: "no-store" });
-            if (!response.ok) {
-                const body = await response.text();
-                throw new Error(body || `context_fetch_failed:${response.status}`);
-            }
-            const snapshot = (await response.json());
-            setData(snapshot);
-            setContextId(snapshot.context?.id ?? null);
-        }
-        catch (err) {
-            setError(toErrorMessage(err));
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [enabled, options.fetchImpl, options.contextKey, url]);
-    const applyChunk = useCallback((chunk) => {
-        if (!chunk || typeof chunk !== "object")
-            return;
-        if (typeof chunk.type === "string" && chunk.type.startsWith("data-context.")) {
-            const payload = "data" in chunk && chunk.data && typeof chunk.data === "object"
-                ? chunk.data
-                : undefined;
-            const candidate = typeof payload?.contextId === "string"
-                ? payload.contextId
-                : null;
-            if (candidate)
-                setContextId(candidate);
-        }
-    }, []);
-    useEffect(() => {
-        void refresh();
-    }, [refresh]);
-    useEffect(() => {
-        if (!enabled || !options.refreshMs || options.refreshMs <= 0)
-            return;
-        const intervalId = setInterval(() => {
-            void refresh();
-        }, options.refreshMs);
-        return () => clearInterval(intervalId);
-    }, [enabled, options.refreshMs, refresh]);
-    return {
-        data,
-        isLoading,
-        error,
-        refresh,
-        setData,
-        contextId,
-        applyChunk,
-        url,
-    };
-}
+export { mergeContextStepPartsForUI, useContext } from "./react.use-context";
+export { ASSISTANT_MESSAGE_TYPE, INPUT_TEXT_ITEM_TYPE } from "./react.types";
+export { findNormalizedToolPart, getActionPartInfo, getCreateMessageText, getPartText, getReasoningState, getReasoningText, getSourceParts, normalizeContextEventParts, } from "./react.context-event-parts";
+export { buildContextStepViews, buildEventStepsIndex, buildLiveEventFromStepChunks, consumePersistedContextStepStream, extractPersistedContextTree, isUserEvent, } from "./react.step-stream";