@adminforth/agent 1.43.28 → 1.44.0

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/apiBasedTools.js

@@ -341,7 +341,7 @@ function validationErrorResponse(error, details) {
 }
 function callOpenApiSchema(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { adminforth, adminUser, abortSignal, inputs, schema, toolName, userTimeZone } = params;
+        const { adminforth, adminUser, abortSignal, inputs, schema, toolName, userTimeZone, acceptLanguage } = params;
         const method = schema.method.toUpperCase();
         const normalizedInputs = normalizeDateTimeInputsToUtc((inputs !== null && inputs !== void 0 ? inputs : {}), adminforth, userTimeZone);
         const hasRequestBody = !METHODS_WITHOUT_REQUEST_BODY.has(method);
@@ -353,7 +353,8 @@ function callOpenApiSchema(params) {
         }
         const response = createDirectToolResponse();
         logger.info(`Calling OpenAPI tool "${toolName}" with direct handler`);
-        const tr = (msg, category, trParams, pluralizationNumber) => adminforth.tr(msg, category, undefined, trParams, pluralizationNumber);
+        const lang = acceptLanguage !== null && acceptLanguage !== void 0 ? acceptLanguage : "en";
+        const tr = (msg, category, trParams, pluralizationNumber) => adminforth.tr(msg, category, lang, trParams, pluralizationNumber);
         const output = yield schema.handler({
             body,
             query,
@@ -410,7 +411,7 @@ export function prepareApiBasedTools(adminforth, hiddenResourceIds = []) {
             description: schema.description,
             input_schema: schema.request_schema,
             output_schema: schema.response_schema,
-            call: (...args_1) => __awaiter(this, [...args_1], void 0, function* ({ adminUser, adminuser, abortSignal, inputs, userTimeZone } = {}) {
+            call: (...args_1) => __awaiter(this, [...args_1], void 0, function* ({ adminUser, adminuser, abortSignal, inputs, userTimeZone, acceptLanguage } = {}) {
                 if (isHiddenResourceCall(hiddenResourceIdSet, inputs)) {
                     return YAML.stringify({
                         error: 'RESOURCE_NOT_AVAILABLE',
@@ -425,6 +426,7 @@ export function prepareApiBasedTools(adminforth, hiddenResourceIds = []) {
                     toolName,
                     inputs,
                     userTimeZone,
+                    acceptLanguage,
                 });
                 const processedOutput = yield applyToolOverride({
                     adminforth,

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;
+}