@jskit-ai/assistant-runtime 0.1.192 → 0.1.194

package/fixtures/canonical-conversation/App.vue

@@ -0,0 +1,188 @@
+<script setup>
+import { computed, defineComponent, effectScope, inject, nextTick, onMounted, onScopeDispose, ref, shallowRef } from "vue";
+import { useAssistantAttachments } from "@jskit-ai/assistant-core/client/conversation-attachments";
+import { useAssistantSuggestions } from "@jskit-ai/assistant-core/client/conversation-suggestions";
+import AssistantConversationClientElement from "../../src/client/components/AssistantConversationClientElement.vue";
+import { useAssistantConversation, useAssistantConversationFactory } from "../../src/client/composables/useAssistantConversation.js";
+import DraftConversation from "./DraftConversation.vue";
+
+const { placement, socket } = inject("fixture");
+const factoryScope = effectScope();
+const acquireConversation = factoryScope.run(() => useAssistantConversationFactory());
+const fixtureOptions = new URLSearchParams(window.location.search);
+const conversationId = ref(fixtureOptions.has("unresolved") ? "" : "chat:1");
+const visible = ref(true);
+const multiple = ref(false);
+const mirror = ref(false);
+const conversation = ref(null);
+const voice = shallowRef(null);
+const acceptedDraft = fixtureOptions.has("acceptedDraft");
+const draftWhileLoading = fixtureOptions.has("draftWhileLoading");
+const presentation = ref({});
+const dispatches = [];
+const recordDispatch = messageId => dispatches.push(messageId);
+const eventReaders = ref([]);
+const readerEvents = [];
+const EventReader = defineComponent({
+  props: { reader: { type: Object, required: true } },
+  setup(props) {
+    const binding = useAssistantConversation({
+      conversationId, active: () => props.reader.active !== false,
+      goal: () => props.reader.goal === true,
+      onEvent(event) {
+        const streaming = binding.runtime.value?.snapshot.value?.streaming;
+        readerEvents.push({ reader: props.reader.id, type: event.type, marker: event.marker,
+          revision: streaming?.revision ?? null, text: streaming?.messages.at(-1)?.text || "" });
+        if (props.reader.id === "first" && event.failure === "throw") throw new Error("Fixture presentation failed.");
+        if (props.reader.id === "first" && event.failure === "reject") return Promise.reject(new Error("Fixture refresh failed."));
+      }
+    });
+    return () => null;
+  }
+});
+const authoredData = ref(undefined);
+const attachmentsEnabled = ref(false);
+const attachmentActor = ref("42");
+const uploads = [];
+const deleted = [];
+const acknowledged = [];
+const heldUploads = [];
+const attachments = useAssistantAttachments({
+  sessionId: computed(() => `${attachmentActor.value}/${conversationId.value}`),
+  canUpload: attachmentsEnabled,
+  uploadAttachment(sessionId, file, { onProgress }) {
+    const receipt = { attachmentId: crypto.randomUUID(), fileName: file.name, size: file.size, sessionId };
+    uploads.push({ sessionId, fileName: file.name, attachmentId: receipt.attachmentId });
+    onProgress({ bytesSent: file.size / 2, totalBytes: file.size });
+    if (file.name.startsWith("held-")) return new Promise(resolve => heldUploads.push(() => resolve(receipt)));
+    return Promise.resolve(receipt);
+  },
+  deleteAttachment(sessionId, attachmentId) { deleted.push({ sessionId, attachmentId }); return { ok: true }; }
+});
+const clearAttachments = attachments.clearAttachments;
+attachments.clearAttachments = options => {
+  acknowledged.push([...options.attachmentIds]);
+  return clearAttachments(options);
+};
+const suggestionsEnabled = ref(false);
+const suggestionMode = ref("ready");
+const suggestionModel = ref("suggestions-small");
+const suggestionRequests = [];
+const target = computed(() => conversation.value?.runtime || null);
+const modelsEnabled = ref(false);
+const modelId = ref("small");
+const appliedModel = ref("small");
+const modelSaving = ref(false);
+const modelCatalogError = ref("");
+const modelSelections = [];
+const modelChangesDisabled = computed(() => target.value?.snapshot.value?.status === "working");
+let finishModelApply;
+const models = {
+  providerRows: computed(() => [{ id: "application", label: "Application choices" }]),
+  modelProviderId: ref("application"),
+  modelRows: computed(() => [{ id: "small", label: "Small model" }, { id: "large", label: "Large model" }]),
+  modelId, selectionSummary: computed(() => `Selected ${appliedModel.value}`),
+  changesDisabled: modelChangesDisabled,
+  canSave: computed(() => !modelChangesDisabled.value && !modelCatalogError.value && modelId.value !== appliedModel.value), saving: modelSaving,
+  catalogLoading: ref(false), catalogError: modelCatalogError,
+  selectModel(value) { modelId.value = value; },
+  async apply() {
+    const selected = modelId.value;
+    modelSelections.push(selected);
+    modelSaving.value = true;
+    await new Promise(resolve => { finishModelApply = resolve; });
+    appliedModel.value = selected;
+    modelSaving.value = false;
+  },
+  reload() { modelCatalogError.value = ""; }
+};
+const questions = ref(false);
+const suggestions = useAssistantSuggestions({
+  active: () => Boolean(suggestionsEnabled.value && visible.value && target.value?.available.value &&
+    target.value.snapshot.value?.status === "ready"),
+  requestKey: () => target.value?.identity || null,
+  draft: () => target.value?.draft.value || "",
+  configuration: () => ({ integrationId: "suggestions", model: suggestionModel.value }),
+  debounceMs: 0,
+  generate(input) {
+    const request = { ...input, target: { ...target.value.identity } };
+    suggestionRequests.push(request);
+    if (suggestionMode.value === "hold") return new Promise(resolve => { request.resolve = resolve; });
+    return [{ label: "Suggested next step", prompt: `Suggested by ${input.configuration.model}` }];
+  },
+  onSelect(prompt) {
+    if (!target.value?.available.value) return false;
+    target.value.draft.value = prompt;
+    return true;
+  }
+});
+let retained;
+onMounted(() => {
+  window.conversationFixture = {
+    socket,
+    acquireConversation,
+    releaseFactory() { factoryScope.stop(); },
+    target(id) { conversationId.value = id; },
+    show(value) { visible.value = value; },
+    multiple(value) { multiple.value = value; },
+    mirror(value) { mirror.value = value; },
+    async eventReaders(value) { eventReaders.value = value; await nextTick(); },
+    readerEvents() { return [...readerEvents]; },
+    actor(id) { placement.setContext({ user: id ? { id } : null }); attachmentActor.value = id; },
+    current() { return conversation.value?.runtime; },
+    presentation(value) { presentation.value = value; },
+    adapter() { return conversation.value?.adapter; },
+    submit() { return conversation.value.submit(); },
+    dispatches() { return [...dispatches]; },
+    retainVoice() { retained?.release(); retained = conversation.value.runtime.retain(); voice.value = retained.runtime; },
+    releaseVoice() { retained?.release(); retained = null; voice.value = null; },
+    sendVoice(text, data) { return voice.value.send({ message: text, ...(data !== undefined ? { data } : {}) }); },
+    data(value) { authoredData.value = value; },
+    changeFocus(value) { authoredData.value.focus = value; },
+    attachments(enabled) { attachmentsEnabled.value = enabled; },
+    finishUploads() { for (const resolve of heldUploads.splice(0)) resolve(); },
+    suggestions(enabled, mode = "ready") { suggestionMode.value = mode; suggestionsEnabled.value = enabled; },
+    questions(options) { questions.value = options; },
+    models(enabled) { modelsEnabled.value = enabled; },
+    modelError(message) { modelCatalogError.value = message; },
+    finishModelApply() { finishModelApply?.(); finishModelApply = null; },
+    modelState() { return { selected: modelId.value, applied: appliedModel.value, saving: modelSaving.value, selections: [...modelSelections] }; },
+    suggestionModel(value) { suggestionModel.value = value; },
+    resolveSuggestion(index, prompt) { suggestionRequests[index]?.resolve?.([{ label: "Suggested next step", prompt }]); },
+    suggestionState() { return { items: suggestions.items.value, preview: suggestions.preview.value,
+      requests: suggestionRequests.map(({ target, draft, configuration, signal }) => ({ target, draft, configuration, aborted: signal.aborted })) }; },
+    attachmentState() { return { ready: attachments.attachments.value.map(file => ({ ...file })),
+      queue: attachments.queueItems.value.map(row => ({ fileName: row.fileName, phase: row.phase })),
+      uploads, deleted, acknowledged }; },
+    voiceState() { return voice.value && { current: voice.value.current.value, available: voice.value.available.value,
+      id: voice.value.identity.conversationId, draft: voice.value.draft.value, turns: voice.value.delivery.turns(voice.value.turns.value) }; }
+  };
+});
+onScopeDispose(() => retained?.release());
+</script>
+
+<template>
+  <v-app>
+    <main class="fixture">
+      <EventReader v-for="eventReader in eventReaders" :key="eventReader.id" :reader="eventReader" />
+      <div v-if="visible" class="fixture__conversation" data-primary>
+        <DraftConversation v-if="acceptedDraft" ref="conversation" :conversation-id="conversationId" :data="authoredData" :attachments="attachmentsEnabled ? attachments : null" :presentation="presentation" :on-dispatch="recordDispatch" :draft-while-loading="draftWhileLoading" />
+        <AssistantConversationClientElement v-else ref="conversation" :conversation-id="conversationId" :data="authoredData" :attachments="attachmentsEnabled ? attachments : null" :suggestions="suggestionsEnabled ? suggestions : null" :models="modelsEnabled ? models : null" :questions="questions" assistant-label="Primary conversation" />
+      </div>
+      <div v-if="mirror" class="fixture__conversation" data-mirror>
+        <DraftConversation v-if="acceptedDraft" :conversation-id="conversationId" :data="authoredData" :attachments="attachmentsEnabled ? attachments : null" :presentation="presentation" :on-dispatch="recordDispatch" :draft-while-loading="draftWhileLoading" />
+        <AssistantConversationClientElement v-else :conversation-id="conversationId" :data="authoredData" :attachments="attachmentsEnabled ? attachments : null" :suggestions="suggestionsEnabled ? suggestions : null" :models="modelsEnabled ? models : null" :questions="questions" assistant-label="Mirror conversation" />
+      </div>
+      <div v-for="index in (multiple ? [2, 3, 4, 5] : [])" :key="index" class="fixture__conversation" :data-chat="index">
+        <AssistantConversationClientElement :conversation-id="`chat:${index}`" :assistant-label="`Conversation ${index}`" />
+      </div>
+      <output v-if="voice" data-voice>{{ voice.identity.conversationId }} {{ voice.current.value ? 'current' : 'retired' }}</output>
+    </main>
+  </v-app>
+</template>
+
+<style>
+html, body, #app { margin: 0; height: 100%; }
+.fixture { display: grid; gap: 1rem; padding: 1rem; max-width: 72rem; width: 100%; margin: 0 auto; }
+.fixture__conversation { height: min(720px, calc(100dvh - 3rem)); min-height: 360px; min-width: 0; }
+</style>

package/fixtures/canonical-conversation/DraftConversation.vue

@@ -0,0 +1,32 @@
+<script setup>
+import { toRef } from "vue";
+import { assistantHttpClient, createAssistantApi } from "@jskit-ai/assistant-core/client";
+import { AssistantConversationElement } from "@jskit-ai/assistant-core/client/conversation";
+import { useAssistantConversation } from "../../src/client/composables/useAssistantConversation.js";
+
+const props = defineProps({
+  conversationId: { type: String, required: true },
+  data: { type: Object, default: undefined },
+  attachments: { type: Object, default: null },
+  presentation: { type: Object, default: () => ({}) },
+  draftWhileLoading: { type: Boolean, default: false },
+  onDispatch: { type: Function, required: true }
+});
+const api = createAssistantApi({ request: assistantHttpClient.request,
+  resolveBasePath: () => "/api/assistant/home", resolveSurfaceId: () => "home" });
+const binding = useAssistantConversation({
+  conversationId: toRef(props, "conversationId"), data: toRef(props, "data"),
+  presentation: toRef(props, "presentation"),
+  attachments: toRef(props, "attachments"),
+  api: { ...api, sendConversationMessage(id, input) {
+    props.onDispatch(input.messageId);
+    return api.sendConversationMessage(id, input);
+  } },
+  clearDraftOn: "accepted", queueWhileSending: false, draftWhileLoading: props.draftWhileLoading
+});
+defineExpose({ runtime: binding.runtime, adapter: binding.adapter, submit: () => binding.adapter.value.actions.submit() });
+</script>
+
+<template>
+  <AssistantConversationElement :adapter="binding.adapter.value" label="Accepted draft conversation" style="height: 100%" />
+</template>

package/fixtures/canonical-conversation/index.html

@@ -0,0 +1 @@
+<!doctype html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"></head><body><div id="app"></div><script type="module" src="/main.js"></script></body></html>

package/fixtures/canonical-conversation/main.js

@@ -0,0 +1,61 @@
+import { createApp, ref } from "vue";
+import { createRouter, createWebHistory } from "vue-router";
+import { createVuetify } from "vuetify";
+import * as components from "vuetify/components";
+import * as directives from "vuetify/directives";
+import { aliases, mdi } from "vuetify/iconsets/mdi-svg";
+import "vuetify/styles";
+import App from "./App.vue";
+import { createWebPlacementRuntime } from "../../../shell-web/src/client/placement/runtime.js";
+import { createFixtureSocket } from "./socket.js";
+import { assistantHttpClient, createAssistantApi } from "@jskit-ai/assistant-core/client";
+import { configureAssistantConversations, useAssistantConversation } from "../../src/client/composables/useAssistantConversation.js";
+
+globalThis.__JSKIT_CLIENT_APP_CONFIG__ = {
+  surfaceDefinitions: { home: { requiresWorkspace: false } },
+  assistantSurfaces: { home: { settingsSurfaceId: "home", configScope: "global" } }
+};
+const placement = createWebPlacementRuntime({ components: new Map() });
+placement.setContext({ user: { id: "42" }, surfaceConfig: {
+  defaultSurfaceId: "home", surfacesById: { home: { id: "home", routeBase: "/", requiresWorkspace: false } }
+} });
+const socket = createFixtureSocket();
+const app = createApp(App);
+const router = createRouter({ history: createWebHistory(), routes: [{ path: "/:pathMatch(.*)*", component: App }] });
+if (new URLSearchParams(window.location.search).has("applicationDefaults")) {
+  const actor = ref("application-user");
+  const requests = [], overrideRequests = [];
+  configureAssistantConversations(app, {
+    actorKey: actor, clearDraftOn: "accepted",
+    request(path, options) { requests.push(path); return assistantHttpClient.request(path, options); }
+  });
+  const overrideApi = createAssistantApi({
+    request(path, options) { overrideRequests.push(path); return assistantHttpClient.request(path, options); },
+    resolveBasePath: () => "/api/assistant/home", resolveSurfaceId: () => "home"
+  });
+  let otherApp, otherBinding, otherRoot;
+  window.conversationDefaultsFixture = {
+    actor(value) { actor.value = value; }, requests, overrideRequests, overrideApi,
+    mountOtherApp() {
+      otherApp = createApp({ setup() {
+        otherBinding = useAssistantConversation({ conversationId: "chat:1" });
+        return () => null;
+      } });
+      otherApp.provide("jskit.shell-web.runtime.web-placement.client", placement);
+      otherApp.provide("jskit.realtime.runtime.client.socket", socket);
+      otherApp.use(router);
+      otherRoot = document.createElement("div");
+      document.body.append(otherRoot);
+      otherApp.mount(otherRoot);
+    },
+    other() { return otherBinding.runtime.value; },
+    unmountOtherApp() { otherApp.unmount(); otherRoot.remove(); }
+  };
+}
+app.provide("jskit.shell-web.runtime.web-placement.client", placement);
+app.provide("jskit.realtime.runtime.client.socket", socket);
+app.provide("fixture", { placement, socket });
+app.use(router).use(createVuetify({ theme: { defaultTheme: "light" }, components, directives,
+  icons: { defaultSet: "mdi", aliases, sets: { mdi } } }));
+await router.isReady();
+app.mount("#app");

package/fixtures/canonical-conversation/socket.js

@@ -0,0 +1,50 @@
+import { ASSISTANT_CONVERSATION_EVENT, ASSISTANT_CONVERSATION_SUBSCRIBE, ASSISTANT_CONVERSATION_UNSUBSCRIBE } from "../../src/shared/conversationRealtime.js";
+
+// Controlled transport fixture. The production Socket.IO/auth/lifetime contract
+// is exercised separately by assistantConversationSubscriptions.test.js.
+export function createFixtureSocket() {
+  const listeners = new Map();
+  const subscriptions = new Map();
+  const calls = [];
+  const fire = (event, payload) => { for (const listener of [...listeners.get(event) || []]) listener(payload); };
+  const socket = {
+    connected: true,
+    on(event, listener) {
+      if (!listeners.has(event)) listeners.set(event, new Set());
+      listeners.get(event).add(listener);
+    },
+    off(event, listener) { listeners.get(event)?.delete(listener); },
+    timeout() { return socket; },
+    async emit(event, input, acknowledge) {
+      calls.push({ event, input: structuredClone(input) });
+      if (event === ASSISTANT_CONVERSATION_UNSUBSCRIBE) { subscriptions.delete(input.subscriptionId); return; }
+      if (event !== ASSISTANT_CONVERSATION_SUBSCRIBE) throw new Error(`Unexpected fixture socket command ${event}`);
+      const subscription = { ...input, epoch: crypto.randomUUID(), revision: 0 };
+      subscriptions.set(input.subscriptionId, subscription);
+      const response = await fetch(`/api/assistant/${input.targetSurfaceId}/conversations/${encodeURIComponent(input.conversationId)}`, {
+        headers: { "x-jskit-surface": input.hostSurfaceId }
+      });
+      const state = await response.json();
+      if (!subscriptions.has(input.subscriptionId)) return;
+      acknowledge(null, response.ok ? { ok: true, streamEpoch: subscription.epoch, state }
+        : { ok: false, error: state.error, status: response.status, code: state.code });
+    },
+    notify(conversationId, event = { type: "settled" }) {
+      for (const subscription of subscriptions.values()) {
+        if (conversationId && subscription.conversationId !== conversationId) continue;
+        fire(ASSISTANT_CONVERSATION_EVENT, { subscriptionId: subscription.subscriptionId,
+          conversationId: subscription.conversationId, streamEpoch: subscription.epoch,
+          streamRevision: ++subscription.revision, event });
+      }
+    },
+    reconnect() {
+      socket.connected = false;
+      subscriptions.clear();
+      fire("disconnect", "transport close");
+      socket.connected = true;
+      fire("connect");
+    },
+    inspect() { return { active: subscriptions.size, calls, listeners: [...listeners.values()].reduce((sum, set) => sum + set.size, 0) }; }
+  };
+  return socket;
+}

package/fixtures/canonical-conversation/vite.config.mjs

@@ -0,0 +1,178 @@
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import { fileURLToPath } from "node:url";
+import { createConversationTranscript } from "@jskit-ai/assistant-core/server/conversation";
+
+export default defineConfig({
+  root: fileURLToPath(new URL("./", import.meta.url)),
+  server: { host: "127.0.0.1", strictPort: true },
+  plugins: [vue(), {
+    name: "controlled-canonical-assistant-api",
+    configureServer(server) {
+      let states, requests, held, mode, denied;
+      const pageLimits = new Map();
+      // Exercise the existing page reader over this fixture's controlled rows.
+      const transcript = createConversationTranscript({ storage: {
+        read(id, callback) {
+          const turns = states.get(id).conversationLog;
+          return callback({ listTurnIds: () => turns.map(turn => turn.turnId),
+            readTurn: turnId => turns.find(turn => turn.turnId === turnId) });
+        },
+        write() { throw new Error("The fixture owns its controlled rows."); }
+      } });
+      function reset() {
+        states = new Map(Array.from({ length: 5 }, (_, index) => {
+          const id = `chat:${index + 1}`;
+          return [id, { id, engine: "api", segmentId: `segment-${index + 1}`, status: "ready", conversationLog: [],
+            streaming: { revision: 0, messages: [] }, capabilities: { steering: false, goals: false, attachments: true } }];
+        }));
+        requests = []; held = []; mode = "accepted"; denied = false; pageLimits.clear();
+      }
+      reset();
+      function accept(state, input) {
+        state.pendingRequest = null;
+        state.status = "working";
+        const turn = { turnId: input.messageId, user: { messageId: input.messageId, text: input.text,
+          role: "user", at: new Date().toISOString(), attachments: input.attachments || (input.attachmentIds || []).map(attachmentId => ({ attachmentId })) },
+          assistant: null, metadata: { runtime: { status: "running" } } };
+        state.conversationLog.push(turn);
+        return { status: "accepted", messageId: input.messageId, turnId: turn.turnId };
+      }
+      function changeGoal(state, input) {
+        if (input.action === "set") {
+          if (state.segmentId === null) state.segmentId = `first-native-thread-${state.id}`;
+          state.goal = { id: `goal-${input.messageId || state.segmentId}`, objective: input.objective,
+            status: "active", timeUsedSeconds: 10, updatedAt: new Date().toISOString(), tokenBudget: input.tokenBudget ?? null };
+        }
+        if (input.action === "resume") state.goal.status = "active";
+        if (input.action === "pause") state.goal.status = "paused";
+        if (input.action === "cancel") state.goal = null;
+        if (state.capabilities.goalCommands[input.action].interruptsTurn) state.status = "ready";
+      }
+      server.middlewares.use(async (request, response, next) => {
+        const url = new URL(request.url, "http://fixture");
+        if (!url.pathname.startsWith("/api/") && !url.pathname.startsWith("/fixture/")) return next();
+        const json = (value, status = 200) => { response.statusCode = status; response.setHeader("Content-Type", "application/json"); response.end(JSON.stringify(value)); };
+        let body = "";
+        for await (const part of request) body += part;
+        const input = body ? JSON.parse(body) : {};
+        if (url.pathname === "/api/session") return json({ csrfToken: "fixture-only" });
+        if (url.pathname === "/fixture/reset") { reset(); return json({ ok: true }); }
+        if (url.pathname === "/fixture/state") return json({ requests, states: Object.fromEntries(states), held: held.length });
+        if (url.pathname === "/fixture/mode") { mode = input.mode; return json({ ok: true }); }
+        if (url.pathname === "/fixture/deny") { denied = input.denied; return json({ ok: true }); }
+        if (url.pathname === "/fixture/error") { states.get(input.id).error = input.error; return json({ ok: true }); }
+        if (url.pathname === "/fixture/interim-reply") { states.get(input.id).interimReply = input.reply; return json({ ok: true }); }
+        if (url.pathname === "/fixture/history") {
+          states.get(input.id).conversationLog = input.turns;
+          pageLimits.set(input.id, input.limit);
+          return json({ ok: true });
+        }
+        if (url.pathname === "/fixture/question") {
+          const state = states.get(input.id);
+          const assistant = { messageId: "fixture-question", role: "assistant", text: input.text,
+            status: input.pending ? "inProgress" : "completed" };
+          state.status = input.pending ? "working" : "ready";
+          state.conversationLog = [{ turnId: "fixture-question", assistant, messages: [assistant] }];
+          return json({ ok: true });
+        }
+        if (url.pathname === "/fixture/attachments") { states.get(input.id).capabilities.attachments = input.enabled; return json({ ok: true }); }
+        if (url.pathname === "/fixture/steering") { states.get(input.id).capabilities.steering = input.enabled; return json({ ok: true }); }
+        if (url.pathname === "/fixture/goals") {
+          const state = states.get(input.id);
+          state.engine = "fixture-native";
+          state.segmentId = Object.hasOwn(input, "segmentId") ? input.segmentId : `${state.segmentId}-next`;
+          state.status = "ready";
+          state.goal = null;
+          state.capabilities = { ...state.capabilities, goals: true, goalBudgets: input.budgets,
+            goalCommands: input.commands };
+          return json({ ok: true });
+        }
+        if (url.pathname === "/fixture/confirm") {
+          const state = states.get(input.id);
+          const pending = state.pendingRequest;
+          const receipt = accept(state, pending);
+          if (pending.goal) changeGoal(state, { ...pending.goal, messageId: pending.messageId });
+          return json(receipt);
+        }
+        if (url.pathname === "/fixture/accept") {
+          for (const pending of held.splice(0)) {
+            const receipt = accept(states.get(pending.id), pending.input);
+            if (input.holdResponse) held.push({ ...pending, receipt });
+            else pending.respond(receipt);
+          }
+          return json({ ok: true });
+        }
+        if (url.pathname === "/fixture/release-response") {
+          for (const pending of held.splice(0)) pending.respond(pending.receipt);
+          return json({ ok: true });
+        }
+        if (url.pathname === "/fixture/finish") {
+          const state = states.get(input.id);
+          state.status = "ready";
+          const last = state.conversationLog.at(-1);
+          if (last) { last.assistant = { role: "assistant", messageId: `${last.turnId}:answer`, text: input.text || "Completed answer." }; last.metadata.runtime.status = "complete"; }
+          return json({ ok: true });
+        }
+        const match = /^\/api\/assistant\/home\/conversations\/([^/]+)(.*)$/u.exec(url.pathname);
+        if (!match) return json({ error: "Unknown fixture route" }, 404);
+        const id = decodeURIComponent(match[1]);
+        const state = states.get(id);
+        requests.push({ method: request.method, id, suffix: match[2], surface: request.headers["x-jskit-surface"], input, query: Object.fromEntries(url.searchParams) });
+        if (denied || !state) return json({ error: "Access denied.", code: "conversation_forbidden" }, 403);
+        if (request.method === "GET" && !match[2]) {
+          return json(pageLimits.has(id) ? { ...state, ...await transcript.readConversationLogPage(id, {
+            beforeTurnId: url.searchParams.get("beforeTurnId") || "",
+            limit: url.searchParams.get("limit") || pageLimits.get(id)
+          }) } : state);
+        }
+        if (match[2] === "/goal") {
+          if (request.method === "GET") return json(state.goal || null, state.goal ? 200 : 204);
+          const command = state.capabilities.goalCommands?.[input.action];
+          if (!command) return json({ error: "Unsupported goal command.", code: "conversation_unsupported" }, 400);
+          if (input.expectedSegmentId !== state.segmentId || state.segmentId === null && input.action !== "set") {
+            return json({ error: "The native conversation changed.", code: "conversation_goal_changed" }, 409);
+          }
+          if (command.delivery === "message" && mode === "uncertain") {
+            state.status = "unconfirmed";
+            state.pendingRequest = { messageId: input.messageId, text: input.objective || "Resume the goal.",
+              origin: "user", attachments: [], goal: input, error: "The goal's receipt was lost." };
+            return json({ error: state.pendingRequest.error }, 503);
+          }
+          const receipt = command.delivery === "message" ? accept(state, { messageId: input.messageId,
+            text: input.objective || (input.action === "resume" ? "Resume the goal." : "Cancel the goal.") }) : null;
+          changeGoal(state, input);
+          const result = receipt || state.goal || null;
+          return json(result, result === null ? 204 : 200);
+        }
+        if (match[2] === "/messages") {
+          if (mode === "product-rejected") return json({ ok: false, delivered: false,
+            messageId: input.messageId, code: "product_owner_conflict", error: "This turn belongs to another user.",
+            operationOutcome: "active_turn_owned_by_another_user", retryable: true, refreshRecommended: true }, 202);
+          if (mode === "product-native-duplicate") return json({ ok: true, delivered: true, messageId: input.messageId }, 202);
+          if (mode === "product-accepted") {
+            accept(state, input);
+            return json({ ok: true, delivered: true, messageId: input.messageId }, 202);
+          }
+          if (mode === "rejected") return json({ error: "The message was rejected before admission.", code: "ACTION_VALIDATION_FAILED" }, 400);
+          if (mode === "uncertain") {
+            state.status = "unconfirmed";
+            state.pendingRequest = { messageId: input.messageId, text: input.text, origin: "user",
+              ...(input.data !== undefined ? { data: input.data } : {}),
+              attachments: (input.attachmentIds || []).map(attachmentId => ({ attachmentId })), error: "Connection closed before the receipt arrived." };
+            return json({ error: state.pendingRequest.error }, 503);
+          }
+          if (mode === "hold") { held.push({ id, input, respond: value => json(value, 202) }); return; }
+          return json(accept(state, input), 202);
+        }
+        if (match[2] === "/cancel") { state.status = "ready"; return json({ stopped: true }); }
+        if (match[2].startsWith("/deliveries/") && match[2].endsWith("/inspect")) {
+          const messageId = decodeURIComponent(match[2].split("/")[2]);
+          const receipt = state.conversationLog.find(turn => turn.user?.messageId === messageId);
+          return json(receipt ? { status: "accepted", messageId, turnId: receipt.turnId } : { status: "unknown", messageId });
+        }
+        return json({ error: "Unknown fixture operation" }, 404);
+      });
+    }
+  }]
+});

package/fixtures/conversation/vite.config.mjs

@@ -1,5 +1,7 @@
 import { createMemoryTurnRequests } from "../../test/support/memoryTurnRequests.js";
 import { createChatService } from "../../src/server/services/chatService.js";
+import { createAssistantConversationRuntime } from "../../src/server/createAssistantRuntime.js";
+import { createMemoryAssistantRows } from "../../test/support/memoryAssistantRows.js";
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
 import { fileURLToPath } from "node:url";
@@ -59,7 +61,7 @@ export default defineConfig({
               controller.signal.addEventListener("abort", () => reject(new Error("Stopped")), { once: true });
             });
             stream.advance = parameters => release(parameters);
-            const service = createChatService({
+            const dependencies = {
               turnRequests,
               aiClientFactory: { async resolveClient(_surface, { integrationId }) {
                 return { enabled: true, provider: "fixture", defaultModel: integrationId, supportsAttachments: true,
@@ -69,6 +71,7 @@ export default defineConfig({
                     yield { choices: [{ delta: { content: "Partial answer" } }] };
                     await nextChunk();
                     yield { choices: [{ delta: { content: " completed." } }] };
+                    yield { choices: [{ delta: {}, finish_reason: "stop" }] };
                   }
                 };
               } },
@@ -81,11 +84,18 @@ export default defineConfig({
                 async appendMessage(_surface, _id, message) { transcript.push(message); },
                 async completeConversation() {}
               },
-              serviceToolCatalog: { resolveToolSet: () => ({ tools: [] }) },
+              serviceToolCatalog: { limits: { maxToolArgumentBytes: 64 * 1024 }, resolveToolSet: () => ({ tools: [] }),
+                toOpenAiToolSchema: tool => ({ type: "function", function: tool }) },
               assistantConfigService: { resolveSystemPrompt: async () => "Answer the user." },
               appConfig: { surfaceDefinitions: { admin: { id: "admin", enabled: true, requiresWorkspace: false, accessPolicyId: "public" } },
                 assistantSurfaces: { admin: { settingsSurfaceId: "admin", configScope: "global" } } }
+            };
+            const conversationRuntime = createAssistantConversationRuntime({
+              ...createMemoryAssistantRows({ id: "100", surfaceId: "admin", messages: transcript }),
+              aiClientFactory: dependencies.aiClientFactory, toolCatalog: dependencies.serviceToolCatalog,
+              attachments: dependencies.attachments
             });
+            const service = createChatService({ ...dependencies, conversationRuntime });
             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 }); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.192",
+  "version": "0.1.194",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -8,21 +8,23 @@
   "exports": {
     "./client": "./src/client/index.js",
     "./shared": "./src/shared/index.js",
-    "./server/actionIds": "./src/server/actionIds.js"
+    "./server/actionIds": "./src/server/actionIds.js",
+    "./server": "./src/server/index.js"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.199",
-    "@jskit-ai/database-runtime": "0.1.221",
+    "@jskit-ai/assistant-core": "0.1.201",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.219",
-    "@jskit-ai/http-web": "0.1.66",
-    "@jskit-ai/kernel": "0.1.221",
-    "@jskit-ai/shell-web": "0.1.225",
+    "@jskit-ai/http-runtime": "0.1.221",
+    "@jskit-ai/http-web": "0.1.68",
+    "@jskit-ai/kernel": "0.1.223",
+    "@jskit-ai/realtime": "0.1.220",
+    "@jskit-ai/shell-web": "0.1.227",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
-    "vuetify": "^4.0.0"
+    "vuetify": "^4.0.0",
+    "@jskit-ai/database-runtime": "0.1.223"
   },
   "description": "Capability-based assistant runtime with per-surface chat, transcripts, settings, and action tools.",
   "jskit": {
@@ -34,7 +36,6 @@
       "requires": [
         "runtime.actions",
         "runtime.config",
-        "runtime.database",
         "runtime.env",
         "runtime.http",
         "runtime.http-web",
@@ -91,6 +92,10 @@
           {
             "subpath": "./server/actionIds",
             "summary": "Exports assistant runtime action identifiers."
+          },
+          {
+            "subpath": "./server",
+            "summary": "Provides conversation routes, authorized shared realtime subscriptions, explicit Fastify hosting shorthand and optional database integration."
           }
         ],
         "capabilities": [
@@ -106,5 +111,13 @@
         "migrations"
       ]
     }
+  },
+  "peerDependenciesMeta": {
+    "@jskit-ai/realtime": {
+      "optional": true
+    },
+    "@jskit-ai/database-runtime": {
+      "optional": true
+    }
   }
 }