@jskit-ai/assistant-runtime 0.1.164 → 0.1.166

package/fixtures/conversation/App.vue

@@ -1,5 +1,6 @@
 <script setup>
-import { computed, ref } from "vue";
+import { useAssistantAttachments } from "@jskit-ai/assistant-core/client/conversation";
+import { computed, reactive, ref } from "vue";
 import { useRoute, useRouter } from "vue-router";
 import { useTheme } from "vuetify";
 import { useWebPlacementContext } from "@jskit-ai/shell-web/client/placement";
@@ -12,6 +13,12 @@ const mounted = ref(true);
 const second = ref(false);
 const compact = ref(false);
 const surface = ref("admin");
+const integrationId = ref("quick");
+const attachments = reactive(useAssistantAttachments({
+  sessionId: () => String(route.query.workspace || "alpha"),
+  uploadAttachment: async (_scope, file) => ({ attachmentId: "fixture-file", fileName: file.name, size: file.size }),
+  deleteAttachment: async () => {}
+}));
 const workspace = computed(() => route.query.workspace || "alpha");
 function switchWorkspace() { router.push({ query: { workspace: workspace.value === "alpha" ? "beta" : "alpha" } }); }
 </script>
@@ -30,7 +37,7 @@ function switchWorkspace() { router.push({ query: { workspace: workspace.value =
           <button @click="theme.change(theme.global.name.value === 'dark' ? 'light' : 'dark')">Toggle theme</button>
         </nav>
         <div class="fixture__panes" :class="{ 'fixture__panes--compact': compact }">
-          <AssistantSurfaceClientElement v-if="mounted" :surface-id="surface" :layout="compact ? 'compact' : 'page'" assistant-label="Fixture assistant" />
+          <AssistantSurfaceClientElement v-if="mounted" v-model:integration-id="integrationId" :connections="[{ id: 'quick', label: 'Quick model' }, { id: 'deep', label: 'Deep model' }]" :attachments="route.query.files ? attachments : null" :surface-id="surface" :layout="compact ? 'compact' : 'page'" assistant-label="Fixture assistant" />
           <AssistantSurfaceClientElement v-if="second" surface-id="console" assistant-label="Second assistant" />
         </div>
       </div>

package/fixtures/conversation/vite.config.mjs

@@ -1,3 +1,4 @@
+import { createChatService } from "../../src/server/services/chatService.js";
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
 import { fileURLToPath } from "node:url";
@@ -10,15 +11,19 @@ export default defineConfig({
     configureServer(server) {
       const streams = [];
       const requests = [];
+      const transcript = [];
+      let realService = false;
       server.middlewares.use(async (req, res, next) => {
         const url = new URL(req.url, "http://fixture");
         if (!url.pathname.startsWith("/api/") && !url.pathname.startsWith("/fixture/")) return next();
         const json = (value) => { res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(value)); };
         const send = (stream, event) => stream.res.write(`${JSON.stringify(event)}\n`);
         if (url.pathname === "/api/session") return json({ csrfToken: "fixture-only" });
-        if (url.pathname === "/fixture/state") return json({ requests, streams: streams.map(({ closed }) => ({ closed })) });
+        if (url.pathname === "/fixture/service") { realService = true; return json({ ok: true }); }
+        if (url.pathname === "/fixture/state") return json({ requests, transcript, streams: streams.map(({ closed }) => ({ closed })) });
         if (url.pathname === "/fixture/next") {
           for (const stream of streams.filter((entry) => !entry.closed)) {
+            if (stream.advance) { stream.advance(url.searchParams); continue; }
             if (url.searchParams.has("fail")) {
               send(stream, { type: "error", message: "Fixture provider failed." });
               send(stream, { type: "done", status: "failed" });
@@ -43,6 +48,47 @@ export default defineConfig({
           const stream = { res, closed: false };
           streams.push(stream);
           res.on("close", () => { stream.closed = true; });
+          if (realService) {
+            const controller = new AbortController();
+            res.on("close", () => controller.abort());
+            let release;
+            const nextChunk = () => new Promise((resolve, reject) => {
+              release = resolve;
+              controller.signal.addEventListener("abort", () => reject(new Error("Stopped")), { once: true });
+            });
+            stream.advance = parameters => release(parameters);
+            const service = createChatService({
+              aiClientFactory: { async resolveClient(_surface, { integrationId }) {
+                return { enabled: true, provider: "fixture", defaultModel: integrationId, supportsAttachments: true,
+                  async *createChatCompletionStream({ messages }) {
+                    stream.receivedFiles = messages.at(-1).content;
+                    await nextChunk();
+                    yield { choices: [{ delta: { content: "Partial answer" } }] };
+                    await nextChunk();
+                    yield { choices: [{ delta: { content: " completed." } }] };
+                  }
+                };
+              } },
+              attachments: { async resolve({ attachmentIds }) {
+                return { attachments: attachmentIds.map(attachmentId => ({ attachmentId, fileName: "notes.txt", size: 5 })),
+                  content: [{ type: "text", text: "Uploaded notes" }] };
+              } },
+              transcriptService: {
+                async createConversationForTurn() { return { conversation: { id: "100" } }; },
+                async appendMessage(_surface, _id, message) { transcript.push(message); },
+                async completeConversation() {}
+              },
+              serviceToolCatalog: { resolveToolSet: () => ({ tools: [] }) },
+              assistantConfigService: { resolveSystemPrompt: async () => "Answer the user." },
+              appConfig: { surfaceDefinitions: { admin: { id: "admin", enabled: true, requiresWorkspace: false, accessPolicyId: "public" } },
+                assistantSurfaces: { admin: { settingsSurfaceId: "admin", configScope: "global" } } }
+            });
+            const streamWriter = Object.fromEntries(["sendMeta", "sendAssistantDelta", "sendAssistantMessage", "sendToolCall", "sendToolResult", "sendError", "sendDone"].map(method => [method, event => send(stream, event)]));
+            try { await service.streamChat({ ...payload, targetSurfaceId: "admin" }, { streamWriter, abortSignal: controller.signal, context: { actor: { id: "1" } } }); }
+            catch (error) { if (!res.destroyed) send(stream, { type: "error", message: error.message }); }
+            finally { res.end(); }
+            return;
+          }
           send(stream, { type: "meta", conversationId: payload.conversationId || "100" });
           send(stream, { type: "tool_call", toolCallId: "lookup", name: "Look up records", arguments: "never-render-this-payload" });
           return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.164",
+  "version": "0.1.166",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -11,15 +11,15 @@
     "./server/actionIds": "./src/server/actionIds.js"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.171",
-    "@jskit-ai/database-runtime": "0.1.193",
+    "@jskit-ai/assistant-core": "0.1.173",
+    "@jskit-ai/database-runtime": "0.1.195",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.191",
-    "@jskit-ai/http-web": "0.1.38",
-    "@jskit-ai/kernel": "0.1.193",
-    "@jskit-ai/shell-web": "0.1.197",
+    "@jskit-ai/http-runtime": "0.1.193",
+    "@jskit-ai/http-web": "0.1.40",
+    "@jskit-ai/kernel": "0.1.195",
+    "@jskit-ai/shell-web": "0.1.199",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"

package/patterns/assistant-surface/PATTERN.md

@@ -3,7 +3,7 @@ id: assistant/assistant-surface
 title: Assistant surface and settings
 summary: Configure an assistant runtime for one application surface and expose its chat and settings elements through ordinary pages and placements.
 keywords: ai, assistant, chat, config, environment, page, placement, settings, surface
-requires: @jskit-ai/assistant-runtime, @jskit-ai/shell-web
+requires: @jskit-ai/assistant-runtime, @jskit-ai/shell-web, @jskit-ai/connectors-catalog, @jskit-ai/connectors-core
 ---
 
 # Assistant surface and settings
@@ -32,7 +32,8 @@ in source or a questionnaire transcript.
 - Workspace configuration is used only when both surfaces require a workspace.
 - Each runtime surface appears once in `assistantSurfaces` and
   `assistantServer`.
-- The server config contains an environment prefix, never a credential value.
+- The server config selects an AI integration ID, never a credential value.
+- The application publishes an authorized `integrations.ai` resolver capability.
 - Runtime and settings pages use the public assistant elements.
 - Environment values are supplied through the application's normal secret
   environment boundary.
@@ -48,12 +49,16 @@ and `assistantServer` in server config.
 ## Example files
 
 `example/` contains concrete public/server config, assistant and settings pages,
-and semantic placements for an `admin` surface. Adapt the complete files to the
+semantic placements, an AI integration and its server resolver for an `admin` surface.
+Install `@jskit-ai/connectors-catalog` and `@jskit-ai/connectors-core` and register
+`ApplicationAiFeature` in the ordinary server feature list. Set its application ID
+and AI-use policy. The example explicitly selects the catalogue's no-key model;
+provider availability is independent of configuration. Adapt the complete files to the
 application's existing config and placement registries.
 
 ## Variation points
 
-Change surface ids, settings location, config scope, environment prefix, routes,
+Change surface ids, settings location, config scope, AI integration IDs, routes,
 labels, icons, and placement targets. A workspace-scoped application must retain
 the current workspace in both routes and assistant requests through the runtime's
 public workspace support.
@@ -92,3 +97,18 @@ workspace/surface aborts the local response and discards that view's state.
 Reopening restores saved history, not a live stream. Stop cannot guarantee that
 a server-side tool already running has stopped. Custom editor conversations
 should use their own adapter and keep their existing operation/storage owner.
+
+## Shared optional controls
+
+The shared status row shows “Assistant is working…” before output and answers
+stream as they arrive. Pass safe `connections: [{ id, label }]` with
+`v-model:integration-id` to offer the shared model chooser; list every selectable
+ID in server `aiIntegrationIds`. Use `configuration-mode="hidden"` for a supplied
+fixed connection or `readonly` to show its fixed choice.
+
+The optional `suggestions`, `attachments`, `goal` and `activity` props use the
+embeddable conversation contract. Goals are disabled unless a real backend
+scheduler is supplied. Suggestions use their own generator and agent policy.
+File bytes and upload authorization belong to the app's `assistant.attachments`
+resolver and upload routes. See the Assistant and Embeddable assistant
+conversations guides for exact callback shapes.

package/patterns/assistant-surface/example/config/server.js

@@ -1,7 +1,7 @@
 const config = {
   assistantServer: {
     admin: {
-      aiConfigPrefix: "ADMIN_ASSISTANT"
+      aiIntegrationId: "assistant"
     }
   }
 };

package/patterns/assistant-surface/example/integrations.json

@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "registrations": {},
+  "integrations": {
+    "assistant": {
+      "provider": "ai",
+      "accountMode": "shared",
+      "scopes": [],
+      "settings": {
+        "model": "opencode/big-pickle"
+      },
+      "authentication": {
+        "method": "none"
+      }
+    }
+  }
+}

package/patterns/assistant-surface/example/src/ApplicationAiFeature.js

@@ -0,0 +1,20 @@
+import { defineFeature } from "@jskit-ai/kernel/server/features";
+import { createAiConnectionResolver } from "@jskit-ai/connectors-catalog/server/ai";
+import { createEnvironmentReferenceResolver } from "@jskit-ai/connectors-core/server";
+import configuration from "../integrations.json" with { type: "json" };
+
+// Register this in the application's ordinary server feature list.
+export const ApplicationAiFeature = defineFeature({
+  id: "app.ai", requires: { env: "runtime.env" }, provides: { ai: "integrations.ai" },
+  setup({ env }) {
+    return { ai: createAiConnectionResolver({
+      configuration,
+      authorize(context) {
+        if (!context.actor?.id) return null;
+        // Apply the app's AI-use policy here; the actor comes from authentication.
+        return { applicationId: "my-app", subjectId: String(context.actor.id) };
+      },
+      resolveReference: createEnvironmentReferenceResolver(env)
+    }) };
+  }
+});

package/src/client/components/AssistantSurfaceClientElement.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { computed, onMounted, onScopeDispose, reactive, ref, toRef, watchPostEffect } from "vue";
+import { computed, onMounted, onScopeDispose, reactive, ref, toRef, watch, watchPostEffect } from "vue";
 import { AssistantConversationElement } from "@jskit-ai/assistant-core/client/conversation";
 import { useAssistantRuntime } from "../composables/useAssistantRuntime.js";
 import { mapAssistantConversationTurns } from "../support/assistantRuntimeState.js";
@@ -10,9 +10,18 @@ const props = defineProps({
   assistantLabel: { type: String, default: "Assistant" },
   welcomeMessage: { type: String, default: "What would you like to do?" },
   placeholder: { type: String, default: "Message the assistant…" },
-  showToolActivity: { type: Boolean, default: true }
+  showToolActivity: { type: Boolean, default: true },
+  connections: { type: Array, default: () => [] },
+  attachments: { type: Object, default: null },
+  suggestions: { type: Object, default: null },
+  goal: { type: Object, default: null },
+  activity: { type: Object, default: undefined },
+  configurationMode: { type: String, default: "editable", validator: value => ["hidden", "readonly", "editable"].includes(value) }
 });
-const runtime = useAssistantRuntime({ surfaceId: toRef(props, "surfaceId") });
+const integrationId = defineModel("integrationId", { type: String, default: "" });
+const draftIntegrationId = ref(integrationId.value);
+watch(integrationId, value => { draftIntegrationId.value = value; });
+const runtime = useAssistantRuntime({ surfaceId: toRef(props, "surfaceId"), integrationId });
 const state = reactive(runtime.state);
 const conversation = ref(null);
 const root = ref(null);
@@ -34,6 +43,20 @@ onMounted(() => {
 const selectedConversation = computed(() => state.conversationHistory.find((entry) => String(entry.id) === state.activeConversationId));
 const turns = computed(() => mapAssistantConversationTurns(state.messages, state.pendingToolEvents, props));
 const adapter = computed(() => ({
+  attachments: props.attachments,
+  suggestions: props.suggestions,
+  goal: props.goal,
+  activity: props.activity,
+  models: props.connections.length && props.configurationMode !== "hidden" ? {
+    providerRows: [{ id: "application", label: "Application AI" }],
+    modelProviderId: "application", modelRows: props.connections, modelId: draftIntegrationId.value,
+    selectionSummary: props.connections.find(connection => connection.id === integrationId.value)?.label || "Application default",
+    changesDisabled: props.configurationMode !== "editable" || state.isStreaming,
+    canSave: props.configurationMode === "editable" && !state.isStreaming && draftIntegrationId.value !== integrationId.value &&
+      props.connections.some(connection => connection.id === draftIntegrationId.value),
+    selectModel(value) { draftIntegrationId.value = value; },
+    apply() { integrationId.value = draftIntegrationId.value; }
+  } : null,
   conversation: {
     turns: turns.value,
     scrollKey: `${state.scopeKey}:${state.activeConversationId || "new"}`,
@@ -43,7 +66,8 @@ const adapter = computed(() => ({
   },
   composer: {
     draft: state.input,
-    canSend: state.canSend,
+    canSend: state.canSend || Boolean(props.attachments?.enabled !== false && props.attachments?.attachments?.length &&
+      !state.isStreaming && !state.isRestoringConversation && state.hasRuntimeScope),
     disabled: !state.hasRuntimeScope,
     canStop: state.isStreaming,
     stopPending: state.isCanceling,
@@ -55,7 +79,10 @@ const adapter = computed(() => ({
   },
   actions: {
     setDraft(value) { state.input = value; },
-    submit: runtime.actions.sendMessage,
+    submit: ({ attachments }) => runtime.actions.sendMessage({
+      attachments,
+      onAccepted: () => props.attachments?.clearAttachments({ accepted: true, attachmentIds: attachments.map(file => file.attachmentId) })
+    }),
     stop: runtime.actions.cancelStream
   }
 }));
@@ -96,11 +123,13 @@ defineExpose({ focus: () => conversation.value?.focus() });
       </v-menu>
     </div>
     <AssistantConversationElement ref="conversation" :adapter="adapter" label="Conversation" class="assistant-surface__conversation">
+      <template v-if="$slots.activity" #activity="scope"><slot name="activity" v-bind="scope" /></template>
+      <template v-if="$slots.attachments" #attachments="scope"><slot name="attachments" v-bind="scope" /></template>
       <template #message-actions="{ message }">
         <p v-if="message.status === 'failed' && message.error" class="assistant-surface__message-error" role="status">{{ message.error }}</p>
         <p v-if="message.status === 'interrupted'" class="assistant-surface__notice" role="status">Response canceled. A tool already running may still finish.</p>
       </template>
-      <template #hints>
+      <template #composer-feedback>
         <p v-if="state.error && !state.messages.some((message) => message.error === state.error)" class="assistant-surface__message-error" role="status">{{ state.error }}</p>
       </template>
       <template #composer-tools><slot name="composer-tools" :runtime="runtime" /></template>

package/src/client/composables/useAssistantRuntime.js

@@ -135,7 +135,7 @@ function createRuntimeApi({ overrideApi = null, resolveBasePath, resolveSurfaceI
   });
 }
 
-function useAssistantRuntime({ api = null, surfaceId = "" } = {}) {
+function useAssistantRuntime({ api = null, surfaceId = "", integrationId = "" } = {}) {
   const runtimePolicy = resolveRuntimePolicy();
   const queryClient = useQueryClient();
   const errorRuntime = useShellWebErrorRuntime();
@@ -425,8 +425,8 @@ function useAssistantRuntime({ api = null, surfaceId = "" } = {}) {
     abortController.value.abort();
   }
 
-  async function sendMessage() {
-    const normalizedInput = normalizeText(input.value).slice(0, MAX_INPUT_CHARS);
+  async function sendMessage({ attachments = [], onAccepted } = {}) {
+    const normalizedInput = normalizeText(input.value).slice(0, MAX_INPUT_CHARS) || (attachments.length ? "Please review the attached files." : "");
     if (!normalizedInput || isStreaming.value || isRestoringConversation.value || !hasRuntimeScope.value) {
       return;
     }
@@ -441,6 +441,7 @@ function useAssistantRuntime({ api = null, surfaceId = "" } = {}) {
       role: "user",
       kind: "chat",
       text: normalizedInput,
+      attachments,
       status: "done"
     });
 
@@ -472,6 +473,8 @@ function useAssistantRuntime({ api = null, surfaceId = "" } = {}) {
           messageId,
           ...(parsedConversationId ? { conversationId: parsedConversationId } : {}),
           input: normalizedInput,
+          ...(attachments.length ? { attachmentIds: attachments.map(file => file.attachmentId) } : {}),
+          ...(toValue(integrationId) ? { integrationId: toValue(integrationId) } : {}),
           history
         },
         {
@@ -481,6 +484,7 @@ function useAssistantRuntime({ api = null, surfaceId = "" } = {}) {
             const eventType = normalizeAssistantStreamEventType(event?.type, "");
 
             if (eventType === ASSISTANT_STREAM_EVENT_TYPES.META && Object.hasOwn(event || {}, "conversationId")) {
+              onAccepted?.();
               conversationId.value = normalizeRecordId(event?.conversationId, { fallback: null });
               writeStoredActiveConversationId(runtimeScope.value, conversationId.value);
               return;
@@ -503,7 +507,7 @@ function useAssistantRuntime({ api = null, surfaceId = "" } = {}) {
               const text = String(event?.text || "");
               updateMessage(assistantMessageId, {
                 text,
-                status: "done"
+                status: event.status === "streaming" ? "streaming" : "done"
               });
               return;
             }

package/src/client/support/assistantRuntimeState.js

@@ -60,7 +60,8 @@ function buildHistory(messages) {
     })
     .map((message) => ({
       role: message.role,
-      content: String(message.text || "").slice(0, MAX_INPUT_CHARS)
+      content: String(message.text || "").slice(0, MAX_INPUT_CHARS),
+      ...(message.role === "user" && message.attachments?.length ? { attachmentIds: message.attachments.map(file => file.attachmentId) } : {})
     }));
 
   return normalizedHistory.slice(-MAX_HISTORY_MESSAGES);
@@ -123,6 +124,7 @@ function mapTranscriptEntriesToAssistantState(entries) {
         role,
         kind: "chat",
         text,
+        ...(Array.isArray(metadata.attachments) ? { attachments: metadata.attachments } : {}),
         status: "done"
       });
       if (role === "user") {

package/src/server/AssistantProvider.js

@@ -1,6 +1,7 @@
 import { defineFeature } from "@jskit-ai/kernel/server/features";
 import { normalizeObject, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { createAiClient } from "@jskit-ai/assistant-core/server";
+import { AppError } from "@jskit-ai/kernel/server/runtime";
+import { createAiClient, createAiConnectionClient } from "@jskit-ai/assistant-core/server";
 import { createAssistantActions } from "./actions.js";
 import { registerRoutes } from "./registerRoutes.js";
 import { createRepository as createAssistantConfigRepository } from "./repositories/assistantConfigRepository.js";
@@ -9,7 +10,7 @@ import { createRepository as createMessagesRepository } from "./repositories/mes
 import { createService as createAssistantConfigService } from "./services/assistantConfigService.js";
 import { createChatService } from "./services/chatService.js";
 import { createTranscriptService } from "./services/transcriptService.js";
-import { resolveAssistantAiConfig } from "./support/assistantServerConfig.js";
+import { resolveAssistantAiConfig, resolveAssistantServerConfig } from "./support/assistantServerConfig.js";
 import { createSurfaceAwareToolCatalog } from "./support/createSurfaceAwareToolCatalog.js";
 
 function createAssistantAiClientFactory(config = {}) {
@@ -18,12 +19,24 @@ function createAssistantAiClientFactory(config = {}) {
   const cache = new Map();
 
   return Object.freeze({
-    resolveClient(targetSurfaceId = "") {
+    async resolveClient(targetSurfaceId = "", { context, integrationId } = {}) {
       const normalizedTargetSurfaceId = normalizeText(targetSurfaceId).toLowerCase();
       if (!normalizedTargetSurfaceId) {
         throw new Error("assistant.ai.client.factory.resolveClient requires targetSurfaceId.");
       }
 
+      const surfaceConfig = resolveAssistantServerConfig(appConfig, normalizedTargetSurfaceId);
+      if (surfaceConfig.aiIntegrationId) {
+        const selected = integrationId || surfaceConfig.aiIntegrationId;
+        if (![surfaceConfig.aiIntegrationId, ...surfaceConfig.aiIntegrationIds].includes(selected)) {
+          throw new AppError(403, "This AI connection is not available in this assistant.");
+        }
+        if (!config.aiConnections?.resolve) throw new Error("The assistant requires an authorized AI connection resolver.");
+        const connection = await config.aiConnections.resolve({ context, integrationId: selected });
+        return createAiConnectionClient(connection, { timeoutMs: surfaceConfig.timeoutMs });
+      }
+      if (integrationId) throw new AppError(403, "This assistant does not allow selecting an AI connection.");
+
       if (cache.has(normalizedTargetSurfaceId)) {
         return cache.get(normalizedTargetSurfaceId);
       }
@@ -48,13 +61,15 @@ function createAssistantRuntime({
   consoleRuntime,
   database,
   env,
+  aiConnections,
+  attachments,
   workspaces
 } = {}) {
   const assistantConfigRepository = createAssistantConfigRepository(database.knex);
   const conversationsRepository = createConversationsRepository(database.knex);
   const messagesRepository = createMessagesRepository(database.knex);
   const workspaceScopeSupport = workspaces?.scope || null;
-  const aiClientFactory = createAssistantAiClientFactory({ appConfig: config, env });
+  const aiClientFactory = createAssistantAiClientFactory({ appConfig: config, env, aiConnections });
   const toolCatalog = createSurfaceAwareToolCatalog(actionCatalogue, { appConfig: config });
   const configService = createAssistantConfigService({
     assistantConfigRepository,
@@ -64,6 +79,7 @@ function createAssistantRuntime({
   });
   const transcriptService = createTranscriptService({ conversationsRepository, messagesRepository });
   const chatService = createChatService({
+    attachments,
     aiClientFactory,
     transcriptService,
     serviceToolCatalog: toolCatalog,
@@ -94,6 +110,8 @@ const AssistantFeature = defineFeature({
     http: "runtime.http"
   },
   optional: {
+    aiConnections: "integrations.ai",
+    attachments: "assistant.attachments",
     consoleRuntime: "console.core",
     workspaces: "workspaces.core"
   },

package/src/server/services/chatService.js

@@ -38,7 +38,8 @@ function normalizeHistory(history = []) {
 
       return {
         role,
-        content
+        content,
+        attachmentIds: role === "user" ? item.attachmentIds : []
       };
     })
     .filter(Boolean);
@@ -71,6 +72,7 @@ function normalizeStreamInput(payload = {}) {
     messageId,
     conversationId: normalizeConversationId(source.conversationId),
     input,
+    attachmentIds: source.attachmentIds,
     history: normalizeHistory(source.history)
   };
 }
@@ -296,10 +298,10 @@ function sanitizeAssistantMessageText(value) {
   }
 
   const blockPatterns = [
-    /<[^>\n]*function_calls[^>\n]*>[\s\S]*?<\/[^>\n]*function_calls>/gi,
-    /<[^>\n]*tool_calls?[^>\n]*>[\s\S]*?<\/[^>\n]*tool_calls?[^>\n]*>/gi,
-    /<[^>\n]*invoke\b[^>\n]*>[\s\S]*?<\/[^>\n]*invoke>/gi,
-    /<(?:analysis|reasoning|think)>[\s\S]*?<\/(?:analysis|reasoning|think)>/gi
+    /<[^>\n]*function_calls[^>\n]*>[\s\S]*?(?:<\/[^>\n]*function_calls>|$)/gi,
+    /<[^>\n]*tool_calls?[^>\n]*>[\s\S]*?(?:<\/[^>\n]*tool_calls?[^>\n]*>|$)/gi,
+    /<[^>\n]*invoke\b[^>\n]*>[\s\S]*?(?:<\/[^>\n]*invoke>|$)/gi,
+    /<(?:analysis|reasoning|think)>[\s\S]*?(?:<\/(?:analysis|reasoning|think)>|$)/gi
   ];
   for (const pattern of blockPatterns) {
     source = source.replace(pattern, " ");
@@ -380,7 +382,7 @@ function parseDsmlToolCallsFromText(value = "") {
   return calls;
 }
 
-async function consumeCompletionStream(stream) {
+async function consumeCompletionStream(stream, onText = () => {}) {
   let assistantText = "";
   const toolCallsByIndex = new Map();
 
@@ -391,6 +393,11 @@ async function consumeCompletionStream(stream) {
     const textDelta = extractTextDelta(delta.content);
     if (textDelta) {
       assistantText += textDelta;
+      // An opening provider tag can be split between chunks. Keep it private
+      // until its boundary is known; complete internal blocks are stripped below.
+      const tagStart = assistantText.lastIndexOf("<");
+      const safeText = tagStart > assistantText.lastIndexOf(">") ? assistantText.slice(0, tagStart) : assistantText;
+      onText(sanitizeAssistantMessageText(safeText));
     }
 
     const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
@@ -456,6 +463,7 @@ function buildAssistantActionContext(context = {}, assistantSurface = {}) {
 
 function createChatService({
   aiClientFactory,
+  attachments,
   transcriptService,
   serviceToolCatalog,
   assistantConfigService,
@@ -486,14 +494,16 @@ function createChatService({
 
   async function streamChat(payload = {}, options = {}) {
     const assistantSurface = requireAssistantSurface(resolveCurrentAppConfig(), payload?.targetSurfaceId);
-    const aiClient = aiClientFactory.resolveClient(assistantSurface.targetSurfaceId);
+    const context = normalizeObject(options.context);
+    const assistantContext = buildAssistantActionContext(context, assistantSurface);
+    const workspace = resolveRuntimeWorkspace(assistantSurface, assistantContext, payload);
+    const aiClient = await aiClientFactory.resolveClient(assistantSurface.targetSurfaceId, {
+      context: assistantContext, integrationId: payload.integrationId
+    });
     if (!aiClient.enabled) {
       throw new AppError(503, "Assistant provider is not configured.");
     }
 
-    const context = normalizeObject(options.context);
-    const assistantContext = buildAssistantActionContext(context, assistantSurface);
-    const workspace = resolveRuntimeWorkspace(assistantSurface, assistantContext, payload);
     const source = normalizeStreamInput(payload);
     const streamWriter = options.streamWriter;
     if (!hasStreamWriter(streamWriter)) {
@@ -524,6 +534,27 @@ function createChatService({
       throw new AppError(500, "Assistant failed to create conversation.");
     }
 
+    async function resolveFiles(attachmentIds) {
+      if (attachmentIds === undefined || (Array.isArray(attachmentIds) && !attachmentIds.length)) return { attachments: [], content: [] };
+      if (!Array.isArray(attachmentIds) || attachmentIds.length > 10 ||
+          attachmentIds.some(id => typeof id !== "string" || !id || id.length > 256)) {
+        throw new AppError(400, "Invalid attachment identifiers.");
+      }
+      if (!attachments?.resolve || !aiClient.supportsAttachments) {
+        throw new AppError(400, "File attachments are not configured for this assistant.");
+      }
+      // Only the application can authorize uploads and turn stored bytes into
+      // provider input. Browser-supplied paths, URLs and file contents are never used.
+      return attachments.resolve({ attachmentIds, context: assistantContext, workspace, conversation });
+    }
+    const files = await resolveFiles(source.attachmentIds);
+    const history = [];
+    for (const message of source.history) {
+      const previousFiles = await resolveFiles(message.attachmentIds);
+      history.push({ role: message.role, content: previousFiles.content.length
+        ? [{ type: "text", text: message.content }, ...previousFiles.content] : message.content });
+    }
+
     await transcriptService.appendMessage(
       assistantSurface,
       conversationId,
@@ -533,7 +564,8 @@ function createChatService({
         clientMessageSid: source.messageId,
         contentText: source.input,
         metadata: {
-          surfaceId: assistantSurface.targetSurfaceId
+          surfaceId: assistantSurface.targetSurfaceId,
+          ...(files.attachments.length ? { attachments: files.attachments } : {})
         }
       },
       {
@@ -566,10 +598,10 @@ function createChatService({
         role: "system",
         content: systemPrompt
       },
-      ...source.history,
+      ...history,
       {
         role: "user",
-        content: source.input
+        content: files.content.length ? [{ type: "text", text: source.input }, ...files.content] : source.input
       }
     ];
 
@@ -623,6 +655,23 @@ function createChatService({
       };
     }
 
+    let displayedText = "";
+    async function consumeResponse(stream) {
+      if (displayedText) {
+        streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text: "", status: "streaming" });
+        displayedText = "";
+      }
+      return consumeCompletionStream(stream, text => {
+        if (text === displayedText) return;
+        if (text.startsWith(displayedText)) {
+          streamWriter.sendAssistantDelta({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_DELTA, delta: text.slice(displayedText.length) });
+        } else {
+          streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text, status: "streaming" });
+        }
+        displayedText = text;
+      });
+    }
+
     async function executeToolCalls(toolCalls = [], { toolFailures = [], toolSuccesses = [] } = {}) {
       const roundFailures = [];
 
@@ -745,7 +794,7 @@ function createChatService({
           tools: [],
           signal: options.abortSignal
         });
-        const completion = await consumeCompletionStream(completionStream);
+        const completion = await consumeResponse(completionStream);
 
         const recoveryToolCalls = completion.toolCalls.filter((entry) => entry.name);
         if (recoveryToolCalls.length > 0) {
@@ -824,7 +873,7 @@ function createChatService({
           signal: options.abortSignal
         });
 
-        const completion = await consumeCompletionStream(completionStream);
+        const completion = await consumeResponse(completionStream);
 
         const toolCalls = completion.toolCalls.filter((entry) => entry.name);
         if (toolCalls.length < 1) {

package/src/server/support/assistantServerConfig.js

@@ -18,6 +18,8 @@ function resolveAssistantServerConfigMap(appConfig = {}) {
     }
 
     resolved[targetSurfaceId] = Object.freeze({
+      aiIntegrationId: normalizeText(entry.aiIntegrationId),
+      aiIntegrationIds: Object.freeze(normalizeUniqueTextList(entry.aiIntegrationIds)),
       aiConfigPrefix: normalizeText(entry.aiConfigPrefix),
       provider: normalizeText(entry.provider).toLowerCase(),
       apiKey: normalizeText(entry.apiKey),

package/test/aiConnections.test.js

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createAiConnectionResolver } from "../../connectors-catalog/src/server/ai.js";
+import { createAssistantAiClientFactory } from "../src/server/AssistantProvider.js";
+
+test("assistant connections authorize each request and resolve rotated and individual credentials afresh", async t => {
+  const keys = { alice: "alice-first", bob: "bob-only" };
+  const authorized = [];
+  const usedKeys = [];
+  const aiConnections = createAiConnectionResolver({
+    configuration: { schemaVersion: 1, registrations: {}, integrations: {
+      chat: { provider: "ai", accountMode: "per-user", scopes: [],
+        settings: { model: "openai/gpt-4.1-mini" }, authentication: { method: "api-key", secretRef: "account:chat" } }
+    } },
+    authorize(context, request) {
+      authorized.push([context.actor.id, request.integrationId]);
+      return context.actor.id === "denied" ? null : { applicationId: "example", subjectId: context.actor.id };
+    },
+    resolveReference(_reference, owner) { return keys[owner.subjectId]; }
+  });
+  t.mock.method(globalThis, "fetch", async (_url, options) => {
+    usedKeys.push(new Headers(options.headers).get("authorization"));
+    return new Response([
+      { type: "response.output_item.added", output_index: 0, item: { type: "message", id: "msg_1" } },
+      { type: "response.output_text.delta", item_id: "msg_1", output_index: 0, content_index: 0, delta: "Ready" },
+      { type: "response.completed", response: { id: "resp_1", created_at: 1, model: "gpt-4.1-mini", status: "completed", output: [], usage: { input_tokens: 1, output_tokens: 1 } } }
+    ].map(data => `data: ${JSON.stringify(data)}\n\n`).join(""), { headers: { "content-type": "text/event-stream" } });
+  });
+  const factory = createAssistantAiClientFactory({
+    appConfig: { assistantServer: { admin: { aiIntegrationId: "chat" } } }, aiConnections
+  });
+  async function run(id) {
+    const client = await factory.resolveClient("admin", { context: { actor: { id } } });
+    return Array.fromAsync(client.createChatCompletionStream({ messages: [{ role: "user", content: "Hi" }] }));
+  }
+  await run("alice");
+  keys.alice = "alice-rotated";
+  await run("alice");
+  await run("bob");
+  assert.deepEqual(usedKeys, ["Bearer alice-first", "Bearer alice-rotated", "Bearer bob-only"]);
+  delete keys.alice;
+  await assert.rejects(run("alice"), /API key is unavailable/u);
+  await assert.rejects(run("denied"), /denied/u);
+  await assert.rejects(factory.resolveClient("admin", { context: { actor: { id: "bob" } }, integrationId: "not-allowed" }), /not available/u);
+  assert.deepEqual(authorized, [["alice", "chat"], ["alice", "chat"], ["bob", "chat"], ["alice", "chat"], ["denied", "chat"]]);
+  assert.equal(usedKeys.length, 3);
+});
+
+test("existing explicit environment configuration remains available and rejects connection overrides", async () => {
+  const factory = createAssistantAiClientFactory({
+    appConfig: { assistantServer: { admin: { aiConfigPrefix: "ADMIN" } } },
+    env: { ADMIN_AI_PROVIDER: "openai", ADMIN_AI_API_KEY: "test-key", ADMIN_AI_MODEL: "chosen-model" }
+  });
+  const first = await factory.resolveClient("admin");
+  assert.equal(first.defaultModel, "chosen-model");
+  assert.equal(await factory.resolveClient("admin"), first);
+  await assert.rejects(factory.resolveClient("admin", { integrationId: "chat" }), /does not allow/u);
+});

package/test/assistantServerConfig.test.js

@@ -32,6 +32,8 @@ test("assistant server config resolves per-surface AI config without app-level g
   };
 
   assert.deepEqual(resolveAssistantServerConfig(appConfig, "admin"), {
+    aiIntegrationId: "",
+    aiIntegrationIds: [],
     aiConfigPrefix: "ADMIN_ASSISTANT",
     provider: "anthropic",
     apiKey: "config-key",

package/test/assistantSurfacePattern.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import { readFile } from "node:fs/promises";
 import test from "node:test";
+import { createAssistantAiClientFactory } from "../src/server/AssistantProvider.js";
 import { parse as parseSfc } from "@vue/compiler-sfc";
 
 const exampleRoot = new URL("../patterns/assistant-surface/example/", import.meta.url);
@@ -18,7 +19,14 @@ test("assistant surface pattern keeps product config explicit and secrets extern
     settingsSurfaceId: "admin",
     configScope: "global"
   });
-  assert.equal(serverConfig.assistantServer.admin.aiConfigPrefix, "ADMIN_ASSISTANT");
+  assert.equal(serverConfig.assistantServer.admin.aiIntegrationId, "assistant");
+  const { ApplicationAiFeature } = await import(new URL("src/ApplicationAiFeature.js", exampleRoot));
+  const { ai } = await ApplicationAiFeature.setup({ env: {} });
+  await assert.rejects(ai.resolve({ context: {}, integrationId: "assistant" }));
+  const client = await createAssistantAiClientFactory({ appConfig: serverConfig, env: {}, aiConnections: ai })
+    .resolveClient("admin", { context: { actor: { id: "fixture-user" } } });
+  assert.equal(client.enabled, true);
+  assert.equal(client.defaultModel, "big-pickle");
   assert.doesNotMatch(JSON.stringify({ publicConfig, serverConfig }), /api[_-]?key|secret/iu);
   assert.doesNotMatch(placementSource, /generator|scaffold|receipt|provenance/u);
 

package/test/chatServiceLifecycle.test.js

@@ -69,7 +69,7 @@ async function* completionStream(completion = {}) {
   }
 }
 
-function createHarness(completions, { executeToolCall = null, tools: configuredTools = null } = {}) {
+function createHarness(completions, { executeToolCall = null, tools: configuredTools = null, attachments, supportsAttachments = true } = {}) {
   const pendingCompletions = [...completions];
   const completionRequests = [];
   const transcriptMessages = [];
@@ -89,10 +89,12 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
       }));
 
   const chatService = createChatService({
+    attachments,
     aiClientFactory: {
       resolveClient() {
         return {
           enabled: true,
+          supportsAttachments,
           provider: "test",
           defaultModel: "test-model",
           async createChatCompletionStream(request) {
@@ -102,7 +104,7 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
             });
             const completion = pendingCompletions.shift();
             assert.ok(completion, "Expected a queued assistant completion.");
-            return completionStream(completion);
+            return completion[Symbol.asyncIterator] ? completion : completionStream(completion);
           }
         };
       }
@@ -172,13 +174,14 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
     };
   }
 
-  async function run(input = "Help me") {
+  async function run(input = "Help me", payload = {}) {
     return chatService.streamChat(
       {
         targetSurfaceId: "assistant",
         messageId: "message_1",
         input,
-        history: []
+        history: [],
+        ...payload
       },
       {
         context: {
@@ -203,7 +206,7 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
 
 function assistantMessages(events) {
   return events
-    .filter((event) => event.method === "sendAssistantMessage")
+    .filter((event) => event.method === "sendAssistantMessage" && event.payload.status !== "streaming")
     .map((event) => event.payload.text);
 }
 
@@ -255,7 +258,7 @@ test("an empty authorized tool set does not advertise discovery or collection ac
   assert.doesNotMatch(request.messages[0].content, /assistant_action_search|collection action/u);
 });
 
-test("progress-only output is retried silently and current-time prompts require a workspace clock", async () => {
+test("progress-only output is replaced on retry and current-time prompts require a workspace clock", async () => {
   const harness = createHarness(
     [
       textCompletion("Let me query the current time."),
@@ -295,7 +298,7 @@ test("progress-only output is retried silently and current-time prompts require
     true
   );
   assert.deepEqual(assistantMessages(harness.streamEvents), ["It is Tuesday in the workspace timezone."]);
-  assert.equal(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"), false);
+  assert.ok(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"));
   assert.match(
     harness.completionRequests[0].messages[0].content,
     /first use any available authoritative workspace clock action/u
@@ -360,7 +363,7 @@ test("current-time preflight does not invent required tool input", async () => {
   assert.deepEqual(assistantMessages(harness.streamEvents), ["Choose a timezone before asking for its local time."]);
 });
 
-test("native search, contract, and execution workflows can exceed four silent tool rounds", async () => {
+test("native search, contract, and execution workflows stream progress across more than four tool rounds", async () => {
   const harness = createHarness([
     toolCompletion("action_search", 1, { text: "I'll search first." }),
     toolCompletion("action_contract", 2, { text: "Let me inspect that contract." }),
@@ -377,7 +380,7 @@ test("native search, contract, and execution workflows can exceed four silent to
     ["action_search", "action_contract", "action_execute", "action_contract", "action_execute"]
   );
   assert.deepEqual(assistantMessages(harness.streamEvents), ["The requested operation completed successfully."]);
-  assert.equal(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"), false);
+  assert.ok(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"));
   const assistantToolMessages = harness.completionRequests
     .flatMap((request) => request.messages)
     .filter((message) => Array.isArray(message.tool_calls));
@@ -415,7 +418,7 @@ test("tool-loop exhaustion gives the concise new-conversation instruction", asyn
   assert.equal(harness.executedTools.length, 16);
   assert.equal(harness.completionRequests.length, 19);
   assert.deepEqual(finalMessages, ["Limit reached. Start a new conversation."]);
-  assert.equal(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"), false);
+  assert.ok(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"));
 });
 
 test("tool-failure recovery retains the bounded latest successful result", async () => {
@@ -461,3 +464,72 @@ test("tool-failure recovery retains the bounded latest successful result", async
   assert.match(fallback, /…\[truncated\]$/u);
   assert.doesNotMatch(fallback, /Limit reached/u);
 });
+
+
+test("answer text reaches the client before the provider finishes, then persists once", async () => {
+  const firstChunk = Promise.withResolvers();
+  const continueResponse = Promise.withResolvers();
+  async function* response() {
+    yield { choices: [{ delta: { content: "The first sentence." } }] };
+    firstChunk.resolve();
+    await continueResponse.promise;
+    yield { choices: [{ delta: { content: " The second sentence." } }] };
+  }
+  const harness = createHarness([response()]);
+  const running = harness.run();
+  await firstChunk.promise;
+  try {
+    assert.deepEqual(harness.streamEvents.filter(event => event.method === "sendAssistantDelta").map(event => event.payload.delta), ["The first sentence."]);
+    assert.deepEqual(harness.completedConversations, []);
+    assert.deepEqual(harness.transcriptMessages.filter(message => message.role === "assistant"), []);
+  } finally {
+    continueResponse.resolve();
+  }
+  await running;
+  assert.deepEqual(harness.streamEvents.filter(event => event.method === "sendAssistantDelta").map(event => event.payload.delta), ["The first sentence.", " The second sentence."]);
+  assert.deepEqual(assistantMessages(harness.streamEvents), ["The first sentence. The second sentence."]);
+  assert.deepEqual(harness.transcriptMessages.filter(message => message.role === "assistant").map(message => message.contentText), ["The first sentence. The second sentence."]);
+});
+
+test("split internal tags and tool arguments never become answer deltas", async () => {
+  async function* response() {
+    for (const content of ["<th", "ink>private reasoning", "</thi", "nk>", "<｜DSML｜function_", "calls><｜DSML｜invoke name=\"action_search\">", '{"secret":"private arguments"}', "</｜DSML｜invoke></｜DSML｜function_calls>"]) {
+      yield { choices: [{ delta: { content } }] };
+    }
+  }
+  const harness = createHarness([response(), textCompletion("The search is complete.")]);
+  await harness.run();
+  assert.deepEqual(harness.executedTools.map(request => request.toolName), ["action_search"]);
+  assert.deepEqual(harness.streamEvents.filter(event => event.method === "sendAssistantDelta").map(event => event.payload.delta), ["The search is complete."]);
+  assert.deepEqual(assistantMessages(harness.streamEvents), ["The search is complete."]);
+});
+
+
+test("application-authorized attachments reach the model and survive transcript restore", async () => {
+  const calls = [];
+  const receipt = { attachmentId: "file-one", fileName: "notes.txt", size: 12 };
+  const attachments = { async resolve(request) {
+    calls.push(request);
+    assert.equal(request.context.actor.id, "user_1");
+    assert.equal(request.conversation.id, "conversation_1");
+    if (request.attachmentIds[0] !== "file-one") throw new Error("Attachment access denied");
+    return { attachments: [receipt], content: [{ type: "text", text: "Authorized file bytes" }] };
+  } };
+  const harness = createHarness([textCompletion("I read your notes.")], { attachments });
+  await harness.run("Read this", { attachmentIds: ["file-one"], history: [
+    { role: "user", content: "Previous file", attachmentIds: ["file-one"] }
+  ] });
+  assert.equal(calls.length, 2, "Both current and historical files must be authorized");
+  assert.deepEqual(harness.transcriptMessages[0].metadata.attachments, [receipt]);
+  assert.deepEqual(harness.completionRequests[0].messages.at(-1).content, [
+    { type: "text", text: "Read this" }, { type: "text", text: "Authorized file bytes" }
+  ]);
+  const denied = createHarness([textCompletion("Must not run")], { attachments });
+  await assert.rejects(denied.run("Read this", { attachmentIds: ["another-users-file"] }), /access denied/);
+  assert.deepEqual(denied.completionRequests, []);
+  assert.deepEqual(denied.transcriptMessages, []);
+  const disabled = createHarness([textCompletion("Must not run")]);
+  await assert.rejects(disabled.run("Read this", { attachmentIds: ["file-one"] }), /not configured/);
+  const legacy = createHarness([textCompletion("Must not run")], { attachments, supportsAttachments: false });
+  await assert.rejects(legacy.run("Read this", { attachmentIds: ["file-one"] }), /not configured/);
+});

package/test/conversation.browser.test.js

@@ -258,3 +258,44 @@ test("page assistant bounds long history in a document layout and preserves draf
     await stopProcess(vite);
   }
 });
+
+
+test("the ready-made UI streams from the real chat service with selected AI connections and files", {
+  skip: process.env.JSKIT_ASSISTANT_RUNTIME_BROWSER_INTEGRATION !== "1", timeout: 90_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  const page = await browser.newPage({ viewport: { width: 1100, height: 800 } });
+  try {
+    await page.request.get(`${vite.baseURL}/fixture/service`);
+    await page.goto(`${vite.baseURL}/?files=1`);
+    const input = page.getByRole("textbox", { name: "Message AI assistant" });
+    await expect(input).toBeEnabled();
+    await page.getByRole("button", { name: "Choose AI", exact: true }).click();
+    await page.getByRole("button", { name: "Deep model", exact: true }).click();
+    await page.getByRole("button", { name: "Apply", exact: true }).click();
+    await page.locator('input[type="file"]').setInputFiles({ name: "notes.txt", mimeType: "text/plain", buffer: Buffer.from("notes") });
+    await expect(page.getByText("notes.txt", { exact: true })).toBeVisible();
+    await input.fill("Read the notes");
+    await input.press("Enter");
+    await expect(page.getByText("Assistant is working…", { exact: true }).last()).toBeVisible();
+    await expect(page.getByLabel("Message attachments")).toHaveCount(0);
+    await expect(page.getByLabel("Attached files")).toBeVisible();
+    await input.fill("My next draft");
+    await input.evaluate(element => element.setSelectionRange(3, 7));
+    await page.request.get(`${vite.baseURL}/fixture/next`);
+    await expect(page.getByText("Partial answer", { exact: true })).toBeVisible();
+    await expect(input).toHaveValue("My next draft");
+    assert.deepEqual(await input.evaluate(element => [element.selectionStart, element.selectionEnd]), [3, 7]);
+    let state = await (await page.request.get(`${vite.baseURL}/fixture/state`)).json();
+    assert.equal(state.requests[0].integrationId, "deep");
+    assert.deepEqual(state.requests[0].attachmentIds, ["fixture-file"]);
+    assert.equal(state.transcript.filter(message => message.role === "assistant").length, 0);
+    await page.request.get(`${vite.baseURL}/fixture/next?finish=1`);
+    await expect(page.getByText("Partial answer completed.", { exact: true })).toHaveCount(1);
+    await expect(page.getByText("Assistant is working…", { exact: true })).toHaveCount(0);
+    state = await (await page.request.get(`${vite.baseURL}/fixture/state`)).json();
+    assert.deepEqual(state.transcript[0].metadata.attachments, [{ attachmentId: "fixture-file", fileName: "notes.txt", size: 5 }]);
+    assert.equal(state.transcript.filter(message => message.role === "assistant").length, 1);
+  } finally { await browser.close(); await stopProcess(vite); }
+});