@123toto/ai-app-assistant-server 0.2.3 → 0.2.4

package/dist/index.cjs

@@ -573,7 +573,6 @@ async function writeResponse(response, webResponse) {
 
 // src/ai-sdk.ts
 var import_ai = require("ai");
-var import_zod2 = require("zod");
 var import_anthropic = require("@ai-sdk/anthropic");
 var import_google = require("@ai-sdk/google");
 var import_mistral = require("@ai-sdk/mistral");
@@ -701,20 +700,14 @@ async function testAiSdkConnection(options) {
   const displayModel = typeof options.model === "string" ? options.model.trim() : `ai-sdk:${options.model.provider}:${options.model.modelId}`;
   try {
     const resolved = resolveModel(options);
-    const result = await (0, import_ai.generateText)({
+    await (0, import_ai.generateText)({
       model: resolved.model,
       maxRetries: 0,
-      maxOutputTokens: 32,
-      timeout: clampInteger2(options.timeoutMs ?? 15e3, 1e3, 3e4),
-      system: "Return the requested connectivity result as structured data.",
-      prompt: "Return status ok.",
-      output: import_ai.Output.object({
-        schema: import_zod2.z.object({ status: import_zod2.z.literal("ok") })
-      })
+      maxOutputTokens: 8,
+      timeout: clampInteger2(options.timeoutMs ?? 15e3, 1e3, 12e4),
+      system: "This is a connectivity check. Reply briefly.",
+      prompt: "Reply with OK."
     });
-    if (result.output.status !== "ok") {
-      throw new Error("The model returned an invalid connectivity result");
-    }
     return {
       success: true,
       model: displayModel,
@@ -1130,52 +1123,52 @@ var import_node_crypto3 = require("crypto");
 
 // src/configuration.ts
 var import_node_crypto = require("crypto");
-var import_zod3 = require("zod");
+var import_zod2 = require("zod");
 var AiAppAssistantConfigurationConflictError = class extends Error {
   constructor() {
     super("AI App Assistant configuration changed concurrently; retry the operation");
     this.name = "AiAppAssistantConfigurationConflictError";
   }
 };
-var accessRuleSchema = import_zod3.z.discriminatedUnion("mode", [
-  import_zod3.z.object({ mode: import_zod3.z.literal("all") }),
-  import_zod3.z.object({ mode: import_zod3.z.literal("roles"), roles: import_zod3.z.array(import_zod3.z.string().min(1)).min(1) }),
-  import_zod3.z.object({ mode: import_zod3.z.literal("users"), userIds: import_zod3.z.array(import_zod3.z.string().min(1)).min(1) })
+var accessRuleSchema = import_zod2.z.discriminatedUnion("mode", [
+  import_zod2.z.object({ mode: import_zod2.z.literal("all") }),
+  import_zod2.z.object({ mode: import_zod2.z.literal("roles"), roles: import_zod2.z.array(import_zod2.z.string().min(1)).min(1) }),
+  import_zod2.z.object({ mode: import_zod2.z.literal("users"), userIds: import_zod2.z.array(import_zod2.z.string().min(1)).min(1) })
 ]);
-var actorSchema = import_zod3.z.object({
-  id: import_zod3.z.string().min(1),
-  label: import_zod3.z.string().min(1)
+var actorSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1),
+  label: import_zod2.z.string().min(1)
 });
-var administrationSchema = import_zod3.z.object({
+var administrationSchema = import_zod2.z.object({
   keyCreatedBy: actorSchema.optional(),
-  keyCreatedAt: import_zod3.z.string().datetime().optional(),
+  keyCreatedAt: import_zod2.z.string().datetime().optional(),
   modelUpdatedBy: actorSchema.optional(),
-  modelUpdatedAt: import_zod3.z.string().datetime().optional(),
-  allowModelChangesByOthers: import_zod3.z.boolean(),
-  history: import_zod3.z.array(import_zod3.z.object({
-    id: import_zod3.z.string().min(1),
+  modelUpdatedAt: import_zod2.z.string().datetime().optional(),
+  allowModelChangesByOthers: import_zod2.z.boolean(),
+  history: import_zod2.z.array(import_zod2.z.object({
+    id: import_zod2.z.string().min(1),
     actor: actorSchema,
-    changedAt: import_zod3.z.string().datetime(),
-    changes: import_zod3.z.array(import_zod3.z.object({
-      field: import_zod3.z.enum(["provider", "apiKey", "model", "access", "quota", "conversation", "modelChangePolicy"]),
-      from: import_zod3.z.string().optional(),
-      to: import_zod3.z.string().optional()
+    changedAt: import_zod2.z.string().datetime(),
+    changes: import_zod2.z.array(import_zod2.z.object({
+      field: import_zod2.z.enum(["provider", "apiKey", "model", "access", "quota", "conversation", "modelChangePolicy"]),
+      from: import_zod2.z.string().optional(),
+      to: import_zod2.z.string().optional()
     })).min(1)
   })).max(200)
 });
-var persistedConfigurationSchema = import_zod3.z.object({
-  version: import_zod3.z.literal(1),
-  provider: import_zod3.z.enum(["anthropic", "google", "mistral", "ollama", "openai"]),
-  model: import_zod3.z.string().min(1),
-  connectionSource: import_zod3.z.enum(["environment", "override"]).optional(),
-  protectedApiKey: import_zod3.z.string().min(1).optional(),
-  baseURL: import_zod3.z.string().url().optional(),
+var persistedConfigurationSchema = import_zod2.z.object({
+  version: import_zod2.z.literal(1),
+  provider: import_zod2.z.enum(["anthropic", "google", "mistral", "ollama", "openai"]),
+  model: import_zod2.z.string().min(1),
+  connectionSource: import_zod2.z.enum(["environment", "override"]).optional(),
+  protectedApiKey: import_zod2.z.string().min(1).optional(),
+  baseURL: import_zod2.z.string().url().optional(),
   access: accessRuleSchema,
-  quota: import_zod3.z.object({
-    maxRequests: import_zod3.z.number().int().positive(),
-    windowSeconds: import_zod3.z.number().int().positive()
+  quota: import_zod2.z.object({
+    maxRequests: import_zod2.z.number().int().positive(),
+    windowSeconds: import_zod2.z.number().int().positive()
   }).optional(),
-  maxConversationTurns: import_zod3.z.number().int().min(1).max(10).optional(),
+  maxConversationTurns: import_zod2.z.number().int().min(1).max(10).optional(),
   administration: administrationSchema.optional()
 });
 function createAiAppAssistantConfigurationRepository(options) {
@@ -1335,7 +1328,7 @@ function createRedisAiAppAssistantStore(client, options) {
 }
 function normalizeConfiguration(configuration) {
   const parsed = persistedConfigurationSchema.omit({ version: true, protectedApiKey: true }).extend({
-    apiKey: import_zod3.z.string().min(1).optional()
+    apiKey: import_zod2.z.string().min(1).optional()
   }).parse({
     ...configuration,
     model: configuration.model.trim(),
@@ -1686,7 +1679,7 @@ var AiAppAssistantConfigurationManager = class {
       model: `${input.provider}:${input.model}`,
       ...apiKey ? { apiKey } : {},
       ...input.baseURL ? { baseURL: input.baseURL } : {},
-      timeoutMs: Math.min(this.#options.connectionTimeoutMs ?? 15e3, 3e4)
+      timeoutMs: this.#options.connectionTimeoutMs ?? 15e3
     });
     if (connection.success) {
       this.#recentConnectionValidation = {
@@ -1731,14 +1724,18 @@ var AiAppAssistantConfigurationManager = class {
       model: `${configuration.provider}:${configuration.model}`,
       ...configuration.apiKey ? { apiKey: configuration.apiKey } : {},
       ...configuration.baseURL ? { baseURL: configuration.baseURL } : {},
-      timeoutMs: Math.min(this.#options.connectionTimeoutMs ?? 15e3, 3e4)
+      timeoutMs: this.#options.connectionTimeoutMs ?? 15e3
     }));
     this.#runtimeConnection = {
       status: result.success ? "connected" : "disconnected",
       checkedAt: this.now(),
       model: result.model
     };
-    if (!result.success) this.#options.logger?.warn(`AI assistant connection failed: ${result.error.code}`);
+    if (!result.success) {
+      this.#options.logger?.warn(
+        `AI assistant connection failed: ${result.error.code}: ${result.error.message}`
+      );
+    }
     return result.success;
   }
   /** Validates sensitive connection changes, persists safely and records their author. */
@@ -2021,23 +2018,22 @@ var AiAppAssistantConfigurationManager = class {
   async ensureRuntimeConnection() {
     if (!this.isEnabled()) return false;
     if (this.#runtimeConnection.status === "connected") return true;
+    if (this.#reconnectPromise) return this.#reconnectPromise;
     const intervalMs = Math.max(1e3, this.#options.reconnectIntervalMs ?? 3e4);
     if (Date.now() - this.#lastReconnectAttempt < intervalMs) return false;
-    if (!this.#reconnectPromise) {
-      this.#reconnectPromise = this.validateRuntimeConnection().then(async (connected) => {
-        if (connected) {
-          await this.publishAndEmit({
-            reason: "connection-tested",
-            reloadRequired: true,
-            connectionValidated: true,
-            remote: false
-          });
-        }
-        return connected;
-      }).finally(() => {
-        this.#reconnectPromise = void 0;
-      });
-    }
+    this.#reconnectPromise = this.validateRuntimeConnection().then(async (connected) => {
+      if (connected) {
+        await this.publishAndEmit({
+          reason: "connection-tested",
+          reloadRequired: true,
+          connectionValidated: true,
+          remote: false
+        });
+      }
+      return connected;
+    }).finally(() => {
+      this.#reconnectPromise = void 0;
+    });
     return this.#reconnectPromise;
   }
   async applyTestResultToActiveConfiguration(input, result, apiKey) {
@@ -2473,13 +2469,15 @@ function createManagedAiAppAssistantRuntime(options) {
   return {
     configuration: options.configuration,
     ...options.telemetryStore ? { telemetry: options.telemetryStore } : {},
-    /** Starts cross-instance synchronization and validates the active provider once. */
+    /**
+     * Starts synchronization immediately, then validates the optional provider
+     * in the background so an unavailable LLM never delays the host bootstrap.
+     */
     async initialize() {
       if (initialized) return;
       initialized = true;
       await options.configuration.startSynchronization();
-      const connected = await options.configuration.validateRuntimeConnection();
-      await rebuild({ connectionValidated: connected });
+      void options.configuration.ensureRuntimeConnection().catch(() => void 0);
     },
     dispose() {
       initialized = false;
@@ -2586,7 +2584,7 @@ function unavailable() {
 
 // src/managed-http.ts
 var import_ai_app_assistant_contracts4 = require("@123toto/ai-app-assistant-contracts");
-var import_zod4 = require("zod");
+var import_zod3 = require("zod");
 function createManagedAiAppAssistantFetchHandlers(options) {
   const identity = async (request, nativeContext) => {
     if (options.resolveIdentity) return options.resolveIdentity(request, nativeContext);
@@ -2727,7 +2725,7 @@ function mapError2(error) {
   if (error instanceof AiAppAssistantManagementError) {
     return json({ error: error.code, message: error.message, ...error.details }, error.status);
   }
-  if (error instanceof import_zod4.ZodError || error instanceof SyntaxError) {
+  if (error instanceof import_zod3.ZodError || error instanceof SyntaxError) {
     return json({ error: "invalid_request", message: "The assistant request is invalid." }, 400);
   }
   return json({ error: "assistant_error", message: "The assistant response could not be generated." }, 500);