clay-server 2.33.0-beta.2 → 2.33.0

package/lib/yoke/adapters/codex.js

@@ -89,6 +89,23 @@ function generateUuid() {
   return "codex-" + ts + "-" + cnt + "-" + rnd;
 }
 
+function normalizePlanStatus(status) {
+  if (status === "inProgress") return "in_progress";
+  if (status === "completed") return "completed";
+  return "pending";
+}
+
+function extractPromptSuggestion(params) {
+  if (!params) return "";
+  if (typeof params.suggestion === "string") return params.suggestion;
+  if (typeof params.promptSuggestion === "string") return params.promptSuggestion;
+  if (typeof params.suggestedPrompt === "string") return params.suggestedPrompt;
+  if (Array.isArray(params.suggestions) && typeof params.suggestions[0] === "string") return params.suggestions[0];
+  if (Array.isArray(params.promptSuggestions) && typeof params.promptSuggestions[0] === "string") return params.promptSuggestions[0];
+  if (Array.isArray(params.followUpSuggestions) && typeof params.followUpSuggestions[0] === "string") return params.followUpSuggestions[0];
+  return "";
+}
+
 function flattenEvent(notification, state) {
   var events = [];
   var method = notification.method;
@@ -142,6 +159,21 @@ function flattenEvent(notification, state) {
     return events;
   }
 
+  if (method === "turn/plan/updated") {
+    events.push({
+      yokeType: "plan_updated",
+      turnId: params.turnId || null,
+      explanation: params.explanation || "",
+      plan: Array.isArray(params.plan) ? params.plan.map(function(step) {
+        return {
+          step: step && step.step ? step.step : "",
+          status: normalizePlanStatus(step && step.status),
+        };
+      }) : [],
+    });
+    return events;
+  }
+
   if (method === "turn/failed") {
     events.push({
       yokeType: "error",
@@ -202,6 +234,20 @@ function flattenEvent(notification, state) {
     return events;
   }
 
+  if (method === "item/plan/delta") {
+    var planDeltaItemId = params.itemId || params.id;
+    var nextPlanText = (state.planTexts[planDeltaItemId] || "") + (params.delta || "");
+    if (planDeltaItemId) state.planTexts[planDeltaItemId] = nextPlanText;
+    if (nextPlanText) {
+      events.push({
+        yokeType: "plan_content",
+        content: nextPlanText,
+        itemId: planDeltaItemId || null,
+      });
+    }
+    return events;
+  }
+
   // serverRequest/resolved - confirmation that an approval was processed
   if (method === "serverRequest/resolved") {
     return events; // no-op, approval already handled
@@ -214,6 +260,27 @@ function flattenEvent(notification, state) {
 
     var evtPhase = method.split("/")[1]; // "started", "updated", "completed"
 
+    if (item.type === "plan") {
+      if (typeof item.text === "string") {
+        state.planTexts[item.id] = item.text;
+        events.push({
+          yokeType: "plan_content",
+          content: item.text,
+          itemId: item.id,
+          final: evtPhase === "completed",
+        });
+      }
+      return events;
+    }
+
+    if (item.type === "contextCompaction" || item.type === "context_compaction") {
+      events.push({
+        yokeType: "status",
+        status: evtPhase === "completed" ? "processing" : "compacting",
+      });
+      return events;
+    }
+
     // Agent message (text response)
     if (item.type === "agentMessage" || item.type === "agent_message") {
       if (!state.textBlocks[item.id]) {
@@ -262,6 +329,8 @@ function flattenEvent(notification, state) {
 
     // Command execution (bash/shell)
     if (item.type === "commandExecution" || item.type === "command_execution") {
+      var commandText = item.command || state.commandInputs[item.id] || "";
+      if (commandText) state.commandInputs[item.id] = commandText;
       if (!state.toolBlocks[item.id]) {
         state.blockCounter++;
         state.toolBlocks[item.id] = "blk_" + state.blockCounter;
@@ -277,7 +346,7 @@ function flattenEvent(notification, state) {
           blockId: toolBlockId,
           toolId: item.id,
           toolName: "Bash",
-          input: { command: item.command },
+          input: { command: commandText },
         });
       }
       if (evtPhase === "completed") {
@@ -294,6 +363,9 @@ function flattenEvent(notification, state) {
 
     // File change
     if (item.type === "fileChange" || item.type === "file_change") {
+      var changes = item.changes || [];
+      var changeDesc = changes.map(function(c) { return c.kind + " " + c.path; }).join(", ");
+      var primaryPath = changes.length === 1 ? (changes[0].path || "") : "";
       if (!state.toolBlocks[item.id]) {
         state.blockCounter++;
         state.toolBlocks[item.id] = "blk_" + state.blockCounter;
@@ -304,21 +376,26 @@ function flattenEvent(notification, state) {
           toolId: item.id,
           toolName: "Edit",
         });
-        var changeDesc = (item.changes || []).map(function(c) { return c.kind + " " + c.path; }).join(", ");
         events.push({
           yokeType: "tool_executing",
           blockId: fcBlockId,
           toolId: item.id,
           toolName: "Edit",
-          input: { changes: changeDesc },
+          input: {
+            changes: changeDesc,
+            file_path: primaryPath || undefined,
+          },
         });
       }
       if (evtPhase === "completed") {
+        var diffText = changes.map(function(c) {
+          return c && c.diff ? c.diff : "";
+        }).filter(Boolean).join("\n\n");
         events.push({
           yokeType: "tool_result",
           toolId: item.id,
           blockId: state.toolBlocks[item.id],
-          content: item.status === "completed" ? "Changes applied" : "Changes failed",
+          content: diffText || (item.status === "completed" ? "Changes applied" : "Changes failed"),
           isError: item.status === "failed",
         });
       }
@@ -397,6 +474,15 @@ function flattenEvent(notification, state) {
     return events;
   }
 
+  var promptSuggestion = extractPromptSuggestion(params);
+  if (promptSuggestion) {
+    events.push({
+      yokeType: "prompt_suggestion",
+      suggestion: promptSuggestion,
+    });
+    return events;
+  }
+
   // Unknown event type - pass through
   console.log("[yoke/codex] UNHANDLED event:", method, JSON.stringify(params).substring(0, 200));
   events.push({
@@ -415,6 +501,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
   var abortController = queryOpts.abortController;
   var systemPrompt = queryOpts.systemPrompt || "";
   var canUseTool = queryOpts.canUseTool || null;
+  var onElicitation = queryOpts.onElicitation || null;
 
   // Check if the query was cancelled (either via handle.abort() or direct signal abort)
   function isCancelled() {
@@ -437,6 +524,8 @@ function createCodexQueryHandle(appServer, queryOpts) {
     thinkingBlocks: {}, // itemId -> blockId
     thinkingLengths: {}, // itemId -> last sent length
     toolBlocks: {},     // itemId -> blockId (for tool_start dedup)
+    commandInputs: {},  // itemId -> command captured from approval/start events
+    planTexts: {},      // itemId -> streamed plan text
   };
 
   // Internal event buffer for async iterator
@@ -512,6 +601,9 @@ function createCodexQueryHandle(appServer, queryOpts) {
     // Command approval request
     if (method === "item/commandExecution/requestApproval") {
       var cmdParams = msg.params || {};
+      if (cmdParams.itemId && cmdParams.command) {
+        state.commandInputs[cmdParams.itemId] = cmdParams.command;
+      }
       if (canUseTool) {
         canUseTool("Bash", { command: cmdParams.command }, {}).then(function(decision) {
           var approved = isApproved(decision);
@@ -549,7 +641,45 @@ function createCodexQueryHandle(appServer, queryOpts) {
       var mcpParams = msg.params || {};
       var mcpMeta = mcpParams._meta || {};
       console.log("[yoke/codex] MCP approval request:", (mcpMeta.tool || "?"), "server=" + (mcpParams.serverName || "?"));
-      if (canUseTool) {
+      if (onElicitation) {
+        var request = {
+          serverName: mcpParams.serverName || (mcpMeta.tool || "Tool"),
+          message: mcpParams.message || mcpParams.prompt || "",
+          mode: mcpParams.url ? "url" : "form",
+          url: mcpParams.url || null,
+          elicitationId: mcpParams.elicitationId || null,
+          requestedSchema: mcpParams.requestedSchema || null,
+        };
+        if (!request.requestedSchema && Array.isArray(mcpParams.questions) && mcpParams.questions.length > 0) {
+          var schema = { type: "object", properties: {}, required: [] };
+          for (var qi = 0; qi < mcpParams.questions.length; qi++) {
+            var q = mcpParams.questions[qi];
+            var qid = q.id || ("question_" + (qi + 1));
+            schema.required.push(qid);
+            if (Array.isArray(q.options) && q.options.length > 0) {
+              schema.properties[qid] = {
+                type: "string",
+                description: q.question || q.prompt || qid,
+                enum: q.options.map(function(opt) { return opt && (opt.value || opt.label) ? (opt.value || opt.label) : ""; }).filter(Boolean),
+              };
+            } else {
+              schema.properties[qid] = {
+                type: "string",
+                description: q.question || q.prompt || qid,
+              };
+            }
+          }
+          request.requestedSchema = schema;
+        }
+        onElicitation(request, {
+          signal: { addEventListener: function() {} },
+        }).then(function(result) {
+          appServer.respond(msg.id, result || { action: "reject" });
+        }).catch(function(err) {
+          console.error("[yoke/codex] elicitation_response send failed:", err.message || err);
+          appServer.respond(msg.id, { action: "reject" });
+        });
+      } else if (canUseTool) {
         canUseTool("mcp__" + (mcpParams.serverName || "unknown") + "__" + (mcpMeta.tool || "call"), mcpParams, {}).then(function(decision) {
           appServer.respond(msg.id, { action: isApproved(decision) ? "accept" : "decline" });
         }).catch(function(err) {
@@ -592,9 +722,9 @@ function createCodexQueryHandle(appServer, queryOpts) {
       // Start or resume thread
       var threadParams = {
         model: queryOpts.model || "gpt-5.4",
-        sandboxMode: queryOpts.sandboxMode || "workspace-write",
+        sandbox: queryOpts.sandboxMode || "workspace-write",
         approvalPolicy: queryOpts.approvalPolicy || "on-failure",
-        workingDirectory: queryOpts.cwd,
+        cwd: queryOpts.cwd,
         skipGitRepoCheck: true,
       };
       if (queryOpts.modelReasoningEffort) {
@@ -609,6 +739,9 @@ function createCodexQueryHandle(appServer, queryOpts) {
         threadResult = await appServer.send("thread/resume", {
           threadId: queryOpts.resumeSessionId,
           model: threadParams.model,
+          sandbox: threadParams.sandbox,
+          approvalPolicy: threadParams.approvalPolicy,
+          cwd: threadParams.cwd,
         }, 60000);
       } else {
         threadResult = await appServer.send("thread/start", threadParams, 60000);
@@ -626,6 +759,8 @@ function createCodexQueryHandle(appServer, queryOpts) {
         state.thinkingBlocks = {};
         state.thinkingLengths = {};
         state.toolBlocks = {};
+        state.commandInputs = {};
+        state.planTexts = {};
 
         // Start turn
         var turnPromise = new Promise(function(resolve) { turnResolve = resolve; });
@@ -822,7 +957,7 @@ function createCodexAdapter(opts) {
             betas: false,
             rewind: false,
             sessionResume: true,
-            promptSuggestions: false,
+            promptSuggestions: true,
             elicitation: true,
             fileCheckpointing: false,
             contextCompacting: false,
@@ -974,7 +1109,7 @@ function createCodexAdapter(opts) {
             betas: false,
             rewind: false,
             sessionResume: true,
-            promptSuggestions: false,
+            promptSuggestions: true,
             elicitation: true,
             fileCheckpointing: false,
             contextCompacting: false,
@@ -1014,6 +1149,7 @@ function createCodexAdapter(opts) {
         systemPrompt: queryOpts.systemPrompt || "",
         abortController: ac,
         canUseTool: queryOpts.canUseTool || null,
+        onElicitation: queryOpts.onElicitation || null,
         resumeSessionId: queryOpts.resumeSessionId || null,
       };
 

package/lib/yoke/index.js

@@ -162,7 +162,7 @@ function createAdapters(opts) {
  * Re-checks auth, creates adapter if now logged in.
  * Returns the adapter or null.
  */
-function lazyCreateAdapter(adapters, vendor, opts) {
+async function lazyCreateAdapter(adapters, vendor, opts) {
   if (_sharedAdapters && _sharedAdapters[vendor]) {
     adapters[vendor] = _sharedAdapters[vendor];
     return adapters[vendor];
@@ -177,8 +177,12 @@ function lazyCreateAdapter(adapters, vendor, opts) {
 
   try {
     var ad = createAdapter({ vendor: vendor, cwd: opts.cwd });
+    if (typeof ad.init === "function") {
+      await ad.init(opts || {});
+    }
     console.log("[yoke] Lazy adapter created: " + vendor);
     if (_sharedAdapters) _sharedAdapters[vendor] = ad;
+    if (_sharedAuth) _sharedAuth[vendor] = true;
     adapters[vendor] = ad;
     return ad;
   } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "2.33.0-beta.2",
+  "version": "2.33.0",
   "description": "Self-hosted Claude Code in your browser. Multi-session, multi-user, push notifications.",
   "bin": {
     "clay-server": "./bin/cli.js",