@unieai/code 0.0.30 → 0.0.31

package/agent-runtime/bin/unieai-uac-server.mjs

@@ -177,6 +177,20 @@ await launchAppServer({
   defaultModel: dsh.defaultModel,
   threadMode,
   onShutdown: () => Promise.all([...hosts.values()].map((host) => host.close())),
+  // What this account can actually run: a model it does not offer (a config
+  // written for another account — Studio's ids differ from Rabi's) becomes
+  // its default, so the client shows the model the turns run on.
+  resolveModel: (model) => {
+    if (!model) return model;
+    try {
+      const account = writeAccount();
+      if (account.models.includes(model)) return model;
+      log(`[uac] this account does not offer "${model}"; using ${account.defaultModel}`);
+      return account.defaultModel;
+    } catch {
+      return model;
+    }
+  },
   buildEngine: ({ cwd, model, modelProvider, sandboxMode: _mode, oneShot, variant, readConfig, ...callbacks }) => {
     // The user's `[mcp_servers]` and Studio's (knowledge bases, SQL, skills),
     // read when each session opens so a config edit or new sign-in counts.
@@ -194,6 +208,8 @@ await launchAppServer({
     } catch (error) {
       log("[uac] could not refresh the account for dsh:", error.message);
     }
+    // Already resolved by `resolveModel` for threads the client started;
+    // a stored thread's model is checked again here.
     const chosen = model && account.models.includes(model) ? model : account.defaultModel;
     // The client's hidden structured turns (thread titles): one tool-less call.
     if (oneShot) return createOneShotEngine({ oneShot: oneShotModel, model: chosen, onText: callbacks.onText });
@@ -215,7 +231,7 @@ await launchAppServer({
       // Threads stored before modes existed have none: standard.
       host: hostFor(variant ?? "standard"),
       workspace: cwd,
-      model: model && account.models.includes(model) ? model : account.defaultModel,
+      model: chosen,
       onLog: (line) => log("[uac]", line),
       mcpServers,
       ...callbacks,

package/agent-runtime/src/app-server/server.mjs

@@ -163,10 +163,17 @@ export function createHandlers({
   // workspace-write, so the header promised a restriction nothing enforced.
   sandboxMode = "workspace-write",
   now = () => new Date().toISOString(),
+  // Called with what made a turn fail, so the reason is in the server's log
+  // and not only in the one line the client shows.
+  onTurnError = () => {},
   threadStore = null,
   // The engine variant a new thread runs in (uac: the dsh mode), read when
   // the thread starts; a forked thread keeps its source's.
   threadMode = () => null,
+  // A requested model as this account can actually run it. A config written
+  // for another account names models this one does not have, and the client
+  // would otherwise show a model no turn runs on.
+  resolveModel = (model) => model,
 }) {
   // Thread state lives here, not in the Rust process: its ThreadStateManager
   // keeps threads in an in-process HashMap, so a thread created there is not
@@ -250,6 +257,49 @@ export function createHandlers({
     return child ? subagents.threadFields(child) : null;
   };
 
+  /** What the thread runs under, as the protocol's SandboxPolicy. */
+  const sandboxShape = (t) =>
+    t.readOnly || (t.permissions?.sandbox ?? (sandboxMode === "readOnly" ? "read-only" : null)) === "read-only"
+      ? { type: "readOnly", networkAccess: false }
+      : t.permissions?.sandbox === "danger-full-access" || sandboxMode === "dangerFullAccess"
+        ? { type: PROTOCOL_SANDBOX["danger-full-access"] }
+        : { type: "workspaceWrite", networkAccess: true };
+
+  /** The named profile in force: the client's own when it asked for one. */
+  const permissionProfileShape = (t) => ({
+    id: t.permissionProfile ?? (sandboxMode === "readOnly" || t.readOnly ? ":read-only" : ":workspace-write"),
+    extends: null,
+  });
+
+  /**
+   * The thread as the protocol's ThreadSettings, for `thread/settings/updated`.
+   *
+   * The TUI holds a pending permission change until a notification confirms
+   * the profile it asked for is the one in force, and blocks switching task,
+   * forking and `/cd` while it waits ("Wait for permissions to update before
+   * ..."). We answered `thread/settings/update` and sent nothing, so the wait
+   * never ended: one `/permissions` left the rest of the session fenced off
+   * until it was restarted.
+   */
+  const threadSettings = (t) => ({
+    disabledPluginIds: [],
+    cwd: t.cwd,
+    approvalPolicy: t.permissions?.approval === "never" ? "never" : "on-request",
+    approvalsReviewer: "user",
+    sandboxPolicy: sandboxShape(t),
+    activePermissionProfile: permissionProfileShape(t),
+    model: t.model || defaultModel || "",
+    modelProvider: t.modelProvider || defaultProvider || "",
+    serviceTier: null,
+    effort: t.effort ?? null,
+    summary: null,
+    // dsh has no plan/default split of its own; a thread is always the one
+    // the client started, and its model is the thread's.
+    collaborationMode: { mode: "default", settings: { model: t.model || defaultModel || "" } },
+    multiAgentMode: "explicitRequestOnly",
+    personality: null,
+  });
+
   /** The session-settings half of thread/start, /resume and /fork responses. */
   const sessionResponse = (t, params, turns = []) => ({
     thread: threadShape(t, turns),
@@ -263,15 +313,8 @@ export function createHandlers({
     approvalPolicy: params?.approvalPolicy || "on-request",
     approvalsReviewer: params?.approvalsReviewer || "user",
     // What the thread runs under: its own -s when it has one.
-    sandbox: t.readOnly || (t.permissions?.sandbox ?? (sandboxMode === "readOnly" ? "read-only" : null)) === "read-only"
-      ? { type: "readOnly", networkAccess: false }
-      : t.permissions?.sandbox === "danger-full-access" || sandboxMode === "dangerFullAccess"
-        ? { type: PROTOCOL_SANDBOX["danger-full-access"] }
-        : { type: "workspaceWrite", networkAccess: true },
-    activePermissionProfile: {
-      id: t.permissionProfile ?? (sandboxMode === "readOnly" || t.readOnly ? ":read-only" : ":workspace-write"),
-      extends: null,
-    },
+    sandbox: sandboxShape(t),
+    activePermissionProfile: permissionProfileShape(t),
     // dsh decides how much the model thinks; no effort is chosen here, and
     // "none" would read as thinking turned off.
     reasoningEffort: null,
@@ -392,6 +435,9 @@ export function createHandlers({
         if (method === "item/completed" && openCards.delete(item?.id) && openCards.size === 0) runAfterCards();
         return sent;
       },
+      // What the model said so far is a finished message: anything that is
+      // not a card (the plan, a question) still ends the text before it.
+      closeText,
       /** Run `place` now, or once the cards open in this turn have completed. */
       whenNoOpenCards: (place) => {
         if (openCards.size === 0) place();
@@ -418,7 +464,9 @@ export function createHandlers({
         // The client files an error by thread and turn and needs to know
         // whether to expect a retry; without those it cannot place the error
         // at all, so an engine failure was invisible.
-        ctx?.emit?.("error", { error: { message: String(error?.message || error) }, willRetry: false, threadId: thread.id, turnId });
+        const message = String(error?.message || error);
+        onTurnError(message, { threadId: thread.id, turnId });
+        ctx?.emit?.("error", { error: { message }, willRetry: false, threadId: thread.id, turnId });
       }
       thread.activeTurn = null;
       thread.pendingAnswer = null;
@@ -533,6 +581,7 @@ export function createHandlers({
       onSteerDelivered: ({ clientId, text }) => emitUserMessage(thread, text, clientId),
       // The model's questions, through the client's request_user_input screen.
       askUser: async ({ questions }) => {
+        thread.pendingAnswer?.closeText?.();
         const emitItem = thread.pendingAnswer?.emitItem;
         for (const detail of questionDetails(questions)) {
           const item = agentMessageItem(newItemId(), detail);
@@ -586,6 +635,10 @@ export function createHandlers({
       request: (...args) => thread.connection.request(...args),
       emit: (method, params) => {
         const pending = thread.pendingAnswer;
+        // The plan checklist shows no card, but it still marks the end of
+        // what the model was saying: a client holding the message open (and
+        // queueing what follows behind it) would wait forever.
+        if (method === "turn/plan/updated") pending?.closeText?.();
         // Text deltas are routed through the turn's answer item so they carry
         // its id; everything else just gains the thread/turn stamps.
         if (method === "item/agentMessage/delta" && pending?.emitAnswerDelta) {
@@ -607,12 +660,17 @@ export function createHandlers({
    */
   const applySettings = async (thread, params) => {
     const changed = (value, current) => (typeof value === "string" && value && value !== current ? value : null);
-    const model = changed(params?.model, thread.model);
+    const model = changed(resolveModel(params?.model), thread.model);
     const effort = changed(params?.effort, thread.effort);
     const wanted = Object.fromEntries(Object.entries(requestedPermissions(params)).filter(([, value]) => value));
     const permissions = { ...thread.permissions, ...wanted };
     const permissionsChanged = JSON.stringify(permissions) !== JSON.stringify(thread.permissions ?? {});
-    if (!model && !effort && !permissionsChanged) return;
+    // The named profile the client asked for, as thread/start records it: it
+    // is what the client matches against to see its change took effect.
+    const profile = typeof params?.permissions === "string" ? params.permissions : null;
+    const profileChanged = profile !== null && profile !== thread.permissionProfile;
+    if (profileChanged) thread.permissionProfile = profile;
+    if (!model && !effort && !permissionsChanged && !profileChanged) return;
     if (model) thread.model = model;
     if (effort) thread.effort = effort;
     if (permissionsChanged) thread.permissions = permissions;
@@ -690,7 +748,7 @@ export function createHandlers({
     async "thread/start"(params, ctx) {
       const thread = newThread({
         cwd: params?.cwd || process.cwd(),
-        model: params?.model,
+        model: resolveModel(params?.model),
         modelProvider: params?.modelProvider,
         ephemeral: params?.ephemeral ?? false,
         mode: threadMode(),
@@ -724,9 +782,16 @@ export function createHandlers({
     },
 
     /** /model, /permissions: kept on the thread and applied from the next step. */
-    async "thread/settings/update"(params) {
+    async "thread/settings/update"(params, ctx) {
       const thread = getThread(params?.threadId);
       await applySettings(thread, params);
+      // Always, even when nothing moved: the client is waiting to be told
+      // what is in force, and a request that changed nothing still answers
+      // that question. See threadSettings.
+      (ctx ?? thread.connection)?.emit?.("thread/settings/updated", {
+        threadId: thread.id,
+        threadSettings: threadSettings(thread),
+      });
       return {};
     },
 
@@ -1119,8 +1184,8 @@ export function textOf(input) {
  * — useful in tests, wrong in production, where the platform surface has to
  * reach the Rust app-server.
  */
-export async function startAppServer({ socketPath, createEngineFor, codexHome, version, sandboxMode, threadStore = null, defaultModel = null, threadMode, forward = null, onError = () => {}, onTrace = null }) {
-  const handlers = createHandlers({ createEngineFor, codexHome, version, sandboxMode, threadStore, defaultModel, threadMode });
+export async function startAppServer({ socketPath, createEngineFor, codexHome, version, sandboxMode, threadStore = null, defaultModel = null, threadMode, resolveModel, onTurnError, forward = null, onError = () => {}, onTrace = null, onIdle = null }) {
+  const handlers = createHandlers({ createEngineFor, codexHome, version, sandboxMode, threadStore, defaultModel, threadMode, resolveModel, onTurnError });
   // Ours are unknown to the Rust side: a thread id it would look up is dropped.
   const forwardPlatform = forward
     ? (method, params, ...context) => {
@@ -1212,6 +1277,9 @@ export async function startAppServer({ socketPath, createEngineFor, codexHome, v
       conn.onClose(() => {
         live.delete(conn);
         trace(`connection ${connId} closed`);
+        // The client this server was started for is gone: whoever owns the
+        // process decides whether it stays (see onIdle).
+        if (live.size === 0) onIdle?.();
         for (const { resolve, timer } of pending.values()) {
           if (timer) clearTimeout(timer);
           resolve({ decision: "cancel" }); // the client is gone; cancel, not "maybe"
@@ -1223,6 +1291,8 @@ export async function startAppServer({ socketPath, createEngineFor, codexHome, v
 
   await transport.listen();
   return {
+    /** How many clients are connected right now. */
+    connections: () => live.size,
     ...transport,
     handlers,
     socketPath,

package/agent-runtime/src/app-server/unieai-launch.mjs

@@ -13,7 +13,7 @@ import { startAppServer } from "./server.mjs";
 import { createForwarder } from "./forward.mjs";
 import { createItemBridge } from "./items.mjs";
 import { createApprovalBridge } from "./approval.mjs";
-import { sandboxBin } from "../config.mjs";
+import { loadCredentials, sandboxBin } from "../config.mjs";
 
 export const log = (...parts) => process.stderr.write(`${parts.join(" ")}\n`);
 
@@ -23,7 +23,11 @@ export const log = (...parts) => process.stderr.write(`${parts.join(" ")}\n`);
  * thread. `threadStore` (see unieai-thread-store.mjs) makes threads persistent.
  * `onShutdown` runs before the process exits.
  */
-export async function launchAppServer({ name, version, buildEngine, sandboxMode, threadStore = null, defaultModel = null, threadMode, onShutdown = async () => {} }) {
+/** How long the server waits for another client before stopping. */
+const IDLE_EXIT_MS = Number(process.env.UNIEAI_UAC_IDLE_EXIT_MS) || 15_000;
+
+export async function launchAppServer({ name, version, buildEngine, sandboxMode, threadStore = null, defaultModel = null, threadMode, resolveModel, onShutdown = async () => {} }) {
+  let idleTimer = null;
   const codexHome = process.env.CODEX_HOME || process.env.UNIEAI_HOME || join(homedir(), ".unieai");
   const socketPath =
     process.env.UNIEAI_APP_SERVER_SOCKET || join(codexHome, "app-server-control", "app-server-control.sock");
@@ -54,8 +58,24 @@ export async function launchAppServer({ name, version, buildEngine, sandboxMode,
     threadStore,
     defaultModel,
     threadMode,
+    resolveModel,
+    // The server is this client's: when the client goes, so does it, unless
+    // another connects first (an engine switch or an update relaunches the
+    // client within seconds). Left running, it would serve the next client
+    // with another account's models and an older release's behaviour.
+    onIdle: () => {
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        if (server?.connections?.() === 0) {
+          log(`no client for ${IDLE_EXIT_MS}ms; stopping`);
+          shutdown();
+        }
+      }, IDLE_EXIT_MS);
+      idleTimer.unref?.();
+    },
     forward: (method, params) => forwarder.forward(method, params),
     onError: (error) => log("[app-server]", error.message),
+    onTurnError: (message, { threadId }) => log(`[turn] ${threadId} failed: ${message}`),
     onTrace: (line) => log("[trace]", line),
     createEngineFor: ({ cwd, model, effort, modelProvider, emit, request, sandboxMode: mode, ids, newItemId, resumeState, onState, clientTools, oneShot, mode: variant, permissions, onSteerDelivered, onGoalChanged, onEngineTurn, onSubagent, onChildActivity, askUser, onCompaction }) =>
       buildEngine({
@@ -113,6 +133,9 @@ export async function launchAppServer({ name, version, buildEngine, sandboxMode,
   const stamp = {
     pid: process.pid,
     cliVersion: process.env.UNIEAI_CLI_VERSION ?? null,
+    // Which account it serves: its models, threads and gateway are that
+    // account's, so a client signed in as someone else needs its own.
+    accountId: loadCredentials().accountId || null,
     engineVersion: version,
     socket: socketPath,
     startedAt: new Date().toISOString(),

package/agent-runtime/src/config.mjs

@@ -24,13 +24,26 @@ export function loadCredentials() {
       gatewayBaseUrl: parsed.gateway_base_url,
       gatewayApiKey: parsed.gateway_api_key,
       studioUrl: parsed.studio_url,
+      // Which account this is, for a client to notice it changed (see
+      // accountId): never the key itself.
+      accountId: accountId(parsed),
       models
     };
   } catch {
-    return { signedIn: false, gatewayBaseUrl: "", gatewayApiKey: "", studioUrl: "", models: [] };
+    return { signedIn: false, gatewayBaseUrl: "", gatewayApiKey: "", studioUrl: "", accountId: "", models: [] };
   }
 }
 
+/**
+ * Who a credentials file signs in as: the product, the gateway it uses and
+ * the user. A long-running server started for one account serves models and
+ * threads that belong to it, so a client on another account must replace it.
+ */
+export function accountId(parsed) {
+  if (!parsed) return "";
+  return [parsed.account ?? "studio", parsed.gateway_base_url ?? "", parsed.email ?? ""].join("|");
+}
+
 /** Configure agent-core's upstream env for this process. */
 export function applyUpstreamEnv(credentials) {
   if (credentials.gatewayBaseUrl) process.env.AGENT_CORE_UPSTREAM_BASE_URL = credentials.gatewayBaseUrl;

package/agent-runtime/src/unieai-dsh/acp-client.mjs

@@ -17,13 +17,23 @@ export const ACP_PROTOCOL_VERSION = 1;
 
 export class AcpError extends Error {
   constructor(message, { code, data } = {}) {
-    super(message);
+    // dsh answers an internal failure with "Internal error" and puts what
+    // actually went wrong in `data.details`. Dropping it left the user with
+    // a message that says nothing at all.
+    super(detailed(message, data));
     this.name = "AcpError";
     this.code = code;
     this.data = data;
   }
 }
 
+/** `message`, with the detail dsh attached when it adds anything. */
+function detailed(message, data) {
+  const details = typeof data?.details === "string" ? data.details.trim() : "";
+  if (!details || String(message).includes(details)) return String(message);
+  return `${message}: ${details}`;
+}
+
 /**
  * Speak ACP over an already-open pair of streams. Split from the spawning so
  * tests can drive it with an in-memory agent.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unieai/code",
-  "version": "0.0.30",
+  "version": "0.0.31",
   "description": "UnieAI Code is a coding agent that runs locally on your computer.",
   "license": "Apache-2.0",
   "bin": {
@@ -282,11 +282,11 @@
     "@deepseek-ai/schemastery": "3.18.2"
   },
   "optionalDependencies": {
-    "@unieai/code-linux-x64": "npm:@unieai/code@0.0.30-linux-x64",
-    "@unieai/code-linux-arm64": "npm:@unieai/code@0.0.30-linux-arm64",
-    "@unieai/code-darwin-x64": "npm:@unieai/code@0.0.30-darwin-x64",
-    "@unieai/code-darwin-arm64": "npm:@unieai/code@0.0.30-darwin-arm64",
-    "@unieai/code-win32-x64": "npm:@unieai/code@0.0.30-win32-x64",
-    "@unieai/code-win32-arm64": "npm:@unieai/code@0.0.30-win32-arm64"
+    "@unieai/code-linux-x64": "npm:@unieai/code@0.0.31-linux-x64",
+    "@unieai/code-linux-arm64": "npm:@unieai/code@0.0.31-linux-arm64",
+    "@unieai/code-darwin-x64": "npm:@unieai/code@0.0.31-darwin-x64",
+    "@unieai/code-darwin-arm64": "npm:@unieai/code@0.0.31-darwin-arm64",
+    "@unieai/code-win32-x64": "npm:@unieai/code@0.0.31-win32-x64",
+    "@unieai/code-win32-arm64": "npm:@unieai/code@0.0.31-win32-arm64"
   }
 }