@firstlovecenter/ai-chat 0.2.3 → 0.6.0

package/dist/server/index.cjs

@@ -2,6 +2,9 @@
 
 var vertexSdk = require('@anthropic-ai/vertex-sdk');
 var crypto = require('crypto');
+var ai = require('ai');
+var googleVertex = require('@ai-sdk/google-vertex');
+var anthropic = require('@ai-sdk/google-vertex/anthropic');
 var googleAuthLibrary = require('google-auth-library');
 
 // src/server/tools/types.ts
@@ -72,8 +75,8 @@ async function runAgent(input) {
     const toolResults = [];
     for (const tc of response.toolCalls) {
       transcript.push({ kind: "tool_use", name: tc.name, input: tc.input });
-      const tool = input.tools[tc.name];
-      if (!tool) {
+      const tool2 = input.tools[tc.name];
+      if (!tool2) {
         const errResult = {
           ok: false,
           error: { code: "UNKNOWN_TOOL", message: `Unknown tool: ${tc.name}` }
@@ -87,7 +90,7 @@ async function runAgent(input) {
         });
         continue;
       }
-      const result = await tool.execute(tc.input, {
+      const result = await tool2.execute(tc.input, {
         ...input.ctx,
         toolCallCount
       });
@@ -649,7 +652,7 @@ async function* streamClaudeNarration(opts) {
   });
   const stream = await client.messages.stream({
     model: opts.modelId,
-    max_tokens: 400,
+    max_tokens: opts.maxTokens,
     system: NARRATIVE_SYSTEM,
     messages: [{ role: "user", content: buildNarrativeUserMessage(opts.input) }]
   });
@@ -709,7 +712,7 @@ async function* streamGeminiNarration(opts) {
           parts: [{ text: buildNarrativeUserMessage(opts.input) }]
         }
       ],
-      generationConfig: { maxOutputTokens: 400, temperature: 0 }
+      generationConfig: { maxOutputTokens: opts.maxTokens, temperature: 0 }
     })
   });
   if (!res.ok || !res.body) {
@@ -785,7 +788,7 @@ async function* streamGrokNarration(opts) {
     },
     body: JSON.stringify({
       model: opts.modelId,
-      max_tokens: 400,
+      max_tokens: opts.maxTokens,
       stream: true,
       messages: [
         { role: "system", content: NARRATIVE_SYSTEM3 },
@@ -1008,7 +1011,8 @@ data: ${JSON.stringify(data)}
               ctx: toolContext,
               tools: tools.tools,
               systemBlocks,
-              provider
+              provider,
+              maxOutputTokens: aiSettings.maxOutputTokens
             });
             if (!agentResult.ok) {
               persistedError = agentResult.error;
@@ -1034,6 +1038,7 @@ data: ${JSON.stringify(data)}
                     projectId: vertex.projectId,
                     location: aiSettings.gcpLocation,
                     modelId: narratorModelId,
+                    maxTokens: aiSettings.maxOutputTokens,
                     input: {
                       question,
                       structured,
@@ -1137,6 +1142,297 @@ data: {}
     }
   };
 }
+function buildVercelTools(tools, ctx, data, onPresent) {
+  const result = {};
+  let toolCallCount = 0;
+  for (const [name, def] of Object.entries(tools)) {
+    if (!def.zodSchema) {
+      throw new Error(
+        `Tool '${name}' has no zodSchema; required for the Vercel AI SDK chat. Add a Zod schema to the tool definition (or remove it from the registry if the host only uses the custom SSE chat).`
+      );
+    }
+    if (name === TERMINAL_TOOL_NAME) {
+      result[name] = ai.tool({
+        description: def.schema.description,
+        // The Zod schema doubles as the runtime parameter validator the SDK
+        // hands the model. We accept whatever Zod shape the host registered;
+        // the SDK uses it to validate the tool-call arguments before dispatch.
+        parameters: def.zodSchema,
+        execute: async (input) => {
+          if (toolCallCount < 2) {
+            return {
+              error: {
+                code: "SELF_VERIFY_REQUIRED",
+                message: "Per FR-8.3 you must run at least one CROSS-CHECK tool call (a different metric, a different period, or a run_sql sanity-check) before present. Make that extra call now, then call present again."
+              }
+            };
+          }
+          const payload = input;
+          for (let i = 0; i < payload.blocks.length; i++) {
+            data.append({
+              type: "block",
+              value: { index: i, ...payload.blocks[i] }
+            });
+          }
+          onPresent(payload);
+          return { ok: true };
+        }
+      });
+      continue;
+    }
+    result[name] = ai.tool({
+      description: def.schema.description,
+      parameters: def.zodSchema,
+      execute: async (input) => {
+        const res = await def.execute(input, { ...ctx, toolCallCount });
+        toolCallCount += 1;
+        if (res.ok) return res.data;
+        return { error: res.error };
+      }
+    });
+  }
+  return result;
+}
+
+// src/server/routes/agent-vercel.ts
+var VALID_MODELS = /* @__PURE__ */ new Set(["claude", "gemini"]);
+function jsonError2(status, code, message) {
+  return new Response(JSON.stringify({ error: { code, message } }), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function defaultGenerateSessionId2() {
+  return crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+}
+function createAgentVercelRoutes(ctx) {
+  const { persistence, auth, scope, tools, vertex, logger, hooks } = ctx;
+  return {
+    /** Next.js-compatible POST handler. */
+    POST: async (req) => {
+      if (hooks?.onRequest) {
+        const short = await hooks.onRequest(req);
+        if (short) return short;
+      }
+      const authResult = await auth.requireAuth(req);
+      if (!authResult.ok) return authResult.response;
+      const { scope: callerScope, userId } = authResult;
+      if (hooks?.onAuthenticated) {
+        const short = await hooks.onAuthenticated({
+          req,
+          scope: callerScope,
+          userId
+        });
+        if (short) return short;
+      }
+      const body = await req.json().catch(() => null);
+      const question = typeof body?.question === "string" ? body.question.trim() : "";
+      if (!question) {
+        return jsonError2(
+          400,
+          "VALIDATION_FAILED",
+          "question must be a non-empty string."
+        );
+      }
+      const rawChatSessionId = body?.chatSessionId;
+      const incomingChatSessionId = typeof rawChatSessionId === "number" && Number.isInteger(rawChatSessionId) ? rawChatSessionId : null;
+      const rawModel = body?.model;
+      const requestedModel = typeof rawModel === "string" && VALID_MODELS.has(rawModel) ? rawModel : null;
+      const aiSettings = await persistence.getAiSettings();
+      let chatSessionId;
+      if (incomingChatSessionId !== null) {
+        const owned = await persistence.getSession(
+          incomingChatSessionId,
+          userId
+        );
+        if (!owned) {
+          return jsonError2(404, "NOT_FOUND", "Chat session not found.");
+        }
+        chatSessionId = owned.id;
+      } else {
+        const created = await persistence.createSession({
+          userId,
+          title: question.slice(0, 200)
+        });
+        chatSessionId = created.id;
+      }
+      await persistence.appendMessage({
+        sessionId: chatSessionId,
+        role: "user",
+        question
+      });
+      const sessionId = hooks?.generateSessionId ? await hooks.generateSessionId({
+        scope: callerScope,
+        userId,
+        chatSessionId: incomingChatSessionId
+      }) : defaultGenerateSessionId2();
+      const scopeSummary = await scope.buildScopeSummary(callerScope);
+      const scopeLabel = await scope.resolveScopeLabel(callerScope);
+      const toolContext = {
+        scope: callerScope,
+        sessionId,
+        scopeSummary,
+        toolCallCount: 0
+      };
+      const systemBlocks = await tools.buildSystemBlocks(toolContext);
+      const provider = requestedModel ?? aiSettings.toolProvider;
+      if (!VALID_MODELS.has(provider)) {
+        return jsonError2(
+          400,
+          "INVALID_PROVIDER",
+          `Vercel chat only supports 'claude' or 'gemini'; got '${provider}'.`
+        );
+      }
+      const data = new ai.StreamData();
+      let presentPayload = null;
+      let persistedError = null;
+      let sessionStarted = false;
+      try {
+        if (hooks?.onSessionStart) {
+          await hooks.onSessionStart({
+            scope: callerScope,
+            sessionId,
+            userId
+          });
+        }
+        sessionStarted = true;
+        const vercelTools = buildVercelTools(
+          tools.tools,
+          toolContext,
+          data,
+          (p) => {
+            presentPayload = p;
+          }
+        );
+        data.append({
+          type: "meta",
+          value: { chatSessionId, scopeLabel }
+        });
+        const system = systemBlocks.map((b) => b.text).join("\n\n");
+        const model = provider === "claude" ? anthropic.createVertexAnthropic({
+          project: vertex.projectId,
+          location: vertex.defaultLocation,
+          googleAuthOptions: {}
+        })(vertex.modelIds.claude) : googleVertex.createVertex({
+          project: vertex.projectId,
+          location: aiSettings.gcpLocation,
+          googleAuthOptions: {}
+        })(vertex.modelIds.gemini);
+        const result = ai.streamText({
+          model,
+          system,
+          messages: [{ role: "user", content: question }],
+          tools: vercelTools,
+          maxSteps: 12,
+          maxTokens: aiSettings.maxOutputTokens,
+          onFinish: async ({ text }) => {
+            try {
+              let blocks = presentPayload?.blocks ?? [];
+              const prose = {};
+              const trimmed = (text ?? "").trim();
+              if (presentPayload === null && trimmed) {
+                const topic = question.length > 80 ? question.slice(0, 77) + "..." : question;
+                const synthetic = {
+                  kind: "paragraph_brief",
+                  topic,
+                  key_facts: [trimmed]
+                };
+                blocks = [synthetic];
+                prose[0] = trimmed;
+                data.append({
+                  type: "block",
+                  value: { index: 0, ...synthetic }
+                });
+              } else if (text) {
+                const firstPbIdx = blocks.findIndex(
+                  (b) => b.kind === "paragraph_brief"
+                );
+                if (firstPbIdx >= 0) prose[firstPbIdx] = text;
+              }
+              await persistence.appendMessage({
+                sessionId: chatSessionId,
+                role: "assistant",
+                blocks: blocks.length ? blocks : null,
+                prose: Object.keys(prose).length ? prose : null,
+                errorJson: persistedError
+              });
+            } catch (err2) {
+              logger?.warn?.(
+                {
+                  chatSessionId,
+                  sessionId,
+                  err: err2.message
+                },
+                "[agent-vercel] failed to persist assistant turn"
+              );
+            } finally {
+              try {
+                await data.close();
+              } catch {
+              }
+            }
+          }
+        });
+        return result.toDataStreamResponse({ data });
+      } catch (e) {
+        const message = e.message ?? "Internal error";
+        persistedError = { code: "INTERNAL", message };
+        logger?.error?.(
+          { chatSessionId, sessionId, err: message },
+          "[agent-vercel] route errored"
+        );
+        try {
+          data.append({
+            type: "error",
+            value: { code: "INTERNAL", message }
+          });
+        } catch {
+        }
+        try {
+          await data.close();
+        } catch {
+        }
+        try {
+          await persistence.appendMessage({
+            sessionId: chatSessionId,
+            role: "assistant",
+            blocks: null,
+            prose: null,
+            errorJson: persistedError
+          });
+        } catch (err2) {
+          logger?.warn?.(
+            { chatSessionId, sessionId, err: err2.message },
+            "[agent-vercel] failed to persist error turn"
+          );
+        }
+        return jsonError2(500, "INTERNAL", message);
+      } finally {
+        if (hooks?.onSessionEnd) {
+          const cause = req.signal.aborted ? "abort" : persistedError ? "error" : "complete";
+          try {
+            await hooks.onSessionEnd({
+              scope: callerScope,
+              sessionId,
+              userId,
+              cause
+            });
+          } catch (err2) {
+            logger?.warn?.(
+              {
+                chatSessionId,
+                sessionId,
+                sessionStarted,
+                err: err2.message
+              },
+              "[agent-vercel] onSessionEnd hook failed"
+            );
+          }
+        }
+      }
+    }
+  };
+}
 
 // src/server/routes/chat-sessions.ts
 var DEFAULT_TITLE = "New chat";
@@ -1317,6 +1613,8 @@ function createChatSessionsRoutes(ctx) {
 
 // src/server/routes/admin-settings.ts
 var VALID_LOCATIONS = ["us-east5", "global"];
+var MIN_MAX_OUTPUT_TOKENS = 256;
+var MAX_MAX_OUTPUT_TOKENS = 64e3;
 function isStringRecord(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -1331,6 +1629,8 @@ function toWire(settings) {
     tool_provider: settings.toolProvider,
     gcp_location: settings.gcpLocation,
     chat_interface: settings.chatInterface,
+    max_output_tokens: settings.maxOutputTokens,
+    role_prompt: settings.rolePrompt,
     updated_at: settings.updatedAt ? settings.updatedAt.toISOString() : null,
     updated_by_user_id: settings.updatedByUserId
   };
@@ -1410,11 +1710,29 @@ function createAdminSettingsRoutes(ctx) {
       }
       patch.chatInterface = v;
     }
-    if (patch.toolProvider === void 0 && patch.gcpLocation === void 0 && patch.chatInterface === void 0) {
+    if ("max_output_tokens" in body) {
+      const v = body.max_output_tokens;
+      if (typeof v !== "number" || !Number.isInteger(v) || v < MIN_MAX_OUTPUT_TOKENS || v > MAX_MAX_OUTPUT_TOKENS) {
+        return jsonResponse({ error: "invalid_max_output_tokens" }, 400);
+      }
+      patch.maxOutputTokens = v;
+    }
+    if ("role_prompt" in body) {
+      const v = body.role_prompt;
+      if (v === null) {
+        patch.rolePrompt = null;
+      } else if (typeof v === "string") {
+        const trimmed = v.trim();
+        patch.rolePrompt = trimmed === "" ? null : trimmed;
+      } else {
+        return jsonResponse({ error: "invalid_role_prompt" }, 400);
+      }
+    }
+    if (patch.toolProvider === void 0 && patch.gcpLocation === void 0 && patch.chatInterface === void 0 && patch.maxOutputTokens === void 0 && !("rolePrompt" in patch)) {
       return jsonResponse(
         {
           error: "empty_patch",
-          message: "Body must set at least one of tool_provider, gcp_location, chat_interface."
+          message: "Body must set at least one of tool_provider, gcp_location, chat_interface, max_output_tokens, role_prompt."
         },
         400
       );
@@ -1439,16 +1757,27 @@ function configureAiChat(opts) {
   ];
   const getProvider = (id) => toolProviders2.find((p) => p.id === id) ?? getToolProvider(id);
   const chatInterfaces = opts.chatInterfaces ?? BUILTIN_CHAT_INTERFACE_IDS.map((id) => ({ id }));
-  const tools = opts.rolePrompt ? {
+  const staticRolePrompt = opts.rolePrompt;
+  const tools = {
     tools: opts.tools.tools,
     async buildSystemBlocks(ctx) {
       const inner = await opts.tools.buildSystemBlocks(ctx);
-      const rolePrompt = opts.rolePrompt;
-      const role = typeof rolePrompt === "function" ? await rolePrompt(ctx) : rolePrompt;
-      if (!role || !role.trim()) return inner;
+      let role = null;
+      try {
+        const settings = await opts.persistence.getAiSettings();
+        if (settings.rolePrompt && settings.rolePrompt.trim()) {
+          role = settings.rolePrompt;
+        }
+      } catch {
+      }
+      if (!role && staticRolePrompt) {
+        const resolved = typeof staticRolePrompt === "function" ? await staticRolePrompt(ctx) : staticRolePrompt;
+        if (resolved && resolved.trim()) role = resolved;
+      }
+      if (!role) return inner;
       return [{ text: role, cached: true }, ...inner];
     }
-  } : opts.tools;
+  };
   const runAgentBound = async ({
     question,
     ctx,
@@ -1497,6 +1826,15 @@ function configureAiChat(opts) {
     resolveNarratorId: opts.resolveNarratorId,
     hooks: opts.hooks
   });
+  const agentVercel = createAgentVercelRoutes({
+    persistence: opts.persistence,
+    auth: opts.auth,
+    scope: opts.scope,
+    tools,
+    vertex: opts.vertex,
+    logger: opts.logger,
+    hooks: opts.hooks
+  });
   const chatSessions = createChatSessionsRoutes({
     persistence: opts.persistence,
     auth: opts.auth,
@@ -1513,7 +1851,7 @@ function configureAiChat(opts) {
   });
   return {
     runAgent: runAgentBound,
-    routes: { agentCustom, chatSessions, adminSettings },
+    routes: { agentCustom, agentVercel, chatSessions, adminSettings },
     registries: { toolProviders: toolProviders2, chatInterfaces }
   };
 }