@jskit-ai/assistant-core 0.1.223 → 0.1.224

package/test/conversationRuntime.test.js

@@ -3,7 +3,7 @@ import test from "node:test";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { createConversationHookBridge } from "../src/server/conversation/index.js";
+import { createConversationHookBridge, createConversationRuntime } from "../src/server/conversation/index.js";
 import { createClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
 import { createCodexConversationAdapter } from "../src/server/conversation/providers/codex.js";
 import { createOpenCodeConversationAdapter } from "../src/server/conversation/providers/opencode.js";
@@ -29,6 +29,36 @@ function claudeHost() {
 const claudeInput = { systemPrompt: "Use the calendar tools.", contextIdentity: "calendar/model-one",
   model: "one", settings: { effortLevel: "high" }, liveUpdateIdentity: "calendar-schema" };
 
+test("saved persistent history projects receipts and pages without native observation or writes", async () => {
+  const runtime = createConversationRuntime({ authorize: async () => true, host: { conversation: () => ({}) } });
+  const turn = { turnId: "turn-1", user: { messageId: "user-1", attachments: [] },
+    messages: [{ role: "user", messageId: "user-1", text: "Saved draft", at: "2026-01-01T00:00:00Z" }] };
+  const calls = [];
+  const options = {
+    sessionId: "session-1", record: { conversationId: "chat-1", status: "starting", runId: "run-1", messageId: "user-1" },
+    context: { actor: "owner" }, includeAccess: true, transcriptQuery: { limit: 10 },
+    store: {
+      async readConversationLog(scope) { calls.push(["log", scope]); return [turn]; },
+      async readConversationLogPage(scope, query) { calls.push(["page", scope, query]); return { conversationLog: [turn], pagination: { more: false } }; }
+    },
+    operations: new Proxy({}, { get() { throw new Error("native operation must not run"); } }),
+    receipts: { persisted: () => false },
+    projection: {
+      context: (context) => context,
+      messageMetadata: () => ({}),
+      async snapshot(input) { return { ...input, page: await input.readPage() }; }
+    }
+  };
+  const result = await runtime.projectStoredPersistentConversation(options);
+  assert.equal(result.includeAccess, true);
+  assert.equal(result.response.status, "starting");
+  assert.equal(result.messages[0].receipt, false);
+  assert.equal(result.page.conversationLog[0].user.receipt, false);
+  assert.deepEqual(calls.map(([kind]) => kind), ["log", "page"]);
+  await runtime.close();
+  await assert.rejects(runtime.projectStoredPersistentConversation(options), { code: "conversation_closed" });
+});
+
 test("a standalone Claude consumer reuses, updates and replaces processes without changing native history", async () => {
   const f = claudeHost();
   const input = { ...claudeInput, nativeId: "retained-history" };
@@ -57,6 +87,21 @@ test("Claude rejects active prompt changes without invalidating ordinary steerin
   assert.equal(f.launches.length, 1);
 });
 
+test("Claude applies model and effort changes during work without restarting its process", async () => {
+  const f = claudeHost();
+  await f.runtime.prepare(claudeInput);
+  f.state.active = true;
+  await f.runtime.prepare({ ...claudeInput, contextIdentity: "calendar/model-two", model: "two",
+    settings: { effortLevel: "low" } });
+  assert.equal(f.state.active, true);
+  assert.equal(f.launches.length, 1);
+  assert.deepEqual(f.requests.slice(-2), [
+    { subtype: "apply_flag_settings", settings: { effortLevel: "low" } },
+    { subtype: "set_model", model: "two" }
+  ]);
+  await assert.rejects(f.runtime.prepare({ ...claudeInput, liveUpdateIdentity: "changed-tools" }), /Stop the current/);
+});
+
 test("Claude restarts when only the native instruction mode changes", async () => {
   const f = claudeHost();
   await f.runtime.prepare(claudeInput);
@@ -81,10 +126,14 @@ function codexHost({ readInstructions } = {}) {
   const state = { status: "idle", process: "process-1", prompt: "Calendar instructions", provider: "openai", fail: false,
     environment: { TOOL_ENDPOINT: "current" } };
   const requests = [];
-  const client = { async request(method, input) {
+  const client = { isOpen: () => true, async request(method, input) {
     requests.push({ method, input });
     if (method === "thread/read") return { thread: { historyMode: "paginated", status: state.status, modelProvider: state.provider } };
-    if (method === "thread/goal/get") return { goal: null };
+    if (method === "thread/goal/get") return { goal: state.goal ? { ...state.goal } : null };
+    if (method === "thread/goal/set") {
+      state.goal = { ...state.goal, status: input.status, updatedAt: state.goal.updatedAt + 1 };
+      return { goal: { ...state.goal } };
+    }
     if (method === "thread/turns/list") return { data: [{ id: "active-turn" }] };
     if (method === "turn/interrupt") { state.status = "idle"; return {}; }
     if (method === "thread/inject_items") return {};
@@ -93,7 +142,8 @@ function codexHost({ readInstructions } = {}) {
     if (method === "thread/resume") {
       if (state.fail) throw new Error("resume failed");
       state.status = "idle";
-      return { modelProvider: input.modelProvider || state.provider };
+      state.provider = input.modelProvider || state.provider;
+      return { modelProvider: state.provider };
     }
     throw new Error(`Unexpected native request: ${method}`);
   } };
@@ -104,6 +154,7 @@ function codexHost({ readInstructions } = {}) {
     prepareHistory: async (params) => params,
     threadParameters: (params) => params,
     verifyEnvironment: async () => {},
+    publishGoal: (threadId, goal) => requests.push({ method: "host.goal", input: { threadId, goal } }),
     recordInterruption: (threadId, turnId) => requests.push({ method: "host.recordInterruption", input: { threadId, turnId } }),
     prepareResume: async (id, params) => { requests.push({ method: "host.prepareResume", input: { id } }); return params; }
   });
@@ -503,3 +554,116 @@ test("Codex excludes deferred instruction composition without replenishing spent
     });
   }
 });
+
+
+for (const action of ["continue", "pause", "cancel", "complete", "close", "invalidate", "failure"]) {
+  test(`next-turn Codex provider settings preserve the current turn and ${action}`, async () => {
+    const f = codexHost();
+    const id = "native-history";
+    await f.runtime.withThreadContext(id, { modelProvider: "openai" }, () => {});
+    f.requests.length = 0;
+    f.state.status = "active";
+    f.state.goal = { status: "active", createdAt: 1, updatedAt: 1, objective: "Finish the same goal", tokenBudget: 100, tokensUsed: 40 };
+    const applied = [];
+    const update = params => { applied.push(params.model); return { ok: true }; };
+    const first = { modelProvider: "deepseek", model: "first", config: { "model_providers.deepseek": { base_url: "https://example.test" } } };
+    assert.deepEqual(await f.runtime.scheduleSettings(id, first, update), { ok: true, pending: true });
+    const task = f.runtime.threadEnvironmentTasks.get(id);
+    assert.equal(f.state.goal.status, "paused");
+    assert.equal(f.runtime.projectGoal(id, f.state.goal).status, "active", "An internal scheduling hold is not a user Pause");
+    assert.equal(f.requests.some(r => ["turn/interrupt", "thread/resume", "thread/unsubscribe"].includes(r.method)), false);
+    assert.deepEqual(await f.runtime.scheduleSettings(id, { ...first, model: "latest" }, update), { ok: true, pending: true });
+    if (["pause", "cancel"].includes(action)) f.runtime.goalChanged(id);
+    if (action === "pause") f.state.goal = { ...f.state.goal, status: "paused", updatedAt: 3 };
+    if (action === "cancel") f.state.goal = null;
+    if (action === "complete") f.state.goal = { ...f.state.goal, status: "complete", updatedAt: 3 };
+    if (action === "failure") f.state.fail = true;
+    if (action === "close") f.runtime.close();
+    if (action === "invalidate") f.runtime.invalidateThread(id);
+    f.state.status = "idle";
+    if (["close", "invalidate", "failure"].includes(action)) {
+      await assert.rejects(task);
+      assert.deepEqual(applied, []);
+      assert.equal(f.runtime.projectGoal(id, f.state.goal).status, "paused");
+    } else {
+      await task;
+      assert.deepEqual(applied, ["latest"]);
+      assert.equal(f.state.provider, "deepseek");
+      assert.equal(f.state.goal?.status || null, { continue: "active", pause: "paused", cancel: null, complete: "complete" }[action]);
+      if (f.state.goal) for (const [key, value] of Object.entries({ createdAt: 1, objective: "Finish the same goal", tokenBudget: 100, tokensUsed: 40 })) {
+        assert.equal(f.state.goal[key], value);
+      }
+    }
+    assert.equal(f.requests.some(r => r.method === "turn/interrupt"), false);
+    f.runtime.close();
+  });
+}
+
+test("a settings save during Codex reload replaces the older choice before its goal resumes", async () => {
+  const f = codexHost();
+  const id = "native-history";
+  await f.runtime.withThreadContext(id, { modelProvider: "openai" }, () => {});
+  f.state.goal = { status: "active", createdAt: 1, updatedAt: 1, objective: "Continue" };
+  const params = { modelProvider: "deepseek", model: "first" };
+  const applied = [];
+  await f.runtime.scheduleSettings(id, params, async selected => {
+    applied.push(selected.model);
+    if (selected.model === "first") {
+      void f.runtime.scheduleSettings(id, { ...params, model: "latest" }, () => assert.fail("The retained owner handles later saves"));
+    }
+    assert.equal(f.state.goal.status, "paused");
+  });
+  assert.deepEqual(applied, ["first", "latest"]);
+  assert.equal(f.state.goal.status, "active");
+  assert.equal(f.requests.filter(r => r.method === "thread/goal/set" && r.input.status === "active").length, 1);
+  f.runtime.close();
+});
+
+test("Codex retains settings saved during goal resume acknowledgement and after completion", async () => {
+  const f = codexHost();
+  const id = "native-history";
+  await f.runtime.withThreadContext(id, { modelProvider: "openai" }, () => {});
+  f.state.goal = { status: "active", createdAt: 1, updatedAt: 1, objective: "Continue" };
+  const params = { modelProvider: "deepseek", model: "first" };
+  const applied = [];
+  const update = selected => { applied.push(selected.model); };
+  const request = f.client.request.bind(f.client);
+  let savedDuringResume = false;
+  f.client.request = async (method, input) => {
+    const result = await request(method, input);
+    if (method === "thread/goal/set" && input.status === "active" && !savedDuringResume) {
+      savedDuringResume = true;
+      void f.runtime.scheduleSettings(id, { ...params, model: "during-resume" }, update);
+    }
+    return result;
+  };
+  await f.runtime.scheduleSettings(id, params, update);
+  assert.deepEqual(applied, ["first", "during-resume"]);
+  assert.equal(f.runtime.hasPendingSettings(id), false);
+  await f.runtime.scheduleSettings(id, { ...params, model: "after-completion" }, update);
+  assert.deepEqual(applied, ["first", "during-resume", "after-completion"]);
+  assert.equal(f.state.goal.status, "active");
+  assert.equal(f.requests.some(r => r.method === "turn/interrupt"), false);
+  f.runtime.close();
+});
+
+test("a user Pause during the final goal read prevents automatic settings recovery from resuming it", async () => {
+  const f = codexHost();
+  const id = "native-history";
+  await f.runtime.withThreadContext(id, { modelProvider: "openai" }, () => {});
+  f.state.goal = { status: "active", createdAt: 1, updatedAt: 1, objective: "Continue" };
+  const request = f.client.request.bind(f.client);
+  let settingsApplied = false;
+  f.client.request = async (method, input) => {
+    const result = await request(method, input);
+    if (method === "thread/goal/get" && settingsApplied) {
+      f.runtime.goalChanged(id);
+      f.state.goal = { ...f.state.goal, status: "paused", updatedAt: f.state.goal.updatedAt + 1 };
+    }
+    return result;
+  };
+  await f.runtime.scheduleSettings(id, { modelProvider: "deepseek", model: "next" }, () => { settingsApplied = true; });
+  assert.equal(f.state.goal.status, "paused");
+  assert.equal(f.requests.some(r => r.method === "thread/goal/set" && r.input.status === "active"), false);
+  f.runtime.close();
+});

package/test/conversationSession.test.js

@@ -1236,3 +1236,51 @@ for (const text of ["abc", "abcd"]) {
     if (text.length > 3) assert.match(result.error, /final reply limit/);
   });
 }
+
+test("native settings authorize their scope and reject replaced or closed host preparation", async t => {
+  const context = { actor: { id: "owner" } };
+  const nativeContext = { sessionId: "settings-scope", authorized: true };
+  const input = { threadId: "owned-thread", model: "next-model", effort: "high" };
+  let allowed = false, hostCalls = 0, acquisitions = 0, updates = 0;
+  let scope = "settings-scope", gate;
+  const owner = {
+    async acquire(prepared, threadId) {
+      assert.equal(prepared, nativeContext);
+      assert.equal(threadId, input.threadId);
+      acquisitions += 1;
+      return { process: {} };
+    },
+    async ensureProcess() { updates += 1; }
+  };
+  const runtime = createConversationRuntime({
+    authorize: request => allowed && request.context === context &&
+      request.conversationId === "settings-scope" && request.operation === "configure",
+    host: { async conversation(request) {
+      hostCalls += 1;
+      assert.deepEqual(request, { id: "settings-scope", context, input, operation: "updateSettings" });
+      if (gate) { gate.entered.resolve(); await gate.finished.promise; }
+      return { sessionId: scope, engine: "claude", native: { owner }, context: nativeContext };
+    } }
+  });
+  t.after(() => runtime.close());
+  const request = { id: "settings-scope", context, input,
+    get native() { return assert.fail("The caller cannot select a native owner"); },
+    get engine() { return assert.fail("The caller cannot select an engine"); } };
+  await assert.rejects(runtime.updateNativeConversationSettings(request), { code: "conversation_forbidden" });
+  assert.deepEqual([hostCalls, acquisitions, updates], [0, 0, 0]);
+  allowed = true;
+  scope = "another-scope";
+  await assert.rejects(runtime.updateNativeConversationSettings(request), /authorized host preparation/);
+  assert.deepEqual([acquisitions, updates], [0, 0]);
+  scope = "settings-scope";
+  assert.deepEqual(await runtime.updateNativeConversationSettings(request), { ok: true });
+  assert.deepEqual([acquisitions, updates], [1, 1]);
+  gate = { entered: Promise.withResolvers(), finished: Promise.withResolvers() };
+  const pending = runtime.updateNativeConversationSettings(request);
+  await gate.entered.promise;
+  await runtime.close();
+  gate.finished.resolve();
+  await assert.rejects(pending, { code: "conversation_closed" });
+  await assert.rejects(runtime.updateNativeConversationSettings(request), { code: "conversation_closed" });
+  assert.deepEqual([acquisitions, updates], [1, 1]);
+});