arcane-os 0.13.3 → 0.15.0

package/docs/reference/runtime-modules.md

@@ -432,7 +432,7 @@ declined, cancelled, or not-executed result.
 That tool-result content must be a nonblank string and is preserved exactly.
 
 `streamRequest()` owns the complete terminal callback sequence. `onDataChunk`
-receives each complete provider chunk before ordinary projection, while
+receives each provider chunk after private structural fields are removed, while
 `onChunk` receives every nonstructural content or reasoning value from every
 choice in provider order. After the stream settles, `onDataResult` receives the
 complete terminal completion, `onResponse` receives that same unprojected
@@ -442,8 +442,29 @@ output is the ordered structural-call array when the selected result contains
 tools, the complete completion object when it contains multiple choices, or
 the ordinary single-result text/completion otherwise; later choices are never
 discarded.
-Partial structural deltas remain private until the matching terminal envelope
-validates. Request observers receive
+Raw structural deltas remain private until the matching terminal envelope
+validates. To display one tool argument's text as it arrives, supply
+`toolText:{name,field}` and `onToolText(text,call,displayId)`. `name` is the exact
+tool name and `field` is one root-level string argument. The callback receives
+each newly decoded text fragment in order, including whitespace and JSON string
+escapes decoded to their original characters. Its `call` record contains
+`{id,name,field,index,choiceIndex}`; `id` is the actual normalized tool-call ID,
+`index` identifies the call within its choice, and `choiceIndex` identifies the
+response choice. Delivery starts once the matching tool name and call ID are
+known. `displayId` is the same `M-${id}` request display ID used by `onChunk`.
+
+`onToolText` is separate from ordinary `onChunk`, so callers can append to the
+tool's existing display without duplicating assistant prose or saved history.
+It observes text only: it does not execute a tool, alter arguments, persist a
+turn, or change the terminal callbacks. A provider that supplies arguments only
+at completion emits text only when that complete response arrives. Repeated
+terminal snapshots do not replay text already emitted. Omitting `toolText`
+preserves the existing callback path. Invalid selection or callback input throws
+`TypeError`; malformed selected argument text reports
+`ARCANE_AI_TOOL_TEXT_INVALID`. Callback errors reach the request owner and
+cancellation prevents later delivery.
+
+Request observers receive
 `onRequest(request,id,metadata)` and any transport metadata supplied by the
 selected route is forwarded unchanged. Every async native, HTTP, provider, and
 built-in callback is observed before the next callback or terminal settlement.
@@ -1609,7 +1630,7 @@ Defines the closing-report tool, instruction, result normalizer, call classifier
 
 ### Public surface
 
-Six constants/helpers for closing reports.
+Seven constants/helpers for closing reports.
 
 The generated sole-call schema requires both `message` and `final_message`.
 `message` is brief user-facing progress shown while the application accepts and
@@ -1617,9 +1638,14 @@ renders the call. `final_message` remains the complete terminal closeout and is
 never replaced by or duplicated into `message`; `remembered_actions` remains
 optional. `normalizeConversationClosingReport()` returns
 `{message,finalMessage,rememberedActions}`, while
-`formatConversationClosingReport()` escapes and renders only `finalMessage`.
+`formatConversationClosingReport()` normalizes the complete report and formats
+only `finalMessage`. Its shared `formatConversationClosingReportText(value)`
+operation accepts a string, including an empty or whitespace-only chunk, and
+replaces `&`, `<`, and `>` with `&amp;`, `&lt;`, and `&gt;` respectively. It
+preserves all other text and does not trim, validate a report, render, or persist
+anything. Use the same operation for live text chunks and complete final text.
 
-Exact exports: `CONVERSATION_CLOSING_REPORT_TOOL_NAME`, `classifyConversationClosingReportCalls`, `conversationClosingReportInstruction`, `createConversationClosingReportTool`, `formatConversationClosingReport`, `normalizeConversationClosingReport`.
+Exact exports: `CONVERSATION_CLOSING_REPORT_TOOL_NAME`, `classifyConversationClosingReportCalls`, `conversationClosingReportInstruction`, `createConversationClosingReportTool`, `formatConversationClosingReport`, `formatConversationClosingReportText`, `normalizeConversationClosingReport`.
 
 ### Availability and normalization
 
@@ -1628,9 +1654,11 @@ Exact exports: `CONVERSATION_CLOSING_REPORT_TOOL_NAME`, `classifyConversationClo
 ### Example
 
 ```javascript
-import * as module from '/arcane/modules/ConversationClosingReport.js';
+import {
+    formatConversationClosingReportText
+} from '/arcane/modules/ConversationClosingReport.js';
 
-console.log(Object.keys(module));
+console.log(formatConversationClosingReportText('Complete <draft> & next step.'));
 ```
 
 ## ConversationTimebox.js

package/docs/reference/sdk-api.md

@@ -3,7 +3,7 @@
 The npm package exposes a Node.js ESM control plane, the portable
 `arcane-os/event-manager`, `arcane-os/logging`, `arcane-os/mail`,
 `arcane-os/preference-store`, `arcane-os/speech-playback`,
-`arcane-os/speech-text`, and `arcane-os/browser-device` entrypoints, and the browser-only
+`arcane-os/speech-text`, `arcane-os/ai/tool-text-stream`, and `arcane-os/browser-device` entrypoints, and the browser-only
 `arcane-os/pwa`, `arcane-os/ai/browser-wasm` and `arcane-os/ai/browser-speech` entrypoints.
 Those package subpaths are distinct from application-facing projection modules
 in the managed browser map, such as `arcane/AIProviderRuntime`,
@@ -41,6 +41,7 @@ for the installed-inventory-derived physical-runtime contract in SDK `0.5.18`.
 | `arcane-os/browser-device` | Synchronous mobile or desktop identity hints for application-owned settings. |
 | `arcane-os/pwa` | Nonblocking PWA registration, worker updates, native installation state and a dismissible installation component. |
 | `arcane-os/ai/browser-wasm` | Caller-selected browser-local Wllama inference, complete DBOPFS model storage, streaming, cancellation, and structural tool-call results. |
+| `arcane-os/ai/tool-text-stream` | Shared selected tool-argument text observer for provider integration. |
 | `arcane-os/ai/browser-speech` | Caller-selected browser-local Whisper STT and Kokoro TTS provider mechanisms, ordinary upstream assets, materialized/native routing, Workers, and cancellation. |
 | `arcane-os/mail` | Portable Mail runtime, durable outbox, complete transport responses, and provider-neutral acceptance contracts. |
 
@@ -138,6 +139,7 @@ browser map are cataloged separately in [Runtime modules](runtime-modules.md).
 | `createNativeTargetAdapter()` | function | `arcane-os` | Targets, native plans, and providers | Node; selected browser/native target or provider as documented |
 | `createReporter()` | function | `arcane-os` | Events, processes, and testing | Node |
 | `createToolchain()` | function | `arcane-os` | Headless toolchain operations | Node; selected operation may produce browser or native output |
+| `createToolTextObserver()` | function | `arcane-os/ai/tool-text-stream` | AI provider integration | Compatible JavaScript module host; no browser capability required |
 | `createWorkspace()` | function | `arcane-os` | Workspace, doctor, repository, and server | Node |
 | `default()` | function | `arcane-os/testing` | Events, processes, and testing | Node |
 | `DEFAULT_TEST_TIMEOUT_MS` | constant | `arcane-os` | Events, processes, and testing | Node |
@@ -3462,7 +3464,7 @@ async function useselectApp(...arguments_) {
 
 Starts one owned browser development server with exact runtime/app route mappings and a caller-selected bind address.
 
-HTTPS serving uses the published `node-http-server` module. The SDK
+HTTP and HTTPS serving use the published `node-http-server` module. The SDK
 selects source routes and supplies generated representations; the module owns
 static-file conditional GET/HEAD handling and response delivery. The SDK
 retains modification dates for its generated representations. Unchanged
@@ -3478,7 +3480,7 @@ async startDevServer(options={})
 ```
 
 Import it from `arcane-os`. Source mode accepts
-`{workspaceRoot=process.cwd(), appId, mode='source', host='127.0.0.1', port=0, httpPort=0,
+`{workspaceRoot=process.cwd(), appId, mode='source', host='127.0.0.1', port=0, httpPort=0, http=false,
 certPath, keyPath, tls, signal, onEvent}` and serves one validated
 workspace application plus its complete SDK or integrated runtime. Packaged mode uses
 `{mode:'packaged', releaseRoot, workspaceRoot, host, port, httpPort, certPath, keyPath, tls,
@@ -3492,9 +3494,9 @@ The SDK request hook returns `308` for HTTP with a `Location` pointing to the
 actual HTTPS port while preserving the original request path and query. Both listeners
 use the selected host.
 
-Every source server and packaged browser preview enforces HTTPS, including
-localhost. The legacy `https` option is accepted but cannot disable it.
-Startup reads `.arcane/dev/server-cert.pem` and
+Source servers default to HTTPS, including localhost; packaged browser previews
+require HTTPS. The legacy `https` option is accepted but `https:false` and
+`tls:false` alone do not disable HTTPS. HTTPS startup reads `.arcane/dev/server-cert.pem` and
 `.arcane/dev/server-key.pem` relative to `workspaceRoot` unless explicit
 `certPath` and `keyPath` are supplied together; relative paths resolve from the
 workspace. A direct `tls` object instead supplies Node HTTPS server options, including
@@ -3505,16 +3507,27 @@ handshake; browser trust and address matching are evaluated when a client
 connects. The CLI's `--public` selects the wildcard bind;
 the API's `host` option alone changes only the bind address.
 
-The promise settles after both listeners are ready and resolves to
+Explicit `http:true` selects one HTTP content listener in source mode and skips
+certificate loading. `port` selects that listener's port, including `0` for an
+available port. The same application, runtime and generated PWA routes are
+served. `http` must be boolean; `http:true` rejects packaged mode, `https:true`,
+explicit certificate/key paths, a `tls` value other than `undefined`, `null` or
+`false`, and a nonzero `httpPort`. Browser secure-context and installation
+requirements remain browser-owned; see [explicit HTTP development](cli.md#explicit-http-development).
+
+The promise settles after all selected listeners are ready and resolves to
 `{server, protocol, mode, workspaceRoot, appId, host, port, origin, cleanUrl, url,
-networkUrls, httpPort, httpOrigin, httpUrl, close, closed, lifecycle}`. `server` is the raw Node HTTPS
-server; `protocol` is `'https:'`.
+networkUrls, httpPort, httpOrigin, httpUrl, close, closed, lifecycle}`. `server` is the raw Node
+server for application content; `protocol` is `'https:'` by default or `'http:'`
+with explicit HTTP source mode.
 `url` and `cleanUrl` are the same application URL. Wildcard listeners use
 `localhost` in that local URL; `host` retains the actual bound address.
 `httpPort` is the actual HTTP listener port, `httpOrigin` is its HTTP origin,
 and `httpUrl` combines that origin with the application start path. These
-fields identify the redirect endpoint; `origin`, `url`, `cleanUrl`, and
-`networkUrls` identify HTTPS application endpoints.
+fields identify the redirect endpoint in HTTPS mode; `origin`, `url`, `cleanUrl`,
+and `networkUrls` identify application endpoints. In HTTP mode, `httpPort`,
+`httpOrigin`, and `httpUrl` equal `port`, `origin`, and `url`; they identify the
+single content listener, with no redirect listener.
 `networkUrls` lists application URLs for applicable non-loopback interface
 addresses discovered once at startup. These URLs are connection candidates,
 not evidence of reachability from another device. The server adds no session
@@ -3526,15 +3539,15 @@ certificates or modify trust stores. Each client must trust the issuing CA and o
 server certificate. Lifecycle events and CLI summaries exclude TLS options and
 private key contents. See [development HTTPS setup](cli.md#development-https-setup).
 
-Starting the server opens both selected listeners and emits awaited,
+Starting the server opens the selected listener or listeners and emits awaited,
 backpressured `server.starting` and `server.started` events. `server.started`
-includes `httpPort`, `httpOrigin`, and `httpUrl` alongside the HTTPS endpoint.
+includes the selected `protocol`, `httpPort`, `httpOrigin`, and `httpUrl` alongside the application endpoint.
 Request failures emit `server.request.failed`; shutdown emits `server.stopped` after owned
 requests and event delivery drain. Call `await result.close()` in a `finally`
 block, or abort `signal`; `close()` is idempotent and returns the
 same settlement represented by both `closed` and `lifecycle`. Closing the
-operation closes both listeners. An error from either listener or an
-event-callback failure closes both and rejects the lifecycle. Invalid
+operation closes every selected listener once. A listener error or an
+event-callback failure closes the operation and rejects the lifecycle. Invalid
 mode/host/port/httpPort, malformed workspace or release content, an occupied port,
 or an already-aborted signal rejects startup.
 
@@ -3929,14 +3942,15 @@ async function usedescribeTargets(...arguments_) {
 
 Starts one owned browser development server for the selected application.
 
-`https`, `certPath`, `keyPath`, and `tls` follow the
-[`startDevServer()` TLS contract](#startdevserver), alongside `host`, `port`, and
-`httpPort`. `port` selects HTTPS and `httpPort` selects the HTTP `308` redirect
-listener; each defaults to an available port.
+`http`, `https`, `certPath`, `keyPath`, and `tls` follow the
+[`startDevServer()` transport contract](#startdevserver), alongside `host`, `port`, and
+`httpPort`. By default, `port` selects HTTPS and `httpPort` selects the HTTP `308`
+redirect listener; each defaults to an available port. Explicit `http:true`
+selects one source HTTP content listener at `port`, without certificate loading.
 The operation refreshes the selected authored descriptor's `arcane-package.json`
 projection and managed import maps under one development-refresh lock, then
-releases that lock before opening the HTTPS source listener and its HTTP
-redirect listener. It returns both endpoints and their shared shutdown
+releases that lock before opening the selected source listener or listeners.
+It returns their application endpoints and shared shutdown
 lifecycle. Legacy package-only apps remain unchanged. The operation generates
 no packaged output; enabled PWA manifests
 are served directly from the selected source resources.
@@ -5905,8 +5919,20 @@ At least one `llm` or `provider` is required. The mutable API object contains
 delivers every choice's ordinary content/reasoning values in provider order,
 and returns ordinary terminal text for one choice, a structural-call array for
 selected tool output, or complete JSON text for a multi-choice completion.
-`onDataChunk` and `onDataResult` preserve the complete provider chunk and
-terminal record independently of that application-facing projection. Use
+`onDataChunk` receives provider chunks with private structural fields removed;
+`onDataResult` preserves the complete terminal record independently of that
+application-facing projection. Supply `toolText:{name,field}` with
+`onToolText(text,call,displayId)` to receive one selected root string argument
+as it arrives. `call` contains `{id,name,field,index,choiceIndex}` with the real
+normalized call ID, call position, and response-choice index. The SDK decodes
+JSON string escapes, preserves whitespace and order, and starts delivery once
+the matching tool name and call ID are known. `displayId` is the same request
+display ID as `onChunk`. This separate callback does not add ordinary prose,
+execute tools, or persist history. Complete-only providers emit the selected
+text only on actual completion; repeated terminal snapshots do not replay
+emitted text. Callback failures reach the request owner and cancellation
+prevents later delivery. Omitting `toolText` preserves the existing behavior.
+See the [tool-text example](ai/browser-wasm.md#stream-selected-tool-text). Use
 `ai.llm.stream()` for the async iterator; structural fragments remain private
 until the complete terminal result validates.
 
@@ -5991,6 +6017,61 @@ async function openLocalReviewAfterUserChoice() {
 }
 ```
 
+## createToolTextObserver()
+
+### Overview
+
+Creates the shared tool-text observer used by SDK provider integrations before
+private structural fields are removed. Application callers normally use
+`streamRequest({toolText,onToolText})` instead.
+
+### Signature and result
+
+```text
+createToolTextObserver(selection, onText, {signal}={})
+```
+
+`selection` is `{name,field}`: the exact tool name and one root string argument.
+`undefined`, `null`, or `false` selection returns `null`. An active selection
+requires nonblank string `name` and `field` values and an `onText` function;
+invalid configuration throws `TypeError`.
+
+The result is an async `observeToolText(chunk)` function. It accepts raw
+OpenAI-compatible `choices[].delta.tool_calls` fragments and complete
+`choices[].message.tool_calls` or `message.tool_calls` snapshots. `onText` is
+awaited with each newly decoded fragment and
+`{id,name,field,index,choiceIndex}`. It preserves decoded string content and
+whitespace, waits for the matching name and real normalized ID, and reports
+malformed selected argument text with `ARCANE_AI_TOOL_TEXT_INVALID`.
+
+### Availability and normalization
+
+**Compatible JavaScript module host.** One observer owns one request's call
+state. Consume each raw delta once, before any structural filtering; pass the
+same observer through the provider integration instead of creating another
+parser. Complete snapshots may be observed again without replaying emitted
+text. A complete-only response emits only when received. `signal` stops later
+observation after cancellation; callback errors propagate to the caller. The
+observer does not modify the supplied chunk, invoke tools, persist history, or
+start inference.
+
+### Example
+
+```javascript
+import {createToolTextObserver} from 'arcane-os/ai/tool-text-stream';
+
+function createProviderTextObserver(onText, signal) {
+    return createToolTextObserver(
+        {name:'prepare_conversation_closing_report', field:'final_message'},
+        onText,
+        {signal}
+    );
+}
+```
+
+The provider owner passes actual raw chunks to the returned observer and awaits
+it before continuing its existing filtered stream delivery.
+
 ## createBrowserModelSource()
 
 ### Overview

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.13.3",
+  "version": "0.15.0",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",
@@ -20,6 +20,7 @@
     "./speech-playback": "./runtime/arcane/modules/SpeechPlayback.js",
     "./speech-text": "./browser-runtime/speech-text.mjs",
     "./ai/browser-wasm": "./browser-runtime/ai/browser-wasm.mjs",
+    "./ai/tool-text-stream": "./browser-runtime/ai/tool-text-stream.mjs",
     "./ai/browser-speech": "./browser-runtime/ai/browser-speech.mjs",
     "./mail": "./src/mail-api.mjs",
     "./testing": "./src/testing.mjs",

package/runtime/arcane/modules/AI.js

@@ -18,6 +18,7 @@ import {normalizeOllamaModelIdentifier} from './OllamaModelIdentifier.js';
 import {arcaneLogging} from 'arcane-os/logging';
 import {MarkdownSpeech,stripSpeechFormatting} from 'arcane-os/speech-text';
 import {prepareSpeech} from './PreparedSpeech.js';
+import {createToolTextObserver} from 'arcane-os/ai/tool-text-stream';
 
 const completeValue=(value)=>value;
 
@@ -1470,7 +1471,7 @@ class AI {
                     status:statusBuiltInLLMProvider()
                 });
             },
-            request:function requestBuiltInLLMProvider(context={}){
+            request:function requestBuiltInLLMProvider(context={},controls={}){
                 if(context.signal?.aborted){
                     throw normalizeAIRequestAbort(context.signal.reason);
                 }
@@ -1502,7 +1503,8 @@ class AI {
                         function executeBuiltInLLMProviderStream(bridge){
                             return runtime.#requestBuiltInLLMStream(
                                 context.payload,
-                                bridge
+                                bridge,
+                                controls.observeToolText
                             );
                         },
                         context.signal
@@ -4285,7 +4287,7 @@ class AI {
         );
     }
 
-    #requestBuiltInLLMStream(payload={},bridge){
+    #requestBuiltInLLMStream(payload={},bridge,observeToolText=null){
         const parallelToolCalls=payload.parallelToolCalls!==undefined
             ?payload.parallelToolCalls
             :payload.parallel_tool_calls;
@@ -4310,7 +4312,8 @@ class AI {
             true,
             emitBuiltInLLMStreamData,
             function ignoreBuiltInLLMStreamResult(){},
-            payload.reasoningEffort
+            payload.reasoningEffort,
+            observeToolText
         );
     }
 
@@ -4459,6 +4462,8 @@ class AI {
         structuredOutput=false,
         localOnly=false,
         onChunk=function ignoreStreamChunk(){},
+        toolText,
+        onToolText,
         onComplete=function finishIgnoredStream(){},
         onDataChunk=function ignoreStreamDataChunk(){},
         onDataResult=function ignoreStreamDataResult(){},
@@ -4484,6 +4489,15 @@ class AI {
         reasoningEffort
     }={}){
         validateAIStructuralRequest(messages,tools,parallelToolCalls);
+        const observeToolText=createToolTextObserver(
+            toolText,
+            is.function(onToolText)
+                ?function reportAIStreamToolText(text,call){
+                    return onToolText(text,call,`M-${id}`);
+                }
+                :onToolText,
+            {signal}
+        );
         const normalizedReasoningEffort=normalizeAIReasoningEffort(
             reasoningEffort===undefined?this.reasoningEffort:reasoningEffort
         );
@@ -4538,7 +4552,8 @@ class AI {
                         payload:request,
                         localOnly,
                         signal
-                    }
+                    },
+                    {observeToolText}
                 );
                 for await(const chunk of handle){
                     if(signal?.aborted){
@@ -4622,7 +4637,8 @@ class AI {
                 true,
                 onDataChunk,
                 onDataResult,
-                normalizedReasoningEffort
+                normalizedReasoningEffort,
+                observeToolText
             );
             const structuralToolCalls=normalizeAICompletionToolCalls(
                 completion
@@ -4729,7 +4745,8 @@ class AI {
         returnCompletion=false,
         dataChunkHandler=function ignoreBuiltInStreamDataChunk(){},
         dataResultHandler=function ignoreBuiltInStreamDataResult(){},
-        reasoningEffort
+        reasoningEffort,
+        observeToolText=null
     ){
         let speechTurnCompleted=false;
 
@@ -4845,6 +4862,12 @@ class AI {
                                 );
                             }
                             streamedNativeToolCalls=observed;
+                            if(observeToolText){
+                                await observeToolText({message:{tool_calls:observed}});
+                            }
+                        }
+                        if(signal?.aborted){
+                            return;
                         }
                         const thinking=seeThinking
                             ?String(message.thinking||'')
@@ -4918,6 +4941,12 @@ class AI {
                 structuralToolCalls,
                 tool_choice
             );
+            if(observeToolText){
+                await observeToolText(nativeCompletion);
+            }
+            if(signal?.aborted){
+                throw normalizeAIRequestAbort();
+            }
             await dataResultHandler(nativeCompletion,id);
             for(const call of structuralToolCalls){
                 if(signal?.aborted){
@@ -5096,6 +5125,12 @@ class AI {
                     'The AI stream returned a non-object event payload.'
                 );
             }
+            if(observeToolText){
+                await observeToolText(streamedResponse);
+            }
+            if(signal?.aborted){
+                throw normalizeAIRequestAbort();
+            }
             const dataChunk=projectAIStreamChunk(streamedResponse);
             if(dataChunk!==OMITTED_AI_STREAM_DATA){
                 await dataChunkHandler(dataChunk,id);
@@ -5253,6 +5288,13 @@ class AI {
                 await drainSseBuffer(true);
             }
         }catch(error){
+            if(observeToolText){
+                await reader.cancel(error).catch(
+                    function reportToolTextReaderCleanupFailure(cleanupError){
+                        arcaneLogging.error('Arcane tool text reader cleanup failed.',cleanupError);
+                    }
+                );
+            }
             if(isAIRequestAbort(error,signal)){
                 throw normalizeAIRequestAbort(error);
             }
@@ -5383,6 +5425,12 @@ class AI {
             terminalToolCalls,
             'The built-in HTTP stream'
         );
+        if(observeToolText){
+            await observeToolText(completion);
+        }
+        if(signal?.aborted){
+            throw normalizeAIRequestAbort();
+        }
         await dataResultHandler(completion,id);
         for(const call of terminalToolCalls){
             if(signal?.aborted){

package/runtime/arcane/modules/AIProviderRuntime.js

@@ -3347,14 +3347,14 @@ export class AIProviderRuntime {
         return this.#disposeAllPromise;
     }
 
-    request(role, options = {}, {speechInputPrepared = false} = {}) {
+    request(role, options = {}, {speechInputPrepared = false, observeToolText = null} = {}) {
         if (SPEECH_ROLES.includes(role)) {
             arcaneLogging.debug('[Arcane speech runtime] request', role, options);
         }
-        return this.#requestRole(role, options, false, speechInputPrepared);
+        return this.#requestRole(role, options, false, speechInputPrepared, observeToolText);
     }
 
-    #requestRole(role, options, queued, speechInputPrepared = false) {
+    #requestRole(role, options, queued, speechInputPrepared = false, observeToolText = null) {
         this.#assertOpen();
         this.#assertNotConfiguring();
         assertRole(role);
@@ -3486,7 +3486,7 @@ export class AIProviderRuntime {
         }
         if ((!queued && slot.requestQueue.length)
             || slot.activeRequests.size >= maxConcurrentRequests) {
-            return this.#enqueueRoleRequest(slot, options);
+            return this.#enqueueRoleRequest(slot, options, observeToolText);
         }
         if (!slot.ready
             || providerStatus.state !== 'ready'
@@ -3556,6 +3556,17 @@ export class AIProviderRuntime {
         }
 
         if (options.operation === 'stream') {
+            const observeCurrentToolText = role === 'llm' && observeToolText
+                ? async function observeCurrentAIProviderToolText(chunk) {
+                    runtime.#assertCurrentRequest(
+                        slot, generation, requestSequence, requestRecord, controller.signal
+                    );
+                    await observeToolText(chunk);
+                    runtime.#assertCurrentRequest(
+                        slot, generation, requestSequence, requestRecord, controller.signal
+                    );
+                }
+                : null;
             let providerHandle = null;
             let providerOpenPromise = null;
             let iterator = null;
@@ -3796,7 +3807,8 @@ export class AIProviderRuntime {
                                     operation: options.operation,
                                     payload: options.payload,
                                     signal: controller.signal
-                                }
+                                },
+                                {observeToolText: observeCurrentToolText}
                             );
                         }
                     );
@@ -3862,6 +3874,7 @@ export class AIProviderRuntime {
                                         continue;
                                     }
                                     llmToolCallCorrelation.observe(result.value);
+                                    if (observeCurrentToolText) await observeCurrentToolText(result.value);
                                     const projected = projectLLMStreamChunk(result.value);
                                     if (projected !== OMITTED_LLM_STREAM_DATA) {
                                         publishProjectedAIProviderStreamChunk(projected);
@@ -3902,6 +3915,7 @@ export class AIProviderRuntime {
                                     )
                                     : value;
                                 llmToolCallCorrelation?.assertTerminal(terminalValue);
+                                if (observeCurrentToolText) await observeCurrentToolText(terminalValue);
                                 settleAIProviderStream(null, terminalValue);
                             } catch (error) {
                                 if (cleanupPromise) {
@@ -4208,7 +4222,7 @@ export class AIProviderRuntime {
         );
     }
 
-    #enqueueRoleRequest(slot, options) {
+    #enqueueRoleRequest(slot, options, observeToolText = null) {
         if (SPEECH_ROLES.includes(slot.role)) {
             arcaneLogging.debug('[Arcane speech runtime] queue.enqueue', {
                 role: slot.role,
@@ -4222,6 +4236,7 @@ export class AIProviderRuntime {
         return new Promise(function queueAIProviderRoleRequest(resolve, reject) {
             const entry = {
                 options,
+                observeToolText,
                 resolve,
                 reject,
                 detachSignal: null
@@ -4293,7 +4308,9 @@ export class AIProviderRuntime {
             }
             let operation;
             try {
-                operation = runtime.#requestRole(slot.role, entry.options, true);
+                operation = runtime.#requestRole(
+                    slot.role, entry.options, true, false, entry.observeToolText
+                );
             } catch (error) {
                 if (SPEECH_ROLES.includes(slot.role)) {
                     arcaneLogging.debug('[Arcane speech runtime] queue.error', slot.role, entry.options, error);

package/runtime/arcane/modules/ConversationClosingReport.js

@@ -74,7 +74,7 @@ function parseArguments(value){
     return value;
 }
 
-function escapeRawHTML(value){
+export function formatConversationClosingReportText(value){
     return value
         .replaceAll('&','&')
         .replaceAll('<','&lt;')
@@ -240,7 +240,7 @@ export function formatConversationClosingReport(value){
             remembered_actions:value.rememberedActions,
         }
         :value;
-    return escapeRawHTML(
+    return formatConversationClosingReportText(
         normalizeConversationClosingReport(normalizedInput).finalMessage
     );
 }

package/src/cli/main.mjs

@@ -39,6 +39,7 @@ const VALUE_OPTIONS=new Set([
 const FLAG_OPTIONS=new Set([
     'git',
     'public',
+    'http',
     'https',
     'skip-tests',
     'dry-run',
@@ -65,7 +66,7 @@ Usage:
   ${CLI_NAME} upgrade [--workspace <directory>] [--app <id>]
   ${CLI_NAME} doctor [--workspace <directory>] [--arcane-root <directory>]
   ${CLI_NAME} import-map [--workspace <directory>] [--app <id>]
-  ${CLI_NAME} dev [--app <id>] [--public] [--https] [--cert <pem>] [--key <pem>] [--host <address>] [--port 8000] [--http-port 0] [--sdk-runtime-source <sdk-root>]
+  ${CLI_NAME} dev [--app <id>] [--public] [--http | --https] [--cert <pem>] [--key <pem>] [--host <address>] [--port 8000] [--http-port 0] [--sdk-runtime-source <sdk-root>]
   ${CLI_NAME} test [--app <id>] [--scope app]
   ${CLI_NAME} test --scope shared --test-file <repo-relative.test.mjs>
   ${CLI_NAME} check [--app <id>] [--scope app] [--skip-tests]
@@ -88,8 +89,9 @@ Usage:
   ${CLI_NAME} mail serve --profile <profile> --from <address> --app <id> --origin <origin> [--allow-to <addresses>] [--app-key-stdin] [--host 127.0.0.1] [--port 8025] [--request-timeout <ms>]
 
 Development:
-  --public                      Serve HTTPS on all IPv4 interfaces (0.0.0.0) and print network URLs.
-  --https                       Accepted for compatibility; Arcane browser serving always uses HTTPS.
+  --public                      Bind dev to all IPv4 interfaces (0.0.0.0) and print network URLs.
+  --http                        Dev-only HTTP content on --port; no TLS or HTTPS redirect listener.
+  --https                       Explicitly select the default HTTPS browser transport.
   --cert <pem> --key <pem>        Use an existing certificate pair; paths are relative to the workspace.
   --host <address>               Override the bind address; takes precedence over --public.
   --http-port <port>             Browser dev/run HTTP redirect port; 0 selects an available port (default).
@@ -458,6 +460,14 @@ function operationOptions(command,parsed,cwd){
     if(flags.has('public')&&command!=='dev'){
         usage('--public is supported only by dev.');
     }
+    const http = flags.has('http');
+    if (http && command !== 'dev') {
+        usage('--http is supported only by dev.');
+    }
+    if (http && (flags.has('https') || values.cert !== undefined
+        || values.key !== undefined || values['http-port'] !== undefined)) {
+        usage('--http cannot combine --https, --cert, --key, or --http-port; select its listener with --port.');
+    }
     const browserServing = command === 'dev'
         || (command === 'run' && (values.target ?? 'browser') === 'browser');
     if ((flags.has('https') || values.cert !== undefined || values.key !== undefined) && !browserServing) {
@@ -470,7 +480,7 @@ function operationOptions(command,parsed,cwd){
         usage('Arcane HTTPS serving requires --cert and --key together.');
     }
     const browserServerOptions = browserServing ? {
-        https: true,
+        ...(http ? {http: true} : {https: true}),
         httpPort: readPort(values['http-port'], 0),
         ...(values.cert === undefined ? {} : {
             certPath: path.resolve(workspaceRoot, values.cert),
@@ -882,7 +892,7 @@ function serverSummary(result){
 async function waitForServer(result,signal,reporter){
     const readyMessage=[
         `Development server ready at ${result.url}`,
-        ...(result.httpUrl ? [`HTTP redirect: ${result.httpUrl}`] : []),
+        ...(result.httpUrl && result.protocol !== 'http:' ? [`HTTP redirect: ${result.httpUrl}`] : []),
         ...(result.networkUrls??[]).map(function networkAddress(url){return `Network: ${url}`;})
     ].join('\n');
     reporter.emit('server.ready',serverSummary(result),readyMessage);