pgkiln 0.79.0 → 0.81.0

package/public/app.js

@@ -4041,6 +4041,89 @@ function areaFilter(map, f) {
       btn.addEventListener('click', (x) => x.preventDefault());
     }
   });
+  // (sprint 148, WS-4) the answer as the model writes it: the message is posted with fetch asking for server-sent
+  // events; "text" pieces are added as text (never as HTML), "tool" names the tool being used, and "done" loads the
+  // page, which shows the saved answer formatted, its links and actions, or the error. Without fetch streams (or when
+  // the server answers with a page, e.g. a refusal) the form is sent the ordinary way.
+  const streams = typeof ReadableStream !== 'undefined' && typeof TextDecoder !== 'undefined' && typeof fetch === 'function';
+  const go = (url) => {
+    const u = new URL(url, location.href);
+    if (u.pathname === location.pathname && u.search === location.search) {
+      history.replaceState(history.state, '', u);
+      location.reload();
+    } else location.assign(u);
+  };
+  async function streamAnswer(f) {
+    const box = document.querySelector(`textarea[form="${CSS.escape(f.id)}"]`);
+    const wrap = box?.closest('.assistant');
+    const log = wrap?.querySelector('.assistant-log');
+    const entry = (role, label) => {
+      const li = document.createElement('li');
+      li.className = `assistant-msg assistant-msg-${role}`;
+      const who = document.createElement('span');
+      who.className = 'assistant-who';
+      who.textContent = label || '';
+      const text = document.createElement('div');
+      text.className = 'assistant-text';
+      li.append(who, text);
+      log.append(li);
+      return { li, text };
+    };
+    const mine = entry('user', wrap.dataset.you);
+    const said = document.createElement('p');
+    said.textContent = box.value;
+    mine.text.append(said);
+    const answer = entry('assistant', wrap.dataset.who);
+    answer.text.setAttribute('aria-busy', 'true');
+    const para = document.createElement('p');
+    para.className = 'assistant-streaming';
+    answer.text.append(para);
+    const status = document.createElement('small');
+    status.className = 'assistant-tools muted';
+    answer.li.append(status);
+    answer.li.scrollIntoView({ block: 'nearest' });
+    let res;
+    try {
+      res = await fetch(f.action, { method: 'POST', body: new URLSearchParams(new FormData(f)), headers: { accept: 'text/event-stream' }, credentials: 'same-origin' });
+    } catch {
+      return HTMLFormElement.prototype.submit.call(f);
+    }
+    if (!res.ok || !(res.headers.get('content-type') || '').startsWith('text/event-stream') || !res.body) return HTMLFormElement.prototype.submit.call(f);
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = '';
+    try {
+      for (;;) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        let cut;
+        while ((cut = buf.indexOf('\n\n')) >= 0) {
+          const block = buf.slice(0, cut);
+          buf = buf.slice(cut + 2);
+          const event = /^event: (.*)$/m.exec(block)?.[1];
+          const line = /^data: (.*)$/m.exec(block)?.[1];
+          if (!event || line === undefined) continue;
+          const data = JSON.parse(line);
+          if (event === 'text' && typeof data === 'string') {
+            para.textContent += data;
+            answer.li.scrollIntoView({ block: 'nearest' });
+          } else if (event === 'tool' && typeof data === 'string') status.textContent = (wrap.dataset.used || '{tools}').replace('{tools}', data);
+          else if (event === 'done' && data && typeof data.url === 'string') return go(data.url);
+        }
+      }
+    } catch {
+      // the connection broke: the server still saves the answer; the page shows it
+    }
+    location.reload();
+  }
+  document.addEventListener('submit', (e) => {
+    const f = e.target;
+    if (e.defaultPrevented || !streams || !f.matches || !f.matches('form.assistant-form') || !f.id) return;
+    if (!document.querySelector(`textarea[form="${CSS.escape(f.id)}"]`)?.closest('.assistant')?.querySelector('.assistant-log')) return;
+    e.preventDefault();
+    streamAnswer(f);
+  });
   // Ctrl+Enter (or ⌘+Enter) sends the message
   document.addEventListener('keydown', (e) => {
     const box = e.target;

package/src/ai/chat.ts

@@ -52,6 +52,12 @@ export interface ChatRequest {
   effort?: 'low' | 'medium' | 'high' | null;
   /** (121) an agent's output limit per call (never above the service's maximum) */
   maxTokens?: number | null;
+  /**
+   * (sprint 148, WS-4) streamed answers: the text as the model writes it, in pieces (also the text of a round that
+   * then calls tools), and each tool before it runs. Without them a call waits for the whole answer, as before.
+   */
+  onText?: (delta: string) => void;
+  onTool?: (name: string) => void;
 }
 
 export interface ChatResult {
@@ -122,7 +128,7 @@ async function claudeChat(s: AiService, limits: Parameters<typeof metered>[1], r
     const msg = await metered(s, limits, info, async () => {
       let m: Anthropic.Beta.BetaMessage;
       try {
-        m = await client.beta.messages.stream({
+        const stream = client.beta.messages.stream({
           model: s.model,
           max_tokens: outputLimit(s, req),
           system: req.system,
@@ -130,7 +136,9 @@ async function claudeChat(s: AiService, limits: Parameters<typeof metered>[1], r
           ...(tools.length ? { tools } : {}),
           ...((req.effort ?? s.effort) ? { output_config: { effort: (req.effort ?? s.effort)! } } : {}),
           ...(s.refusal_fallback ? { betas: ['server-side-fallback-2026-07-01'], fallbacks: 'default' as const } : {}),
-        }).finalMessage();
+        });
+        if (req.onText) stream.on('text', (delta) => req.onText!(delta));
+        m = await stream.finalMessage();
       } catch (e) {
         throw claudeError(e);
       }
@@ -150,6 +158,7 @@ async function claudeChat(s: AiService, limits: Parameters<typeof metered>[1], r
     if (round >= req.maxRounds) throw new AiError('output', TOO_MANY_ROUNDS);
     const results: Anthropic.Beta.BetaToolResultBlockParam[] = [];
     for (const call of calls) {
+      req.onTool?.(call.name);
       const out = await req.runTool(call.name, (call.input ?? {}) as Record<string, unknown>);
       used.push({ name: call.name, ok: !out.isError });
       results.push({ type: 'tool_result', tool_use_id: call.id, content: clip(out.content), ...(out.isError ? { is_error: true } : {}) });
@@ -169,15 +178,32 @@ async function openAiChat(s: AiService, limits: Parameters<typeof metered>[1], r
     const res = await metered(s, limits, info, async () => {
       let r: OpenAI.Chat.ChatCompletion;
       try {
-        r = await client.chat.completions.create({
+        const params = {
           model: s.model,
           // the system prompt is sent with each request, not kept in the history
-          messages: [{ role: 'system', content: req.system }, ...messages],
+          messages: [{ role: 'system' as const, content: req.system }, ...messages],
           max_completion_tokens: outputLimit(s, req),
           ...(tools.length ? { tools } : {}),
           // (121) an agent's reasoning effort; models without reasoning refuse it, so none is sent without one
           ...(req.effort ? { reasoning_effort: req.effort } : {}),
-        });
+        };
+        if (req.onText) {
+          // (sprint 148) streamed: the content as it comes; the usage in the last chunk
+          // an OpenAI-compatible endpoint that refuses streaming (400) gets the plain request once
+          let streamed: OpenAI.Chat.ChatCompletion | null = null;
+          let sent = false;
+          try {
+            const stream = client.chat.completions.stream({ ...params, stream_options: { include_usage: true } });
+            stream.on('content', (delta) => {
+              sent = true;
+              req.onText!(delta);
+            });
+            streamed = await stream.finalChatCompletion();
+          } catch (e) {
+            if (sent || (e as { status?: number }).status !== 400) throw e;
+          }
+          r = streamed ?? (await client.chat.completions.create(params));
+        } else r = await client.chat.completions.create(params);
       } catch (e) {
         throw openAiError(e);
       }
@@ -198,6 +224,7 @@ async function openAiChat(s: AiService, limits: Parameters<typeof metered>[1], r
     for (const call of calls) {
       let input: Record<string, unknown>;
       let out: ToolOutcome;
+      req.onTool?.(call.function.name);
       try {
         input = JSON.parse(call.function.arguments || '{}');
         out = input && typeof input === 'object' && !Array.isArray(input) ? await req.runTool(call.function.name, input) : { content: 'The arguments are not a JSON object.', isError: true };

package/src/ai/embeddings.ts

@@ -18,8 +18,13 @@ import { AiError } from './types.ts';
 // The dimensions are part of the definition: every embedding is checked against them, and the builder checks
 // them against the vector column (vector(n)) a search configuration or a vector column helper uses.
 
-export type VectorProviderType = 'ai_service' | 'function';
-export const VECTOR_PROVIDER_TYPES: VectorProviderType[] = ['ai_service', 'function'];
+export type VectorProviderType = 'ai_service' | 'function' | 'database_model';
+export const VECTOR_PROVIDER_TYPES: VectorProviderType[] = ['ai_service', 'function', 'database_model'];
+/** (sprint 151, migration 146) the extensions that run a model in the database: pgml = PostgresML's pgml.embed(model, text) */
+export const MODEL_ENGINES = ['pgml'] as const;
+export type ModelEngine = (typeof MODEL_ENGINES)[number];
+/** A provider that embeds in the database (meta.embed, as the caller): a function, or a model in the database. */
+export const embedsInDatabase = (p: { type?: unknown }) => p.type === 'function' || p.type === 'database_model';
 
 export interface VectorProvider {
   name: string;
@@ -32,6 +37,8 @@ export interface VectorProvider {
   dimensions: number;
   /** function: schema.name */
   function?: string;
+  /** (151) database_model: the extension that runs the model (model: its name, e.g. intfloat/e5-small-v2) */
+  engine?: ModelEngine;
   /** ai_service: texts per request (background embedding; default 64) */
   batch_size?: number;
   /** ai_service: requests per minute (background embedding; default 60) */
@@ -59,7 +66,7 @@ export function vectorProviderProblems(p: unknown): string[] {
   const what = `Vector provider ${typeof p.name === 'string' ? p.name : '?'}`;
   const out: string[] = [];
   if (typeof p.name !== 'string' || !PROVIDER_NAME.test(p.name)) out.push(`${what}: the name (static ID) is upper case letters, digits and _ (e.g. DOC_EMBEDDINGS).`);
-  if (!VECTOR_PROVIDER_TYPES.includes(p.type)) out.push(`${what}: the type is ai_service or function.`);
+  if (!VECTOR_PROVIDER_TYPES.includes(p.type)) out.push(`${what}: the type is ai_service, function or database_model.`);
   if (p.description !== undefined && p.description !== null && (typeof p.description !== 'string' || p.description.length > 500)) out.push(`${what}: the description is text (at most 500 characters).`);
   if (!intIn(p.dimensions, 1, MAX_DIMENSIONS)) out.push(`${what}: the dimensions are a whole number from 1 to ${MAX_DIMENSIONS}.`);
   if (p.type === 'ai_service') {
@@ -67,6 +74,12 @@ export function vectorProviderProblems(p: unknown): string[] {
     if (typeof p.model !== 'string' || !MODEL.test(p.model)) out.push(`${what}: the embedding model is its name, e.g. text-embedding-3-small or nomic-embed-text.`);
     if (p.function !== undefined) out.push(`${what}: an AI service provider has no function.`);
   }
+  if (p.type === 'database_model') {
+    if (!MODEL_ENGINES.includes(p.engine)) out.push(`${what}: the engine is ${MODEL_ENGINES.join(' or ')} (the extension that runs the model in the database).`);
+    if (typeof p.model !== 'string' || !MODEL.test(p.model)) out.push(`${what}: the model is its name, e.g. intfloat/e5-small-v2.`);
+    if (p.service !== undefined || p.function !== undefined) out.push(`${what}: a database model provider has no AI service or function.`);
+  }
+  if (p.type !== 'database_model' && p.engine !== undefined) out.push(`${what}: only a database model provider has an engine.`);
   if (p.type === 'function') {
     if (typeof p.function !== 'string' || !FUNCTION_NAME.test(p.function)) out.push(`${what}: the function is schema.name, e.g. sales.embed.`);
     if (p.service !== undefined || p.model !== undefined) out.push(`${what}: a function provider has no AI service or model.`);
@@ -126,11 +139,11 @@ export interface EmbedInfo extends Pick<CallInfo, 'appId' | 'pageNo' | 'user' |
 export async function embedTexts(p: VectorProvider, texts: string[], info: EmbedInfo, client?: Queryable): Promise<number[][]> {
   if (!texts.length) return [];
   const input = texts.map((t) => String(t ?? '').slice(0, MAX_TEXT_CHARS));
-  if (p.type === 'function') {
-    if (!client) throw new AiError('config', `Vector provider ${p.name}: a function provider needs a database connection.`);
+  if (embedsInDatabase(p)) {
+    if (!client) throw new AiError('config', `Vector provider ${p.name}: a ${p.type === 'function' ? 'function' : 'database model'} provider needs a database connection.`);
     const rows = (await client.query('select meta.embed(t, $2, $3) as v from unnest($1::text[]) with ordinality u(t, n) order by n', [input, p.name, info.appId])).rows;
     return rows.map((r: { v: number[] | null }) => {
-      if (!Array.isArray(r.v)) throw new AiError('output', `Vector provider ${p.name}: the function returned no embedding.`);
+      if (!Array.isArray(r.v)) throw new AiError('output', `Vector provider ${p.name}: the ${p.type === 'function' ? 'function' : 'model'} returned no embedding.`);
       return r.v.map(Number);
     });
   }
@@ -183,7 +196,7 @@ const RECENT_MS = 10 * 60_000;
 
 /** The embedding of one search text (AI service providers: kept a few minutes in this process's memory). */
 export async function embedQuery(p: VectorProvider, text: string, info: EmbedInfo, client?: Queryable): Promise<number[]> {
-  if (p.type === 'function') return (await embedTexts(p, [text], info, client))[0];
+  if (embedsInDatabase(p)) return (await embedTexts(p, [text], info, client))[0];
   const key = JSON.stringify([info.appId, p.name, p.service, p.model, p.dimensions, text]);
   const hit = recent.get(key);
   if (hit && Date.now() - hit.at < RECENT_MS) return hit.v;

package/src/app.ts

@@ -99,6 +99,7 @@ import { mailQueueRoutes } from './builder/mail-queue.ts';
 import { networkAccessRoutes } from './builder/network-access.ts';
 import { workspaceMailRoutes } from './builder/workspace-mail.ts';
 import { workspaceResourceRoutes } from './builder/workspace-resources.ts';
+import { remoteDatabaseRoutes } from './builder/remote-databases.ts';
 import { runtimeScope } from './db.ts';
 // (sprint 139, AP-6) OpenTelemetry: a trace per request, /metrics, the browser relay
 import { startTelemetry } from './telemetry/export.ts';
@@ -288,6 +289,7 @@ export async function buildApp(opts: { logger?: boolean } = {}) {
   await app.register(networkAccessRoutes);
   await app.register(workspaceMailRoutes);
   await app.register(workspaceResourceRoutes);
+  await app.register(remoteDatabaseRoutes);
   // (sprint 138, AP-5) an application's Utilities
   await app.register(utilityRoutes);
   await app.register(dependencyRoutes);