@adminforth/agent 1.43.29 → 1.44.1

package/dist/agentEvents.js

@@ -0,0 +1 @@
+export {};

package/dist/agentResponseEvents.d.ts

@@ -0,0 +1 @@
+export { createSseEventEmitter } from "./surfaces/web-sse/createSseEventEmitter.js";

package/dist/agentResponseEvents.js

@@ -1,144 +1 @@
-import { randomUUID } from "crypto";
-export function createAgentEventStream(res, options = {}) {
-    let isStreamClosed = false;
-    let activeBlock = null;
-    res.writeHead(200, Object.assign({ "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive" }, (options.vercelAiUiMessageStream
-        ? { "x-vercel-ai-ui-message-stream": "v1" }
-        : {})));
-    const stream = {
-        send(obj) {
-            if (isStreamClosed || res.writableEnded || res.destroyed) {
-                return;
-            }
-            res.write(`data: ${JSON.stringify(obj)}\n\n`);
-        },
-        endActiveBlock() {
-            if (!activeBlock) {
-                return;
-            }
-            stream.send({
-                type: `${activeBlock.type}-end`,
-                id: activeBlock.id,
-            });
-            activeBlock = null;
-        },
-        startBlock(type) {
-            if ((activeBlock === null || activeBlock === void 0 ? void 0 : activeBlock.type) === type) {
-                return activeBlock.id;
-            }
-            stream.endActiveBlock();
-            const id = randomUUID();
-            activeBlock = { type, id };
-            stream.send({
-                type: `${type}-start`,
-                id,
-            });
-            return id;
-        },
-        start(messageId) {
-            stream.send({
-                type: "start",
-                messageId,
-            });
-        },
-        textDelta(delta) {
-            const textId = stream.startBlock("text");
-            stream.send({
-                type: "text-delta",
-                id: textId,
-                delta,
-            });
-        },
-        reasoningDelta(delta) {
-            const reasoningId = stream.startBlock("reasoning");
-            stream.send({
-                type: "reasoning-delta",
-                id: reasoningId,
-                delta,
-            });
-        },
-        toolCall(event) {
-            if (options.closeActiveBlockOnToolStart && event.phase === "start") {
-                stream.endActiveBlock();
-            }
-            stream.send({
-                type: "data-tool-call",
-                data: event,
-            });
-        },
-        transcript(text, language) {
-            stream.send({
-                type: "transcript",
-                data: {
-                    text,
-                    language,
-                },
-            });
-        },
-        response(text, sessionId, turnId) {
-            stream.send({
-                type: "response",
-                data: {
-                    text,
-                    sessionId,
-                    turnId,
-                },
-            });
-        },
-        speechResponse(transcript, response, sessionId, turnId) {
-            stream.send({
-                type: "speech-response",
-                data: {
-                    transcript,
-                    response,
-                    sessionId,
-                    turnId,
-                },
-            });
-        },
-        audioStart(mimeType, format, sampleRate, channelCount, bitsPerSample) {
-            stream.send({
-                type: "audio-start",
-                data: {
-                    mimeType,
-                    format,
-                    sampleRate,
-                    channelCount,
-                    bitsPerSample,
-                },
-            });
-        },
-        audioDelta(value) {
-            stream.send({
-                type: "audio-delta",
-                data: {
-                    base64: Buffer.from(value).toString("base64"),
-                },
-            });
-        },
-        audioDone() {
-            stream.send({
-                type: "audio-done",
-            });
-        },
-        error(error) {
-            stream.send({
-                type: "error",
-                error,
-            });
-        },
-        end() {
-            if (isStreamClosed || res.writableEnded || res.destroyed) {
-                return;
-            }
-            stream.endActiveBlock();
-            stream.send({
-                type: "finish",
-            });
-            res.write("data: [DONE]\n\n");
-            isStreamClosed = true;
-            res.end();
-        },
-    };
-    return stream;
-}
+export { createSseEventEmitter } from "./surfaces/web-sse/createSseEventEmitter.js";

package/dist/apiBasedTools.d.ts

@@ -0,0 +1,29 @@
+import { type AdminUser, type IAdminForth } from 'adminforth';
+export type ApiBasedToolCallParams = {
+    adminUser?: AdminUser;
+    adminuser?: AdminUser;
+    abortSignal?: AbortSignal;
+    inputs?: Record<string, unknown>;
+    userTimeZone?: string;
+    acceptLanguage?: string;
+};
+export type ApiBasedTool = {
+    description?: string;
+    input_schema?: unknown;
+    output_schema?: unknown;
+    call: (params?: ApiBasedToolCallParams) => Promise<string>;
+};
+export declare function formatApiBasedToolCall(params: {
+    adminforth: IAdminForth;
+    adminUser?: AdminUser;
+    inputs?: Record<string, unknown>;
+    toolName: string;
+    userTimeZone?: string;
+}): Promise<string | undefined>;
+export declare function prepareApiBasedTools(adminforth: IAdminForth, hiddenResourceIds?: Iterable<string>): Record<string, ApiBasedTool>;
+export declare function serializeApiBasedTool(tool: ApiBasedTool | undefined): {
+    description: string | undefined;
+    input_schema: unknown;
+    output_schema: unknown;
+    call: string;
+} | null;

package/dist/custom/conversation_area/ProcessingTimeline.vue

@@ -39,6 +39,15 @@
           <template v-for="(part, index) in ToolOrReasoningParts" :key="index">
             <ReasoningRenderer v-if="part.type === 'reasoning'" :state="part.state" :text="part.text" />
             <ToolsGroup v-else-if="part.type==='data-tool-call'" :toolGroup="groupToolCallParts(message, part)" />
+            <li v-else-if="part.type === 'data-rendering'" class="mb-6 mx-2 mt-2 px-2 z-50 overflow-hidden">
+              <span class="bg-lightNavbar dark:bg-darkNavbar absolute flex items-center text-listTableHeadingText dark:text-darkListTableHeadingText justify-center w-5 h-5 rounded-full -start-[0.68rem] ring-4 ring-lightNavbar dark:ring-darkNavbar">
+                <div class="w-2 h-2 rounded-full bg-current animate-pulse"></div>
+              </span>
+              <h3 class="flex items-center mb-1 text-sm ml-3 gap-1 text-listTableHeadingText dark:text-darkListTableHeadingText">
+                <span class="font-semibold">{{ part.data?.label ?? 'Rendering...' }}</span>
+                <ThreeDotsAnimation />
+              </h3>
+            </li>
           </template>
         </ol>
       </CustomAutoScrollContainer>
@@ -73,7 +82,11 @@
   const isExpanded = ref(true);
   let isUserScrolled = false;
   const ToolOrReasoningParts = computed(() => {
-    return props.message.parts.filter((part: IPart) => part.type === 'data-tool-call' || part.type === 'reasoning');
+    return props.message.parts.filter((part: IPart) => {
+      return part.type === 'data-tool-call'
+        || part.type === 'reasoning'
+        || isActiveRenderingPart(part);
+    });
   });
   const isResponseInProgress = computed(() =>{
     return props.isLastMessageInChat && agentStore.isResponseInProgress; 
@@ -157,6 +170,14 @@
     });
   };
 
+  function isActiveRenderingPart(part: IPart) {
+    return part.type === 'data-rendering'
+      && part.data?.phase === 'start'
+      && !props.message.parts.some((candidate: IPart) => {
+        return candidate.type === 'data-rendering' && candidate.data?.phase === 'end';
+      });
+  }
+
   const groupToolCallParts = (message: IMessage, currentPart: IPart): IToolGroup[] => {
     if (currentPart.type !== 'data-tool-call') {
       return [];
@@ -259,4 +280,4 @@
   }
 }
 
-</style>
+</style>

package/dist/custom/incremark_code_renderers/IncremarkShikiCodeBlock.vue

@@ -72,7 +72,7 @@ let highlightModulePromise: Promise<typeof import('./incremarkCodeHighlight')> |
 const sourceCode = computed(() => props.node.value ?? '');
 const language = computed(() => props.node.lang?.trim().toLowerCase() || 'text');
 const languageLabel = computed(() => language.value === 'vega-lite' ? '' : props.node.lang?.trim() || 'text');
-const shouldRenderVega = computed(() => language.value === 'vega-lite' && props.blockStatus === 'completed');
+const shouldRenderVega = computed(() => language.value === 'vega-lite');
 const codeTheme = computed<IncremarkCodeTheme>(() => {
   const requestedTheme = props.theme ?? (prefersDarkMode.value ? props.darkTheme : props.lightTheme);
 
@@ -390,4 +390,4 @@ function clearVega() {
 :deep(.incremark-vega){
   padding: 0;
 }
-</style>
+</style>

package/dist/custom/types.ts

@@ -1,14 +1,15 @@
 export interface IPartData {
-  toolCallId: string;
-  toolName: string;
-  phase: 'start' | 'end';
+  toolCallId?: string;
+  toolName?: string;
+  phase?: 'start' | 'end';
+  label?: string;
   input?: any;
   output?: any;
   durationMs?: number;
   toolInfo?: string;
 }
 export interface IPart {
-  type: 'reasoning' | 'data-tool-call' | 'text';
+  type: 'reasoning' | 'data-tool-call' | 'data-rendering' | 'text';
   text?: string;
   state?: 'started' | 'thinking' | 'processing' | 'streaming' | 'done';
   data?: IPartData;

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+import type { AdminUser, AdminForthResource, IAdminForth, IHttpServer } from "adminforth";
+import { AdminForthPlugin } from "adminforth";
+import type { PluginOptions } from './types.js';
+import { createSequenceDebugCollector } from "./agent/middleware/sequenceDebug.js";
+import { type PreviousUserMessage } from "./agent/languageDetect.js";
+import type { AgentEventEmitter } from "./agentEvents.js";
+import type { CurrentPageContext } from "./agent/tools/getUserLocation.js";
+export type { AgentEvent, AgentEventEmitter } from "./agentEvents.js";
+type AgentTurnRunInput = {
+    prompt: string;
+    sessionId: string;
+    turnId: string;
+    previousUserMessages: PreviousUserMessage[];
+    modeName?: string | null;
+    userTimeZone: string;
+    currentPage?: CurrentPageContext;
+    abortSignal?: AbortSignal;
+    adminUser: AdminUser;
+    sequenceDebugCollector: ReturnType<typeof createSequenceDebugCollector>;
+    emit?: AgentEventEmitter;
+};
+type RunAndPersistAgentResponseInput = Omit<AgentTurnRunInput, "turnId" | "sequenceDebugCollector" | "previousUserMessages"> & {
+    failureLogMessage: string;
+    abortLogMessage: string;
+};
+type HandleTurnInput = Omit<RunAndPersistAgentResponseInput, "failureLogMessage" | "abortLogMessage"> & {
+    emit: AgentEventEmitter;
+    failureLogMessage?: string;
+    abortLogMessage?: string;
+};
+export default class AdminForthAgentPlugin extends AdminForthPlugin {
+    options: PluginOptions;
+    agentSystemPromptPromise: Promise<string>;
+    private checkpointer;
+    private parseBody;
+    private createNewTurn;
+    private getSessionTurns;
+    private getPreviousUserMessages;
+    private getChatSurfaceSessionId;
+    private getOrCreateChatSurfaceSession;
+    private getCheckpointer;
+    private getInternalAgentResourceIds;
+    constructor(options: PluginOptions);
+    modifyResourceConfig(adminforth: IAdminForth, resourceConfig: AdminForthResource): Promise<void>;
+    validateConfigAfterDiscover(adminforth: IAdminForth, resourceConfig: AdminForthResource): void;
+    instanceUniqueRepresentation(pluginOptions: any): string;
+    private runAgentTurn;
+    private runAndPersistAgentResponse;
+    handleTurn(input: HandleTurnInput): Promise<{
+        text: string;
+        turnId: any;
+        aborted: boolean;
+        failed: boolean;
+    }>;
+    private createChatSurfaceEventEmitter;
+    private handleChatSurfaceMessage;
+    setupEndpoints(server: IHttpServer): void;
+}