@uipath/apollo-vertex 0.0.0-stage → 0.1.0

package/dist/registry/ai-chat/adapters/agenthub/stream.js

@@ -0,0 +1,173 @@
+import { EventType } from "@tanstack/ai";
+import { EventSourceParserStream } from "eventsource-parser/stream";
+import { z } from "zod/v4";
+import { toNormalizedMessages } from "./messages.js";
+import { buildToolDefinitions } from "./tools.js";
+async function* fetchAgentHubStream(config, messages, signal) {
+    const token = "function" == typeof config.accessToken ? config.accessToken() : config.accessToken;
+    if (!token) throw new Error("Not authenticated");
+    const url = `${config.baseUrl}/chat/completions`;
+    const systemPrompt = "function" == typeof config.systemPrompt ? config.systemPrompt() : config.systemPrompt;
+    const body = {
+        model: config.model.name,
+        messages: toNormalizedMessages(messages, systemPrompt, config.model.vendor),
+        max_tokens: config.maxTokens ?? 2048,
+        temperature: config.temperature ?? 0.7,
+        stream: true
+    };
+    if (config.tools && config.tools.length > 0) {
+        body["tools"] = buildToolDefinitions(config.tools, config.model.vendor);
+        body["tool_choice"] = {
+            type: "auto"
+        };
+    }
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+            "X-UiPath-LlmGateway-NormalizedApi-ModelName": config.model.name
+        },
+        body: JSON.stringify(body),
+        signal
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`AgentHub API error: ${response.status} - ${error}`);
+    }
+    if (!response.body) throw new Error("No response body");
+    yield* toStreamChunks(response.body);
+}
+const OpenAIChatStreamChunkSchema = z.object({
+    choices: z.array(z.object({
+        finish_reason: z.string().nullable().optional(),
+        delta: z.object({
+            content: z.string().optional(),
+            tool_calls: z.array(z.object({
+                index: z.number(),
+                id: z.string().optional(),
+                function: z.object({
+                    name: z.string().optional(),
+                    arguments: z.string().optional()
+                }).optional()
+            })).optional()
+        })
+    }))
+});
+function* handleToolCallDelta(tc, toolCalls, parentMessageId) {
+    const idx = tc.index ?? 0;
+    const fn = tc.function;
+    if (toolCalls.has(idx)) {
+        const existing = toolCalls.get(idx);
+        if (fn?.arguments && existing) {
+            existing.arguments += fn.arguments;
+            yield {
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: existing.id,
+                delta: fn.arguments,
+                timestamp: Date.now()
+            };
+        }
+        return;
+    }
+    const id = tc.id ?? crypto.randomUUID();
+    const name = fn?.name ?? "";
+    toolCalls.set(idx, {
+        id,
+        name,
+        arguments: fn?.arguments ?? ""
+    });
+    yield {
+        type: EventType.TOOL_CALL_START,
+        toolCallId: id,
+        toolCallName: name,
+        toolName: name,
+        parentMessageId,
+        timestamp: Date.now()
+    };
+    if (fn?.arguments) yield {
+        type: EventType.TOOL_CALL_ARGS,
+        toolCallId: id,
+        delta: fn.arguments,
+        timestamp: Date.now()
+    };
+}
+async function* toStreamChunks(body) {
+    const messageId = crypto.randomUUID();
+    const runId = crypto.randomUUID();
+    const threadId = crypto.randomUUID();
+    yield {
+        type: EventType.RUN_STARTED,
+        runId,
+        threadId,
+        timestamp: Date.now()
+    };
+    yield {
+        type: EventType.TEXT_MESSAGE_START,
+        messageId,
+        role: "assistant",
+        timestamp: Date.now()
+    };
+    let finishReason = null;
+    const toolCalls = new Map();
+    const eventStream = body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream());
+    for await (const event of eventStream){
+        if ("[DONE]" === event.data) break;
+        let json;
+        try {
+            json = JSON.parse(event.data);
+        } catch  {
+            continue;
+        }
+        const chunkResult = OpenAIChatStreamChunkSchema.safeParse(json);
+        if (!chunkResult.success) continue;
+        const chunk = chunkResult.data;
+        const choice = chunk.choices?.[0];
+        if (!choice) continue;
+        if (choice.finish_reason) finishReason = choice.finish_reason;
+        const delta = choice.delta;
+        if (delta?.content) yield {
+            type: EventType.TEXT_MESSAGE_CONTENT,
+            messageId,
+            delta: delta.content,
+            timestamp: Date.now()
+        };
+        if (delta?.tool_calls) for (const tc of delta.tool_calls)yield* handleToolCallDelta(tc, toolCalls, messageId);
+    }
+    for (const [, tc] of toolCalls){
+        yield {
+            type: EventType.TOOL_CALL_END,
+            toolCallId: tc.id,
+            toolCallName: tc.name,
+            toolName: tc.name,
+            timestamp: Date.now()
+        };
+        let parsedInput = {};
+        try {
+            parsedInput = JSON.parse(tc.arguments);
+        } catch  {}
+        yield {
+            type: EventType.CUSTOM,
+            name: "tool-input-available",
+            value: {
+                toolCallId: tc.id,
+                toolName: tc.name,
+                input: parsedInput
+            },
+            timestamp: Date.now()
+        };
+    }
+    yield {
+        type: EventType.TEXT_MESSAGE_END,
+        messageId,
+        timestamp: Date.now()
+    };
+    yield {
+        type: EventType.RUN_FINISHED,
+        runId,
+        threadId,
+        timestamp: Date.now(),
+        finishReason: "tool_calls" === finishReason ? "tool_calls" : "stop"
+    };
+}
+export { fetchAgentHubStream };

package/dist/registry/ai-chat/adapters/agenthub/tools.d.ts

@@ -0,0 +1,12 @@
+import { type AnyClientTool } from "@tanstack/ai";
+import type { AgentHubVendor } from "./types";
+export declare function buildToolDefinitions(tools: ReadonlyArray<AnyClientTool>, vendor: AgentHubVendor): {
+    type: "custom";
+    name: string;
+    description: string;
+    input_schema: import("@tanstack/ai").JSONSchema | undefined;
+}[] | {
+    name: string;
+    description: string;
+    parameters: import("@tanstack/ai").JSONSchema | undefined;
+}[];

package/dist/registry/ai-chat/adapters/agenthub/tools.js

@@ -0,0 +1,15 @@
+import { convertSchemaToJsonSchema } from "@tanstack/ai";
+function buildToolDefinitions(tools, vendor) {
+    if ("anthropic" === vendor) return tools.map((t)=>({
+            type: "custom",
+            name: t.name,
+            description: t.description,
+            input_schema: convertSchemaToJsonSchema(t.inputSchema)
+        }));
+    return tools.map((t)=>({
+            name: t.name,
+            description: t.description,
+            parameters: convertSchemaToJsonSchema(t.inputSchema)
+        }));
+}
+export { buildToolDefinitions };

package/dist/registry/ai-chat/adapters/agenthub/types.d.ts

@@ -0,0 +1,14 @@
+import type { AnyClientTool } from "@tanstack/ai";
+export type AgentHubVendor = "openai" | "anthropic";
+export interface AgentHubAdapterConfig {
+    baseUrl: string;
+    model: {
+        vendor: AgentHubVendor;
+        name: string;
+    };
+    accessToken: string | (() => string | null);
+    systemPrompt?: string | (() => string);
+    maxTokens?: number;
+    temperature?: number;
+    tools?: ReadonlyArray<AnyClientTool>;
+}

package/dist/registry/ai-chat/adapters/conversational-agent/adapter.d.ts

@@ -0,0 +1,6 @@
+import type { ConnectConnectionAdapter } from "@tanstack/ai-client";
+import type { ConversationalAgentAdapterConfig } from "./types";
+export type { ConversationalAgentAdapterConfig } from "./types";
+export declare function createConversationalAgentConnection(config: ConversationalAgentAdapterConfig): ConnectConnectionAdapter & {
+    dispose: () => void;
+};

package/dist/registry/ai-chat/adapters/conversational-agent/adapter.js

@@ -0,0 +1,25 @@
+import { extractLatestUserText } from "./messages.js";
+import { SessionManager } from "./session.js";
+import { bridgeExchange } from "./stream.js";
+function isUIMessages(messages) {
+    const first = messages[0];
+    return null != first && "parts" in first;
+}
+async function* connectAndStream(sessionManager, text, abortSignal) {
+    const session = await sessionManager.ensureSession();
+    yield* bridgeExchange(session, text, abortSignal);
+}
+function createConversationalAgentConnection(config) {
+    const sessionManager = new SessionManager(config);
+    return {
+        connect (messages, _data, abortSignal) {
+            if (!isUIMessages(messages)) throw new Error("ConversationalAgent adapter requires UIMessages, received ModelMessages");
+            const text = extractLatestUserText(messages);
+            return connectAndStream(sessionManager, text, abortSignal);
+        },
+        dispose () {
+            sessionManager.dispose();
+        }
+    };
+}
+export { createConversationalAgentConnection };

package/dist/registry/ai-chat/adapters/conversational-agent/messages.d.ts

@@ -0,0 +1,8 @@
+import type { UIMessage } from "@tanstack/ai-client";
+/**
+ * Extracts the text content from the last user message.
+ *
+ * The Conversational Agent server tracks conversation history, so we only
+ * need to send the latest user message — not the full history.
+ */
+export declare function extractLatestUserText(messages: UIMessage[]): string;

package/dist/registry/ai-chat/adapters/conversational-agent/messages.js

@@ -0,0 +1,8 @@
+function extractLatestUserText(messages) {
+    for(let i = messages.length - 1; i >= 0; i--){
+        const msg = messages[i];
+        if (msg?.role === "user") return msg.parts.filter((p)=>"text" === p.type).map((p)=>p.content).join("");
+    }
+    return "";
+}
+export { extractLatestUserText };

package/dist/registry/ai-chat/adapters/conversational-agent/session.d.ts

@@ -0,0 +1,14 @@
+import { type SessionStream } from "@uipath/uipath-typescript/conversational-agent";
+import type { ConversationalAgentAdapterConfig } from "./types";
+export declare class SessionManager {
+    private readonly config;
+    private readonly conversationalAgent;
+    private conversationId;
+    private session;
+    private sessionReady;
+    private sessionId;
+    constructor(config: ConversationalAgentAdapterConfig);
+    ensureSession(): Promise<SessionStream>;
+    dispose(): void;
+    private createSession;
+}

package/dist/registry/ai-chat/adapters/conversational-agent/session.js

@@ -0,0 +1,55 @@
+import { ConversationalAgent } from "@uipath/uipath-typescript/conversational-agent";
+class SessionManager {
+    config;
+    conversationalAgent;
+    conversationId = null;
+    session = null;
+    sessionReady = null;
+    sessionId = 0;
+    constructor(config){
+        this.config = config;
+        this.conversationalAgent = new ConversationalAgent(config.sdk);
+    }
+    async ensureSession() {
+        if (this.session && !this.session.ended) return this.session;
+        if (this.sessionReady) return this.sessionReady;
+        this.sessionReady = this.createSession();
+        try {
+            const session = await this.sessionReady;
+            return session;
+        } catch (err) {
+            this.sessionReady = null;
+            throw err;
+        }
+    }
+    dispose() {
+        this.sessionId++;
+        if (this.conversationId && this.session && !this.session.ended) this.conversationalAgent.conversations.endSession(this.conversationId);
+        this.session = null;
+        this.conversationId = null;
+        this.sessionReady = null;
+    }
+    async createSession() {
+        const { agentId, folderId } = this.config;
+        const currentSessionId = this.sessionId;
+        const conversation = await this.conversationalAgent.conversations.create(agentId, folderId);
+        if (currentSessionId !== this.sessionId) throw new Error("Session creation aborted (manager was disposed)");
+        this.conversationId = conversation.id;
+        const session = conversation.startSession({
+            echo: true
+        });
+        const ready = await new Promise((resolve, reject)=>{
+            session.onSessionStarted(()=>resolve(session));
+            session.onErrorStart((err)=>reject(new Error(err.message ?? "Session failed to start")));
+        });
+        this.session = ready;
+        this.sessionReady = null;
+        session.onSessionEnd(()=>{
+            this.session = null;
+            this.conversationId = null;
+            this.sessionReady = null;
+        });
+        return ready;
+    }
+}
+export { SessionManager };

package/dist/registry/ai-chat/adapters/conversational-agent/stream.d.ts

@@ -0,0 +1,3 @@
+import { type StreamChunk } from "@tanstack/ai";
+import type { SessionStream } from "@uipath/uipath-typescript/conversational-agent";
+export declare function bridgeExchange(session: SessionStream, userText: string, signal?: AbortSignal): AsyncIterable<StreamChunk>;

package/dist/registry/ai-chat/adapters/conversational-agent/stream.js

@@ -0,0 +1,157 @@
+import { EventType } from "@tanstack/ai";
+import { MessageRole } from "@uipath/uipath-typescript/conversational-agent";
+function createStreamQueue() {
+    const buffer = [];
+    const waiters = [];
+    let done = false;
+    function push(chunk) {
+        if (done) return;
+        const waiter = waiters.shift();
+        if (waiter) waiter({
+            value: chunk,
+            done: false
+        });
+        else buffer.push(chunk);
+    }
+    function finish() {
+        if (done) return;
+        done = true;
+        for (const waiter of waiters)waiter({
+            value: null,
+            done: true
+        });
+        waiters.length = 0;
+    }
+    const iterable = {
+        [Symbol.asyncIterator] () {
+            return {
+                next () {
+                    const buffered = buffer.shift();
+                    if (buffered) return Promise.resolve({
+                        value: buffered,
+                        done: false
+                    });
+                    if (done) return Promise.resolve({
+                        value: null,
+                        done: true
+                    });
+                    return new Promise((resolve)=>{
+                        waiters.push(resolve);
+                    });
+                }
+            };
+        }
+    };
+    return {
+        push,
+        finish,
+        iterable
+    };
+}
+function bridgeExchange(session, userText, signal) {
+    const queue = createStreamQueue();
+    const runId = crypto.randomUUID();
+    const threadId = crypto.randomUUID();
+    const cleanups = [];
+    queue.push({
+        type: EventType.RUN_STARTED,
+        runId,
+        threadId,
+        timestamp: Date.now()
+    });
+    const exchange = session.startExchange();
+    function finishRun() {
+        for (const cleanup of cleanups)cleanup();
+        cleanups.length = 0;
+    }
+    exchange.onMessageStart((msg)=>{
+        if (!msg.isAssistant) return;
+        const messageId = crypto.randomUUID();
+        queue.push({
+            type: EventType.TEXT_MESSAGE_START,
+            messageId,
+            role: "assistant",
+            timestamp: Date.now()
+        });
+        msg.onContentPartStart((part)=>{
+            if (!part.isMarkdown && !part.isText && !part.isHtml) return;
+            part.onChunk((chunk)=>{
+                queue.push({
+                    type: EventType.TEXT_MESSAGE_CONTENT,
+                    messageId,
+                    delta: chunk.data ?? "",
+                    timestamp: Date.now()
+                });
+            });
+        });
+        msg.onMessageEnd(()=>{
+            queue.push({
+                type: EventType.TEXT_MESSAGE_END,
+                messageId,
+                timestamp: Date.now()
+            });
+        });
+    });
+    exchange.onExchangeEnd(()=>{
+        queue.push({
+            type: EventType.RUN_FINISHED,
+            runId,
+            threadId,
+            finishReason: "stop",
+            timestamp: Date.now()
+        });
+        finishRun();
+        queue.finish();
+    });
+    exchange.onErrorStart((err)=>{
+        queue.push({
+            type: EventType.RUN_ERROR,
+            runId,
+            message: err.message ?? "Exchange error",
+            timestamp: Date.now()
+        });
+        finishRun();
+        queue.finish();
+    });
+    cleanups.push(session.onErrorStart((err)=>{
+        queue.push({
+            type: EventType.RUN_ERROR,
+            runId,
+            message: err.message ?? "Session error",
+            timestamp: Date.now()
+        });
+        finishRun();
+        queue.finish();
+    }));
+    cleanups.push(session.onSessionEnd(()=>{
+        finishRun();
+        queue.finish();
+    }));
+    exchange.sendMessageWithContentPart({
+        data: userText,
+        role: MessageRole.User
+    });
+    if (signal) {
+        const onAbort = ()=>{
+            exchange.sendExchangeEnd();
+            queue.push({
+                type: EventType.RUN_FINISHED,
+                runId,
+                threadId,
+                finishReason: "stop",
+                timestamp: Date.now()
+            });
+            finishRun();
+            queue.finish();
+        };
+        if (signal.aborted) onAbort();
+        else {
+            signal.addEventListener("abort", onAbort, {
+                once: true
+            });
+            cleanups.push(()=>signal.removeEventListener("abort", onAbort));
+        }
+    }
+    return queue.iterable;
+}
+export { bridgeExchange };

package/dist/registry/ai-chat/adapters/conversational-agent/types.d.ts

@@ -0,0 +1,6 @@
+import type { UiPath } from "@uipath/uipath-typescript/core";
+export interface ConversationalAgentAdapterConfig {
+    sdk: UiPath;
+    agentId: number;
+    folderId: number;
+}

package/dist/registry/ai-chat/animations.d.ts

@@ -0,0 +1,28 @@
+export declare const ENTRANCE_EASE: readonly [0.22, 1, 0.36, 1];
+export declare const ENTRANCE_INITIAL: {
+    opacity: number;
+    y: number;
+};
+export declare const ENTRANCE_ANIMATE: {
+    opacity: number;
+    y: number;
+};
+export declare const POP_INITIAL: {
+    opacity: number;
+    y: number;
+    scale: number;
+};
+export declare const POP_ANIMATE: {
+    opacity: number;
+    y: number;
+    scale: number;
+};
+export declare const POP_EXIT: {
+    opacity: number;
+    y: number;
+    scale: number;
+};
+export declare const POP_TRANSITION: {
+    duration: number;
+    ease: readonly [0.22, 1, 0.36, 1];
+};

package/dist/registry/ai-chat/animations.js

@@ -0,0 +1,34 @@
+const ENTRANCE_EASE = [
+    0.22,
+    1,
+    0.36,
+    1
+];
+const ENTRANCE_INITIAL = {
+    opacity: 0,
+    y: 8
+};
+const ENTRANCE_ANIMATE = {
+    opacity: 1,
+    y: 0
+};
+const POP_INITIAL = {
+    opacity: 0,
+    y: 4,
+    scale: 0.96
+};
+const POP_ANIMATE = {
+    opacity: 1,
+    y: 0,
+    scale: 1
+};
+const POP_EXIT = {
+    opacity: 0,
+    y: 4,
+    scale: 0.96
+};
+const POP_TRANSITION = {
+    duration: 0.14,
+    ease: ENTRANCE_EASE
+};
+export { ENTRANCE_ANIMATE, ENTRANCE_EASE, ENTRANCE_INITIAL, POP_ANIMATE, POP_EXIT, POP_INITIAL, POP_TRANSITION };

package/dist/registry/ai-chat/charts/bar-chart-card.d.ts

@@ -0,0 +1,8 @@
+import type { BarChartConfiguration, ChartDataModel, DataAdapter, StringModelField } from "../../charts-core/charts-core";
+interface BarChartCardProps {
+    configuration: BarChartConfiguration;
+    dataModel: ChartDataModel<StringModelField>;
+    dataAdapter: DataAdapter;
+}
+export declare function BarChartCard({ configuration, dataModel, dataAdapter, }: BarChartCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/registry/ai-chat/charts/bar-chart-card.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { BarChartWithAdapter } from "../../bar-chart/bar-chart.js";
+import { Card, CardContent } from "../../card/card.js";
+function BarChartCard({ configuration, dataModel, dataAdapter }) {
+    return /*#__PURE__*/ jsx(Card, {
+        className: "flex flex-col w-full h-[300px] gap-2 py-4",
+        children: /*#__PURE__*/ jsx(CardContent, {
+            className: "flex-1 overflow-hidden p-0",
+            children: /*#__PURE__*/ jsx(BarChartWithAdapter, {
+                configuration: configuration,
+                dataModel: dataModel,
+                dataAdapter: dataAdapter
+            })
+        })
+    });
+}
+export { BarChartCard };

package/dist/registry/ai-chat/charts/distribution-chart-card.d.ts

@@ -0,0 +1,8 @@
+import type { ChartDataModel, DataAdapter, DistributionChartConfiguration, NumericOrDatetimeModelField } from "../../charts-core/charts-core";
+interface DistributionChartCardProps {
+    configuration: DistributionChartConfiguration;
+    dataModel: ChartDataModel<NumericOrDatetimeModelField>;
+    dataAdapter: DataAdapter;
+}
+export declare function DistributionChartCard({ configuration, dataModel, dataAdapter, }: DistributionChartCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/registry/ai-chat/charts/distribution-chart-card.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { Card, CardContent } from "../../card/card.js";
+import { DistributionChartWithAdapter } from "../../distribution-chart/distribution-chart.js";
+function DistributionChartCard({ configuration, dataModel, dataAdapter }) {
+    return /*#__PURE__*/ jsx(Card, {
+        className: "flex flex-col w-full h-[300px] gap-2 py-4",
+        children: /*#__PURE__*/ jsx(CardContent, {
+            className: "flex-1 overflow-hidden p-0",
+            children: /*#__PURE__*/ jsx(DistributionChartWithAdapter, {
+                configuration: configuration,
+                dataModel: dataModel,
+                dataAdapter: dataAdapter
+            })
+        })
+    });
+}
+export { DistributionChartCard };

package/dist/registry/ai-chat/charts/kpi-chart-card.d.ts

@@ -0,0 +1,8 @@
+import type { DataAdapter, KpiChartConfiguration, KpiDataModel } from "../../charts-core/charts-core";
+interface KpiChartCardProps {
+    configuration: KpiChartConfiguration;
+    dataModel: KpiDataModel;
+    dataAdapter: DataAdapter;
+}
+export declare function KpiChartCard({ configuration, dataModel, dataAdapter, }: KpiChartCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/registry/ai-chat/charts/kpi-chart-card.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { Card, CardContent } from "../../card/card.js";
+import { KpiChartWithAdapter } from "../../kpi-chart/kpi-chart.js";
+function KpiChartCard({ configuration, dataModel, dataAdapter }) {
+    return /*#__PURE__*/ jsx(Card, {
+        className: "w-fit min-w-[180px] gap-0 p-0",
+        children: /*#__PURE__*/ jsx(CardContent, {
+            className: "p-0 [&>div>div>div]:!p-3",
+            children: /*#__PURE__*/ jsx(KpiChartWithAdapter, {
+                configuration: configuration,
+                dataModel: dataModel,
+                dataAdapter: dataAdapter
+            })
+        })
+    });
+}
+export { KpiChartCard };

package/dist/registry/ai-chat/charts/line-chart-card.d.ts

@@ -0,0 +1,8 @@
+import type { ChartDataModel, DataAdapter, DatetimeModelField, LineChartConfiguration } from "../../charts-core/charts-core";
+interface LineChartCardProps {
+    configuration: LineChartConfiguration;
+    dataModel: ChartDataModel<DatetimeModelField>;
+    dataAdapter: DataAdapter;
+}
+export declare function LineChartCard({ configuration, dataModel, dataAdapter, }: LineChartCardProps): import("react/jsx-runtime").JSX.Element;
+export {};