devez-vibe 0.1.43 → 0.1.45

package/bridge/claude-agent-sdk-bridge.mjs

@@ -7,10 +7,10 @@ import {
   deleteSession,
   forkSession,
   getSessionInfo,
-  getSessionMessages,
-  listSessions,
-  query,
-} from "@anthropic-ai/claude-agent-sdk";
+  getSessionMessages,
+  listSessions,
+  startup,
+} from "@anthropic-ai/claude-agent-sdk";
 
 const VERSION = process.env.DEVEZ_VIBE_VERSION || "dev";
 const sessions = new Map();
@@ -82,13 +82,23 @@ function hostRequest(method, params, signal) {
   });
 }
 
-function sanitizedEnvironment() {
+function sanitizedEnvironment() {
   const env = { ...process.env };
   delete env.ANTHROPIC_API_KEY;
   delete env.ANTHROPIC_AUTH_TOKEN;
   env.CLAUDE_AGENT_SDK_CLIENT_APP = `devez-vibe/${VERSION}`;
-  return env;
-}
+  return env;
+}
+
+function applyClaudeExecutable(options, params) {
+  const executable = String(params.claudePath || "").trim();
+  if (!executable) return;
+  // On Windows use the SDK's matching native CLI bundle. It reads the same
+  // ~/.claude credentials, settings, hooks, skills, and plugins, while avoiding
+  // EINVAL from command shims and incompatible separately-installed CLI builds.
+  if (process.platform === "win32") return;
+  options.pathToClaudeCodeExecutable = executable;
+}
 
 function modelCapabilities(models, model) {
   const value = stripClaudeModel(model);
@@ -125,7 +135,7 @@ function compactClaudeModelName(model) {
   return fallback || clean(model.displayName || model.resolvedModel || model.value);
 }
 
-function catalogEntry(model) {
+function catalogEntry(model, defaultResolvedModel) {
   const value = String(model.value || "");
   const resolved = String(model.resolvedModel || value);
   const efforts = model.supportsEffort && Array.isArray(model.supportedEffortLevels)
@@ -138,7 +148,7 @@ function catalogEntry(model) {
     displayName: compactClaudeModelName(model),
     defaultReasoningEffort: efforts.includes("high") ? "high" : efforts.at(-1) || "",
     supportedReasoningEfforts: efforts.map((reasoningEffort) => ({ reasoningEffort })),
-    isDefault: false,
+    isDefault: Boolean(defaultResolvedModel) && resolved === defaultResolvedModel,
     ...(contextWindow > 0 ? { contextWindow } : {}),
   };
 }
@@ -156,18 +166,21 @@ async function loadModelCatalog(params) {
       env: sanitizedEnvironment(),
       stderr: (data) => process.stderr.write(data),
     };
-    if (params.claudePath) options.pathToClaudeCodeExecutable = params.claudePath;
-    const agentQuery = query({ prompt: input, options });
+    applyClaudeExecutable(options, params);
+    const agentQuery = await startAgentQuery(input, options);
     const consumer = (async () => {
       try { for await (const _message of agentQuery) { /* initialization only */ } }
       catch { /* the caller receives the supportedModels error */ }
     })();
     try {
-      const models = await agentQuery.supportedModels();
-      return {
-        data: models
-          .filter((model) => model.value && model.value !== "default")
-          .map(catalogEntry),
+      const models = await agentQuery.supportedModels();
+      const defaultResolvedModel = String(
+        models.find((model) => model.value === "default")?.resolvedModel || "",
+      );
+      return {
+        data: models
+          .filter((model) => model.value && model.value !== "default")
+          .map((model) => catalogEntry(model, defaultResolvedModel)),
       };
     } finally {
       input.close();
@@ -202,7 +215,7 @@ function rawSession(id) {
   return id.startsWith("claude:") ? id.slice("claude:".length) : id;
 }
 
-function makeOptions(params, sessionId, resume) {
+function makeOptions(params, sessionId, resume) {
   const options = {
     cwd: params.cwd || process.cwd(),
     includePartialMessages: true,
@@ -223,13 +236,23 @@ function makeOptions(params, sessionId, resume) {
   const model = stripClaudeModel(params.model);
   if (model) options.model = model;
   if (params.effort) options.effort = params.effort;
-  if (params.claudePath) options.pathToClaudeCodeExecutable = params.claudePath;
+  applyClaudeExecutable(options, params);
   if (resume) options.resume = resume;
   else options.sessionId = sessionId;
   options.canUseTool = (toolName, input, permission) =>
     requestToolPermission(toolName, input, permission);
-  return options;
-}
+  return options;
+}
+
+async function startAgentQuery(prompt, options) {
+  const warm = await startup({ options });
+  try {
+    return warm.query(prompt);
+  } catch (error) {
+    warm.close();
+    throw error;
+  }
+}
 
 async function requestToolPermission(toolName, input, permission) {
   if (toolName === "AskUserQuestion") {
@@ -317,10 +340,7 @@ async function createSession(params, resumeId) {
     tools: new Map(),
     tasks: new Map(),
   };
-  const agentQuery = query({
-    prompt: queue,
-    options: makeOptions(params, id, resumeId),
-  });
+  const agentQuery = await startAgentQuery(queue, makeOptions(params, id, resumeId));
   session.query = agentQuery;
   sessions.set(id, session);
   const consumer = consume(session).catch((error) => {
@@ -333,7 +353,16 @@ async function createSession(params, resumeId) {
     if (session.turn) finishTurn(session, error);
   });
   session.consumer = consumer;
-  const initialization = await agentQuery.initializationResult();
+  let initialization;
+  try {
+    initialization = await agentQuery.initializationResult();
+  } catch (error) {
+    sessions.delete(id);
+    queue.close();
+    agentQuery.close();
+    await Promise.race([consumer, new Promise((resolve) => setTimeout(resolve, 1000))]);
+    throw error;
+  }
   session.models = Array.isArray(initialization.models) ? initialization.models : [];
   session.effort = supportedEffort(modelCapabilities(session.models, params.model), params.effort);
   const account = initialization.account || await safeAccount(agentQuery);
@@ -644,8 +673,34 @@ async function consume(session) {
   }
 }
 
-async function inputContent(input) {
-  const content = [];
+const HANDOFF_HEADER = '<devez_provider_handoff chars="';
+const HANDOFF_SEPARATOR = '">\n';
+const HANDOFF_FOOTER = "\n</devez_provider_handoff>\n\n";
+
+function prependHandoff(content, handoffContext) {
+  if (!handoffContext) return content;
+  const handoff = String(handoffContext);
+  const prefix = `${HANDOFF_HEADER}${handoff.length}${HANDOFF_SEPARATOR}${handoff}${HANDOFF_FOOTER}`;
+  const firstText = content.find((item) => item.type === "text");
+  if (firstText) firstText.text = `${prefix}${firstText.text || ""}`;
+  else content.unshift({ type: "text", text: prefix });
+  return content;
+}
+
+function stripHandoff(text) {
+  if (!text.startsWith(HANDOFF_HEADER)) return text;
+  const separator = text.indexOf(HANDOFF_SEPARATOR, HANDOFF_HEADER.length);
+  if (separator < 0) return text;
+  const length = Number(text.slice(HANDOFF_HEADER.length, separator));
+  if (!Number.isSafeInteger(length) || length < 0) return text;
+  const contextStart = separator + HANDOFF_SEPARATOR.length;
+  const contextEnd = contextStart + length;
+  if (text.slice(contextEnd, contextEnd + HANDOFF_FOOTER.length) !== HANDOFF_FOOTER) return text;
+  return text.slice(contextEnd + HANDOFF_FOOTER.length);
+}
+
+async function inputContent(input, handoffContext) {
+  const content = [];
   for (const item of Array.isArray(input) ? input : []) {
     if (item.type === "text") content.push({ type: "text", text: item.text || "" });
     else if (item.type === "localImage" && item.path) {
@@ -658,7 +713,7 @@ async function inputContent(input) {
       content.push({ type: "image", source: { type: "base64", media_type: mediaType, data: bytes.toString("base64") } });
     }
   }
-  return content.length ? content : [{ type: "text", text: "" }];
+  return prependHandoff(content.length ? content : [{ type: "text", text: "" }], handoffContext);
 }
 
 async function startPrompt(params) {
@@ -679,9 +734,9 @@ async function startPrompt(params) {
   const turnId = `claude-turn-${session.turnSequence++}-${randomUUID()}`;
   session.turn = { id: turnId, sawStreamText: false };
   notify("turn/started", { threadId: id, turn: { id: turnId } });
-  session.queue.push({
-    type: "user",
-    message: { role: "user", content: await inputContent(params.input) },
+  session.queue.push({
+    type: "user",
+    message: { role: "user", content: await inputContent(params.input, params.handoffContext) },
     parent_tool_use_id: null,
     session_id: id,
     origin: { kind: "human" },
@@ -702,8 +757,8 @@ function historyTurns(messages) {
   const tasks = new Map();
   for (const message of messages) {
     const blocks = contentBlocks(message.message);
-    const userText = message.type === "user"
-      ? blocks.filter((block) => block.type === "text").map((block) => block.text || "").join("\n")
+    const userText = message.type === "user"
+      ? stripHandoff(blocks.filter((block) => block.type === "text").map((block) => block.text || "").join("\n"))
       : "";
     if (userText && !blocks.some((block) => block.type === "tool_result")) {
       turn = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devez-vibe",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "description": "Stable terminal UI for Codex and Claude Agent SDK",
   "keywords": [
     "codex",