pgkiln 0.78.0 → 0.80.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/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);