@turns/dev 0.0.21 → 0.0.23

package/dist/agent-anchor.js

@@ -209,6 +209,8 @@ class LineTransport {
  */
 const CLAUDE_NOTIFICATION_RESULT_GRACE_MS = 2_000;
 class ClaudeTransport extends LineTransport {
+    model;
+    thinkingLevel;
     nativeTurnActive = false;
     sessionId;
     permissionMode;
@@ -242,6 +244,8 @@ class ClaudeTransport extends LineTransport {
         super(anchor, 'claude', resolveHarnessCommand('claude', profile), args, anchor.cwd, {
             CLAUDE_CODE_ENTRYPOINT: 'turns-agent-anchor',
         });
+        this.model = anchor.model;
+        this.thinkingLevel = anchor.thinkingLevel;
         this.sessionId = anchor.agentSessionId;
         this.permissionMode = anchor.permissionMode;
         this.turnWaiter = null;
@@ -789,7 +793,12 @@ class CodexAppServerTransport extends LineTransport {
         this.turnId = null;
         this.turnIdWaiter = deferred();
         this.turnWaiter = waiter;
-        const started = await this.request('turn/start', { threadId: this.threadId, input: [{ type: 'text', text }] }, timeoutMs).catch((error) => {
+        const started = await this.request('turn/start', {
+            threadId: this.threadId,
+            input: [{ type: 'text', text }],
+            ...(this.anchor.model && this.anchor.model !== 'auto' ? { model: this.anchor.model } : {}),
+            ...(this.anchor.thinkingLevel ? { effort: this.anchor.thinkingLevel } : {}),
+        }, timeoutMs).catch((error) => {
             if (this.turnWaiter === waiter)
                 this.turnWaiter = null;
             this.turnIdWaiter?.resolve('');
@@ -1491,6 +1500,7 @@ class Anchor {
             protocol: 'turns.agent-anchor.v1',
             owner: 'turns.dev',
             capabilities: [
+                'model_settings',
                 'interrupt',
                 'shutdown',
                 'answer_interaction',
@@ -1733,8 +1743,10 @@ class Anchor {
             cwd: path.resolve(request.cwd),
             transcriptPath: path.resolve(request.transcriptPath),
             workerId: String(request.workerId || ''),
-            model: String(request.model || ''),
-            thinkingLevel: String(request.thinkingLevel || ''),
+            // Launch hints disappear after binding. Keep a warm session's choices
+            // until the next explicit selection; never leak them across identities.
+            model: String(request.model || (request.sessionId === this.sessionId ? this.model : '') || ''),
+            thinkingLevel: String(request.thinkingLevel || (request.sessionId === this.sessionId ? this.thinkingLevel : '') || ''),
             permissionMode: requestedPermissionMode(request.permissionMode),
             codexHistoryMode,
             idleTimeoutMs: Math.max(1_000, Number(request.idleTimeoutMs) || 300_000),
@@ -1776,6 +1788,8 @@ class Anchor {
             if (!(this.transport instanceof ClaudeTransport) ||
                 this.transport.child.exitCode !== null ||
                 this.transport.sessionId !== this.agentSessionId ||
+                this.transport.model !== this.model ||
+                this.transport.thinkingLevel !== this.thinkingLevel ||
                 this.transport.permissionMode !== this.permissionMode) {
                 this.transport?.stop?.();
                 this.transport = new ClaudeTransport(this, createSession);

package/dist/queue-worker.js

@@ -559,21 +559,25 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
         }
         bindAnchor(connection, snapshot);
     }
-    const usableAnchor = async (sessionId, source, agentSessionId) => {
+    const usableAnchor = async (sessionId, source, agentSessionId, modelSettings = false) => {
         let entry = anchors.get(sessionId);
         if (entry && !entry.connection.closed) {
             entry.snapshot = await entry.connection.request('snapshot', {}, 5_000).catch(() => entry.snapshot);
             if (String(entry.snapshot.source || '') === source &&
-                String(entry.snapshot.agentSessionId || '') === agentSessionId)
+                String(entry.snapshot.agentSessionId || '') === agentSessionId &&
+                (!modelSettings || entry.snapshot.capabilities?.includes('model_settings')))
                 return entry;
             if (entry.snapshot.status === 'running')
-                throw new Error('The surviving anchor is running a different session identity.');
+                throw new Error('The surviving anchor must finish its turn before it can be replaced.');
             await entry.connection.request('shutdown', {}, 2_000).catch(() => { });
             entry.connection.close();
             anchors.delete(sessionId);
         }
         const connection = await launchAgentAnchor(sessionId);
         entry = bindAnchor(connection, connection.snapshot || {}, sessionId);
+        if (modelSettings && !entry.snapshot.capabilities?.includes('model_settings')) {
+            throw new Error('The installed agent anchor does not support session model settings. Update the Turns CLI.');
+        }
         await reportHarness(sessionId, 'idle', entry);
         return entry;
     };
@@ -684,7 +688,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             // Codex installation leaves a recoverable unsent prompt in the queue.
             if (descriptor.harness === 'codex')
                 resolveHarnessCommand('codex');
-            entry = await usableAnchor(sessionId, descriptor.harness, agentSessionId);
+            entry = await usableAnchor(sessionId, descriptor.harness, agentSessionId, Boolean(claim.session?.modelSettings));
         }
         if (!entry)
             throw new Error(`No surviving agent anchor exists for ${sessionId}.`);
@@ -1399,6 +1403,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 machineId: machine,
                 machineHostname: os.hostname(),
                 capabilities: {
+                    sessionModelSettings: true,
                     fileSearch: true,
                     git: true,
                     fileRanges: true,

package/dist/upload-sessions.js

@@ -24,6 +24,11 @@ const MAX_BATCH_ROWS = 100;
 const MAX_RUNTIME_EVENT_BATCH = 250;
 const RPC_TIMEOUT_MS = 5 * 60_000;
 const MAX_SOCKET_RETRIES = 8;
+/** Deadline for an uploader socket to finish its TCP, TLS, and upgrade
+ * handshake and receive the server's `ready` acknowledgement. A stalled
+ * handshake emits neither `error` nor `close`, so without this the daemon
+ * would wait in CONNECTING forever and silently stop uploading. */
+const READY_TIMEOUT_MS = 30_000;
 const MAX_NATIVE_SETTLE_PASSES = 4;
 const MAX_EXTERNAL_STATUS_BATCH = 1_000;
 const NATIVE_STATE_VERSION = 1;
@@ -548,28 +553,43 @@ export class RpcSocket {
     resolveClosed;
     ready;
     socket;
-    constructor(url, token, devUser = '') {
+    constructor(url, token, devUser = '', { readyTimeoutMs = READY_TIMEOUT_MS } = {}) {
         this.pending = new Map();
         this.listeners = new Set();
         this.closed = new Promise((resolve) => {
             this.resolveClosed = resolve;
         });
         this.ready = new Promise((resolve, reject) => {
+            // Settle exactly once so the deadline, the socket's own events, and the
+            // abort error that `terminate()` raises afterwards cannot race.
+            let settled = false;
+            let readyTimer = null;
+            const settle = (complete, value) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(readyTimer);
+                complete(value);
+            };
+            readyTimer = setTimeout(() => {
+                settle(reject, socketError(`Turns did not acknowledge the uploader within ${readyTimeoutMs / 1000} seconds.`));
+                this.socket.terminate();
+            }, readyTimeoutMs);
             const headers = devUser
                 ? { 'x-turns-dev-user': devUser, 'x-turns-dev-role': 'uploader' }
                 : { Authorization: `Bearer ${token}` };
-            this.socket = new WebSocket(url, { headers });
+            this.socket = new WebSocket(url, { headers, handshakeTimeout: readyTimeoutMs });
             this.socket.once('unexpected-response', (_request, response) => {
                 response.resume?.();
                 if (response.statusCode === 401 || response.statusCode === 403) {
-                    reject(authenticationError(`Turns rejected uploader authentication (HTTP ${response.statusCode}).`));
+                    settle(reject, authenticationError(`Turns rejected uploader authentication (HTTP ${response.statusCode}).`));
                 }
                 else {
-                    reject(socketError(`Unexpected WebSocket response (HTTP ${response.statusCode}).`));
+                    settle(reject, socketError(`Unexpected WebSocket response (HTTP ${response.statusCode}).`));
                 }
             });
-            this.socket.once('error', (error) => reject(socketError(`WebSocket connection failed: ${error.message}`, error)));
-            this.socket.on('message', (data) => this.onMessage(String(data), resolve, reject));
+            this.socket.once('error', (error) => settle(reject, socketError(`WebSocket connection failed: ${error.message}`, error)));
+            this.socket.on('message', (data) => this.onMessage(String(data), (ready) => settle(resolve, ready), (error) => settle(reject, error)));
             this.socket.on('close', (code, reason) => {
                 const error = socketError(`WebSocket closed (${code}): ${String(reason)}`);
                 for (const request of this.pending.values()) {
@@ -665,7 +685,9 @@ export async function connectUploader(options, machine, reconnect = false) {
             const credentials = await options.credentialProvider.refreshIfDue();
             options.token = credentials.accessToken;
         }
-        const rpc = new RpcSocket(options.url, options.token, options.devUser);
+        const rpc = new RpcSocket(options.url, options.token, options.devUser, {
+            readyTimeoutMs: options.readyTimeoutMs,
+        });
         try {
             const ready = await rpc.ready;
             process.stdout.write(`${reconnect ? 'Reconnected' : 'Connected'} to ${options.url} as @${ready.user.login} ` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turns/dev",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",