arcane-os 0.13.3 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.15.0
+
+- Add explicit `arcane dev --http` and source API `http:true` for HTTP
+  development, including LAN device use. Reuse `node-http-server` and the same
+  application, PWA, source-mapping and conditional-response routes without
+  certificate setup. Report the actual HTTP endpoint and own one listener's
+  readiness, cancellation, errors and shutdown.
+- Preserve HTTPS and its HTTP `308` redirect as the default; packaged browser
+  previews continue using HTTPS. Browser settings, certificate validation,
+  application content and caching remain unchanged.
+
+## 0.14.0
+
+- Add opt-in `toolText: {name, field}` and `onToolText(text, call, displayId)`
+  to model streaming requests. Decode the selected root string field as tool
+  arguments arrive, separately from ordinary text and final tool execution.
+  Preserve actual call identity, whitespace, ordered delivery, and cancellation
+  across HTTP, native, and browser provider routes.
+- Export `formatConversationClosingReportText(value)` so streamed closing text
+  uses the same existing formatting as the complete report.
+
 ## 0.13.3
 
 - Skip automatic TTS finalization calls when a model stream completes while

package/README.md

@@ -73,7 +73,7 @@ each device. Keep these local files ignored by Git. The same certificate pair
 works for any selected app in that workspace. The command reports missing TLS
 files instead of starting an HTTP listener.
 
-Every Arcane app uses HTTPS for development and packaged browser previews.
+HTTPS is the default for development and required for packaged browser previews.
 Plain `npm run dev` binds to localhost with the same workspace certificate pair.
 An explicit `--host` overrides the bind address, and `--port` selects the HTTPS port.
 The paired HTTP listener returns 308 redirects and uses an OS-assigned port
@@ -84,6 +84,17 @@ for public mode. Network reachability depends on the machine's firewall and
 network. See the [development HTTPS setup](docs/reference/cli.md#development-https-setup)
 for device trust and DBOPFS's secure-context requirement.
 
+For explicit HTTP source development, including LAN device testing, use:
+
+```bash
+npm run dev -- --app hello-speech --public --http --port 8000
+```
+
+This selects one HTTP content listener and prints HTTP network URLs. It reads
+no certificate pair and serves the same application and generated PWA routes.
+PWA and storage availability still depend on the browser's secure-context
+rules; see [HTTP development](docs/reference/cli.md#explicit-http-development).
+
 Open the URL printed by the server. The generated page owns its import map and
 Arcane theme; its application module is `apps/hello-speech/modules/App.js`.
 `arcane/AI` is a managed **browser import**, not an npm-exported Node inference
@@ -518,7 +529,7 @@ arcane new <id> [--path <directory>] [--display-name <name>] [--target <target>]
 arcane init [id] [--workspace <directory>] [--display-name <name>] [--target <target>]
 arcane doctor [--workspace <directory>] [--arcane-root <directory>]
 arcane import-map [--workspace <directory>] [--app <id>]
-arcane dev [--app <id>] [--public] [--https] [--cert <file> --key <file>] [--host <address>] [--port 8000]
+arcane dev [--app <id>] [--public] [--http | --https] [--cert <file> --key <file>] [--host <address>] [--port 8000]
 arcane test [--app <id>] [--scope app]
 arcane test --scope shared --test-file <repo-relative.test.mjs>
 arcane check [--app <id>] [--scope app] [--skip-tests]

package/browser-runtime/ai/browser-wasm-llm-provider.mjs

@@ -2271,13 +2271,24 @@ function createCompletionAccumulator(modelId, requestId) {
   return completeValue({ push, result, hasToolCalls, correlateToolCalls });
 }
 
-function callbackStreamHandle({ runtime, request, signal, onSettled }) {
+function callbackStreamHandle({ runtime, request, signal, onSettled, observeToolText = null }) {
   const linked = linkAbortSignal(signal);
   const accumulator = createCompletionAccumulator(request.model ?? null, request.id);
   const chunks = [];
   const waiters = [];
   let ended = false;
   let terminalError = null;
+  let observation = Promise.resolve();
+  let observationError = null;
+
+  function publishChunk(chunk) {
+    if (ended || linked.controller.signal.aborted) return;
+    const publicChunk = projectPublicStreamChunk(chunk);
+    if (publicChunk === OMITTED_PUBLIC_STREAM_DATA) return;
+    const waiter = waiters.shift();
+    if (waiter) waiter.resolve({ value: publicChunk, done: false });
+    else chunks.push(publicChunk);
+  }
 
   function deliver(value) {
     // This gate prevents delivery after public cancellation. It is not proof
@@ -2287,11 +2298,20 @@ function callbackStreamHandle({ runtime, request, signal, onSettled }) {
       ? value
       : { ...value, id: request.id };
     accumulator.push(chunk);
-    const publicChunk = projectPublicStreamChunk(chunk);
-    if (publicChunk === OMITTED_PUBLIC_STREAM_DATA) return;
-    const waiter = waiters.shift();
-    if (waiter) waiter.resolve({ value: publicChunk, done: false });
-    else chunks.push(publicChunk);
+    if (!observeToolText) {
+      publishChunk(chunk);
+      return;
+    }
+    observation = observation.then(async function observeBrowserWasmChunk() {
+      if (ended) return;
+      throwIfAborted(linked.controller.signal);
+      await observeToolText(chunk);
+      publishChunk(chunk);
+    });
+    observation.catch(function cancelFailedBrowserWasmObservation(error) {
+      observationError ??= error;
+      linked.controller.abort(error);
+    });
   }
 
   function finish(error = null) {
@@ -2313,17 +2333,27 @@ function callbackStreamHandle({ runtime, request, signal, onSettled }) {
   );
   const result = (async () => {
     try {
-      await terminal;
+      const terminalValue = await terminal;
+      if (observeToolText) await observation;
+      throwIfAborted(linked.controller.signal);
+      if (observeToolText) await observeToolText(terminalValue);
       throwIfAborted(linked.controller.signal);
       const value = accumulator.result();
+      if (observeToolText) await observeToolText(value);
+      throwIfAborted(linked.controller.signal);
       finish();
       return value;
     } catch (error) {
-      const normalized = normalizeArcaneAIError(error, {
+      const normalized = normalizeArcaneAIError(observationError ?? error, {
         kind: "llm",
         operation: "request",
-        signal: normalizationSignal(error, linked.controller.signal),
+        signal: observationError ? null : normalizationSignal(error, linked.controller.signal),
       });
+      if (observeToolText) {
+        await observation.catch(function retainFirstBrowserWasmStreamFailure() {
+          // The failure captured above remains the terminal outcome.
+        });
+      }
       finish(normalized);
       throw normalized;
     }
@@ -2380,7 +2410,7 @@ function callbackStreamHandle({ runtime, request, signal, onSettled }) {
   return completeValue(handle);
 }
 
-function validatedV1StreamHandle(opened, request) {
+function validatedV1StreamHandle(opened, request, observeToolText = null, signal = null) {
   if (
     !opened
     || !is.object(opened)
@@ -2429,6 +2459,16 @@ function validatedV1StreamHandle(opened, request) {
   let publicStreamSettled = false;
   let publicStreamError = null;
 
+  function stopV1ToolTextObservation(reason) {
+    if (!observeToolText) return;
+    publicStreamError ??= reason instanceof Error ? reason : fail(
+      'ARCANE_AI_REQUEST_ABORTED',
+      'The browser-WASM request was cancelled.',
+      reason,
+    );
+    settlePublicStream(publicStreamError);
+  }
+
   function publishPublicChunk(value) {
     if (publicStreamSettled) return;
     const waiter = publicChunkWaiters.shift();
@@ -2459,10 +2499,24 @@ function validatedV1StreamHandle(opened, request) {
           return true;
         }
         accumulator.push(next.value);
+        if (observeToolText) {
+          if (publicStreamError !== null) throw publicStreamError;
+          throwIfAborted(signal);
+          await observeToolText(next.value);
+          if (publicStreamError !== null) throw publicStreamError;
+          throwIfAborted(signal);
+        }
         const projected = projectPublicStreamChunk(next.value);
         if (projected !== OMITTED_PUBLIC_STREAM_DATA) publishPublicChunk(projected);
       }
     } catch (error) {
+      if (observeToolText) {
+        Promise.resolve().then(function cancelFailedV1ToolTextStream() {
+          return opened.cancel(error);
+        }).catch(function reportFailedV1ToolTextCancellation(cleanupError) {
+          arcaneLogging.error('Arcane v1 tool-text stream cancellation failed.', cleanupError);
+        });
+      }
       settlePublicStream(error);
       throw error;
     }
@@ -2476,8 +2530,15 @@ function validatedV1StreamHandle(opened, request) {
   );
   terminalResult.catch(function retainV1StreamTerminalRejection() {});
   const result = Promise.all([terminalResult, privateStreamPump]).then(
-    function correlateV1StreamTerminal([terminal]) {
+    async function correlateV1StreamTerminal([terminal]) {
+      if (observeToolText && publicStreamError !== null) throw publicStreamError;
       accumulator.correlateToolCalls(terminal);
+      if (observeToolText) {
+        throwIfAborted(signal);
+        await observeToolText(terminal);
+        if (publicStreamError !== null) throw publicStreamError;
+        throwIfAborted(signal);
+      }
       return terminal;
     },
   );
@@ -2485,6 +2546,7 @@ function validatedV1StreamHandle(opened, request) {
   const handle = {
     result,
     cancel: function cancelValidatedV1Stream(reason) {
+      stopV1ToolTextObservation(reason);
       return opened.cancel(reason);
     },
     async next() {
@@ -2496,6 +2558,7 @@ function validatedV1StreamHandle(opened, request) {
       });
     },
     async return(value) {
+      stopV1ToolTextObservation('The stream consumer stopped before completion.');
       if (is.function(iterator.return)) {
         Promise.resolve().then(function returnUnderlyingV1Stream() {
           return iterator.return(value);
@@ -2511,6 +2574,7 @@ function validatedV1StreamHandle(opened, request) {
       return { value, done: true };
     },
     async throw(error) {
+      stopV1ToolTextObservation(error);
       await opened.cancel(error);
       throw error;
     },
@@ -3171,6 +3235,7 @@ export function createBrowserWasmLlmProvider({
         runtime,
         request,
         signal: externalSignal,
+        observeToolText: context.observeToolText,
         onSettled(error) {
           if (settled) return;
           settled = true;
@@ -3452,7 +3517,7 @@ export function adaptV1LlmProvider(provider) {
       });
       return status();
     },
-    request({ role = "llm", selection, operation, payload, signal = null } = {}) {
+    request({ role = "llm", selection, operation, payload, signal = null } = {}, controls = {}) {
       assertSelection(selection, role);
       assertActiveSelection(selection);
       throwIfAborted(signal);
@@ -3466,9 +3531,9 @@ export function adaptV1LlmProvider(provider) {
       }
       if (operation === "stream") {
         validateStructuralRequest(payload);
-        return Promise.resolve(methods.stream(payload, { signal })).then(
+        return Promise.resolve(methods.stream(payload, { signal, observeToolText: controls.observeToolText })).then(
           function wrapV1StreamResult(opened) {
-            return validatedV1StreamHandle(opened, payload);
+            return validatedV1StreamHandle(opened, payload, controls.observeToolText, signal);
           },
         );
       }

package/browser-runtime/ai/model-controller.mjs

@@ -1,6 +1,7 @@
 import Is from "../dependencies/strong-type/index.js";
 import { arcaneLogging } from '../logging.mjs';
 import { createArcaneEventSource } from "arcane-os/event-manager";
+import { createToolTextObserver } from './tool-text-stream.mjs';
 
 const is = new Is(false);
 
@@ -1311,13 +1312,22 @@ export class ModelController {
     }
   }
 
-  stream(request = {}) {
+  stream(request = {}, context = {}) {
     this.#assertOperational();
     request=structuralRequest(request);
     localRequirement(request, this.#provider);
     const controller = this;
     const externalSignal = request.signal ?? null;
     const linked = linkedAbortSignal(externalSignal);
+    const observeToolText = context.observeToolText ? async function observeActiveModelToolText(chunk) {
+      if (linked.controller.signal.aborted) {
+        throw normalizeArcaneAIError(null, { operation: 'request', signal: linked.controller.signal });
+      }
+      await context.observeToolText(chunk);
+      if (linked.controller.signal.aborted) {
+        throw normalizeArcaneAIError(null, { operation: 'request', signal: linked.controller.signal });
+      }
+    } : null;
     let opened = null;
     let openedIterator = null;
     let openError = null;
@@ -1363,6 +1373,7 @@ export class ModelController {
           kind: "llm",
           operation: "stream",
           signal: linked.controller.signal,
+          observeToolText,
         },
       );
       if (
@@ -1427,10 +1438,18 @@ export class ModelController {
             return true;
           }
           streamedToolCalls.observe(next.value);
+          if (observeToolText) await observeToolText(next.value);
           const projected=projectPublicStreamChunk(next.value);
           if(projected!==OMITTED_PUBLIC_STREAM_DATA)publishPublicChunk(projected);
         }
       }catch(error){
+        if (observeToolText) {
+          Promise.resolve().then(function cancelFailedModelToolTextStream() {
+            return opened.cancel(error);
+          }).catch(function reportFailedModelToolTextCancellation(cleanupError) {
+            arcaneLogging.error('Arcane model tool-text stream cancellation failed.', cleanupError);
+          });
+        }
         settlePublicStream(error);
         throw error;
       }
@@ -1446,8 +1465,9 @@ export class ModelController {
     });
     terminalResult.catch(()=>undefined);
 
-    const result = Promise.all([terminalResult,privateStreamPump]).then(([terminal]) => {
+    const result = Promise.all([terminalResult,privateStreamPump]).then(async function completeModelStream([terminal]) {
       streamedToolCalls.correlate(terminal);
+      if (observeToolText) await observeToolText(terminal);
       settlePublicStream();
       return terminal;
     }).catch((error)=>{
@@ -1533,10 +1553,18 @@ export class ModelController {
     this.#assertOperational();
     localRequirement(options, this.#provider);
     const id = requestIdentity(options.id);
-    const request = structuralRequest({ ...options, id });
+    const { toolText, onToolText, ...requestOptions } = options;
+    const request = structuralRequest({ ...requestOptions, id });
     const displayId = displayRequestId(id);
+    const observeToolText = createToolTextObserver(
+      toolText,
+      is.function(onToolText) ? function deliverSelectedToolText(text, call) {
+        return onToolText(text, call, displayId);
+      } : onToolText,
+      { signal: options.signal },
+    );
     fireAndForget(options.onRequest, request, id);
-    const handle = this.stream(request);
+    const handle = this.stream(request, { observeToolText });
 
     try {
       for await (const chunk of handle) {