devez-vibe 1.9.40 → 1.9.42

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

@@ -1857,15 +1857,15 @@ function prepareTaskPlanForCreate(tasks, subject) {
 // 한 단계에 걸린 시간은 진행 중으로 바뀐 순간과 완료된 순간의 차이다. 기록에는
 // 항목마다 시각이 남으므로, 다시 읽을 때도 같은 방식으로 되살릴 수 있다.
 function markTaskStatus(task, status, at) {
-  if (task.status !== status) {
-    if (status === "in_progress") {
-      task.startedAt = at;
-      delete task.elapsedMs;
-    } else if (status === "completed" && task.startedAt != null && at != null) {
-      task.elapsedMs = Math.max(0, at - task.startedAt);
-    } else if (status === "pending") {
-      delete task.startedAt;
-      delete task.elapsedMs;
+  if (task.status !== status) {
+    if (status === "in_progress") {
+      task.startedAt = at;
+      delete task.elapsedMs;
+    } else if (status === "completed" && task.startedAt != null && at != null) {
+      task.elapsedMs = Math.max(0, at - task.startedAt);
+    } else if (status === "pending") {
+      delete task.startedAt;
+      delete task.elapsedMs;
     }
   }
   task.status = status;
@@ -1987,19 +1987,19 @@ function updatePlanFromToolResult(session, pending, message) {
     const turnId = session.turn?.id;
     const previous = session.tasks;
     session.tasks = new Map();
-    for (const task of value.tasks || value) {
-      const id = String(task.id);
-      const restored = {
-        id,
-        subject: task.subject || task.description || "작업",
-        status: previous.get(id)?.status || "pending",
+    for (const task of value.tasks || value) {
+      const id = String(task.id);
+      const restored = {
+        id,
+        subject: task.subject || task.description || "작업",
+        status: previous.get(id)?.status || "pending",
         // 이 턴에서 다룬 적 없는 작업은 이전 턴의 것이므로 원래 turnId를 지켜 준다.
-        turnId: previous.get(id)?.turnId ?? turnId,
-        startedAt: previous.get(id)?.startedAt,
-        elapsedMs: previous.get(id)?.elapsedMs,
-      };
-      markTaskStatus(restored, task.status || "pending", Date.now());
-      session.tasks.set(id, restored);
+        turnId: previous.get(id)?.turnId ?? turnId,
+        startedAt: previous.get(id)?.startedAt,
+        elapsedMs: previous.get(id)?.elapsedMs,
+      };
+      markTaskStatus(restored, task.status || "pending", Date.now());
+      session.tasks.set(id, restored);
     }
     session.tasks = latestTaskPlan(session.tasks);
     emitPlan(session);
@@ -2027,11 +2027,11 @@ function emitPlan(session) {
   notify("turn/plan/updated", {
     threadId: session.id,
     turnId: session.turn?.id,
-    plan: [...session.tasks.values()].map((task, index) => ({
-      id: task.id,
-      step: numberedTaskSubject(task.subject, index),
-      status: planStatus(task.status),
-      elapsedMs: task.elapsedMs ?? null,
+    plan: [...session.tasks.values()].map((task, index) => ({
+      id: task.id,
+      step: numberedTaskSubject(task.subject, index),
+      status: planStatus(task.status),
+      elapsedMs: task.elapsedMs ?? null,
     })),
   });
 }
@@ -2238,6 +2238,8 @@ function upsertStructuredSubagent(session, message) {
   }
   if (toolUseId) running.toolUseId = toolUseId;
   if (taskId) running.taskId = taskId;
+  const parentTaskId = firstLine(message.parent_task_id || "", 80);
+  if (parentTaskId) running.parentTaskId = parentTaskId;
   // Agent 호출이 붙인 작업 이름이 있으면 SDK가 뒤늦게 알려 주는 에이전트 종류로 덮지 않는다.
   if (subagentType && (!running.name || running.name === "agent")) running.name = subagentType;
   if (subagentType || isSubagentTaskType(message.task_type)) running.backgroundTask = false;
@@ -2319,6 +2321,11 @@ function syncBackgroundSubagents(session, tasks) {
     }
     running.background = true;
     running.lastSeenAt = Date.now();
+    const parentTaskId = firstLine(task?.parent_task_id || "", 80);
+    if (parentTaskId && parentTaskId !== running.parentTaskId) {
+      running.parentTaskId = parentTaskId;
+      changed = true;
+    }
     // 에이전트 행은 이름만 보이지만, 백그라운드 명령 행은 명령문이 곧 내용이다.
     const description = isSubagentTaskType(task?.task_type)
       ? ""
@@ -2412,8 +2419,14 @@ function processSubagentSystemMessage(session, message) {
 
 // 서브에이전트가 실제로 무엇을 했는지는 자식 메시지에만 남는다. 열람용 기록은 여기서
 // 한 줄씩 흘려보내고, 목록 행에 쓸 현재 도구만 따로 갱신한다.
+// 메시지의 agent_id는 그 하위 에이전트 작업의 task_id라 재개 뒤에도 같은 행을 찾는다.
+function messageSubagent(session, message) {
+  return findSubagent(session, message.parent_tool_use_id)
+    || (message.agent_id ? findSubagent(session, message.agent_id) : undefined);
+}
+
 function recordSubagentMessage(session, message) {
-  const running = findSubagent(session, message.parent_tool_use_id);
+  const running = messageSubagent(session, message);
   if (!running) return;
   running.lastSeenAt = Date.now();
   const content = Array.isArray(message.message?.content) ? message.message.content : [];
@@ -2436,7 +2449,7 @@ function recordSubagentMessage(session, message) {
 }
 
 function recordSubagentResult(session, message) {
-  const running = findSubagent(session, message.parent_tool_use_id);
+  const running = messageSubagent(session, message);
   if (!running) return;
   running.lastSeenAt = Date.now();
   const content = Array.isArray(message.message?.content) ? message.message.content : [];
@@ -2515,6 +2528,37 @@ function firstLine(value, limit) {
   return String(value ?? "").split("\n")[0].trim().slice(0, limit);
 }
 
+// SDK 0.3.292부터 하위 에이전트가 띄운 에이전트·명령에 parent_task_id가 붙는다.
+// 자식 행을 부모 행 바로 아래로 모아 깊이와 함께 보내면 호스트가 들여 그린다.
+// 부모가 이미 끝났거나 모르는 id면 최상위에 둔다.
+function subagentRows(session) {
+  const agents = [...session.subagents.values()];
+  const byTask = new Map(agents.filter((agent) => agent.taskId).map((agent) => [agent.taskId, agent]));
+  const children = new Map();
+  const roots = [];
+  for (const agent of agents) {
+    const parent = agent.parentTaskId ? byTask.get(agent.parentTaskId) : null;
+    if (parent && parent !== agent) {
+      if (!children.has(parent)) children.set(parent, []);
+      children.get(parent).push(agent);
+    } else {
+      roots.push(agent);
+    }
+  }
+  const rows = [];
+  const placed = new Set();
+  const place = (agent, depth) => {
+    if (placed.has(agent)) return;
+    placed.add(agent);
+    rows.push({ agent, depth });
+    for (const child of children.get(agent) || []) place(child, depth + 1);
+  };
+  for (const agent of roots) place(agent, 0);
+  // 서로를 부모로 가리키는 행은 뿌리가 없으므로 최상위로 살린다.
+  for (const agent of agents) place(agent, 0);
+  return rows;
+}
+
 function emitSubagents(session) {
   // 백그라운드 행은 조용하다고 지우지 않는다. 오래 걸리는 조사 에이전트는 진행
   // 신호 없이 몇 분을 보내므로, 종료 통지와 level 스냅숏만 행을 거둔다.
@@ -2528,13 +2572,14 @@ function emitSubagents(session) {
   notify("turn/subagents/updated", {
     threadId: session.id,
     turnId: session.turn?.id,
-    subagents: [...session.subagents.values()].map((agent) => ({
+    subagents: subagentRows(session).map(({ agent, depth }) => ({
       id: agent.id,
       name: agent.name,
       description: agent.description,
       backgroundTask: agent.backgroundTask === true,
       tool: agent.tool,
       elapsedMs: Date.now() - agent.startedAt,
+      depth,
     })),
   });
 }
@@ -2778,6 +2823,7 @@ function cancelUsageLimitWait(session) {
 // 조치를 바로 알기 어려우므로 사유가 있을 때만 앞줄에 한국어 안내를 붙인다.
 const STARTUP_FAILURE_GUIDES = {
   org_pin_api_key_conflict: "조직 설정이 지정한 로그인 대신 API 키가 설정되어 있습니다. API 키·인증 토큰 환경 변수를 지우고 지정된 계정으로 로그인하세요.",
+  provider_not_allowed: "조직 설정이 허용하지 않는 API 제공자로 연결하도록 설정되어 있습니다. 허용된 제공자로 로그인하거나 관리자에게 문의하세요.",
   org_verify_failed: "로그인 계정의 조직을 확인하지 못했습니다. 네트워크를 확인하고 다시 로그인하세요.",
   org_pin_mismatch: "조직 설정이 허용하지 않는 계정으로 로그인되어 있습니다. 허용된 조직 계정으로 다시 로그인하세요.",
   managed_settings_invalid: "조직 관리 설정을 읽지 못했습니다. 관리자에게 설정 확인을 요청하세요.",
@@ -2871,13 +2917,28 @@ async function processResult(session, message) {
     notify("warning", { threadId: session.id, provider: "Claude", message: `Claude response error: ${text}` });
   }
   if (error && waitForUsageLimit(session)) return;
-  finishTurn(session, error, message.duration_ms);
-  notify("claude/account/updated", {
-    threadId: session.id,
-    account: await safeAccount(session.query),
-    usage: await safeUsage(session.query),
-  });
-  await runPendingPrompt(session);
+  // A steer the CLI could not fold into this run gets a run of its own, which
+  // `queued_turn_count` announces. Closing the turn here dropped the host's
+  // spinner and filed a completion until that answer's first frame arrived.
+  // A count of 0 can still hide a steer read just after the result; the steer
+  // debt opens a fresh turn for it then, as before.
+  const steerFollows = !error && !interrupted && !assistantError
+    && session.steerPending > 0 && message.queued_turn_count > 0;
+  if (steerFollows) {
+    session.steerPending -= 1;
+    session.turn.awaitingSteer = true;
+    releaseHeldProgress(session);
+    flushPendingPlan(session);
+    clearForegroundSubagents(session);
+  } else {
+    finishTurn(session, error, message.duration_ms);
+  }
+  // Not awaited: the next run's frames queue behind this message, and the
+  // account lookup used to hold them back.
+  Promise.all([safeAccount(session.query), safeUsage(session.query)])
+    .then(([account, usage]) => notify("claude/account/updated", { threadId: session.id, account, usage }))
+    .catch(() => {});
+  if (!steerFollows) await runPendingPrompt(session);
 }
 
 // Compaction ends the turn's only assistant message, so the context figure would
@@ -2975,12 +3036,13 @@ function beginUntrackedTurn(session, message) {
   return true;
 }
 
-async function consumeMessage(session, message) {
-  adoptSessionId(session, message.session_id);
+async function consumeMessage(session, message) {
+  adoptSessionId(session, message.session_id);
   beginUntrackedTurn(session, message);
   // A queued SDK response may beat the timer. It already resumes the work.
   if (!message.parent_tool_use_id && (message.type === "assistant" || message.type === "stream_event")) {
     clearUsageLimitWait(session);
+    if (session.turn) session.turn.awaitingSteer = false;
   }
   if (message.type === "stream_event") {
     if (message.event?.type === "content_block_delta" && (message.event?.delta?.text || message.event?.delta?.thinking)) {
@@ -3356,20 +3418,20 @@ function historyState(messages) {
         } else if (pending.name === "TaskList" && Array.isArray(message.tool_use_result?.tasks)) {
           const known = new Map(tasks);
           tasks.clear();
-          for (const task of message.tool_use_result.tasks) {
-            const previous = known.get(String(task.id));
-            const restored = {
+          for (const task of message.tool_use_result.tasks) {
+            const previous = known.get(String(task.id));
+            const restored = {
               id: String(task.id),
               subject: task.subject || "작업",
-              status: previous?.status || "pending",
+              status: previous?.status || "pending",
               turnId: previous?.turnId ?? turn.id,
               // A listing restates the plan; it does not re-run it, so the
               // timings already measured for these steps have to survive it.
               startedAt: previous?.startedAt,
               elapsedMs: previous?.elapsedMs,
-            };
-            markTaskStatus(restored, task.status || "pending", messageTime(message));
-            tasks.set(String(task.id), restored);
+            };
+            markTaskStatus(restored, task.status || "pending", messageTime(message));
+            tasks.set(String(task.id), restored);
           }
           const current = latestTaskPlan(tasks);
           tasks.clear();
@@ -3392,9 +3454,9 @@ function historyState(messages) {
     const text = [...tasks.values()].map((task, index) => `${task.status === "completed" ? "✓" : task.status === "in_progress" ? "▸" : "□"} ${numberedTaskSubject(task.subject, index)}`).join("\n");
     // The text alone cannot say how long a step took, so the measured times ride
     // alongside it and the restored plan shows its total instead of zero.
-    const steps = [...tasks.values()].map((task, index) => ({
-      id: task.id,
-      step: numberedTaskSubject(task.subject, index),
+    const steps = [...tasks.values()].map((task, index) => ({
+      id: task.id,
+      step: numberedTaskSubject(task.subject, index),
       status: task.status || "pending",
       elapsedMs: task.elapsedMs ?? null,
     }));
@@ -3884,6 +3946,9 @@ async function dispatch(method, params = {}) {
         if (session.turn === turn) delete turn.interruptRequested;
         throw error;
       }
+      // Kept open for a steer whose run has not begun: nothing is running to
+      // send the result that would close it.
+      if (session.turn === turn && turn.awaitingSteer) finishTurn(session, null);
     }
     return {};
   }
@@ -4460,35 +4525,35 @@ async function runSelfTest() {
     at(taskUse("timed-done", "timed-done", "TaskUpdate", { taskId: "t1", status: "completed" }), "2026-08-07T01:00:09.000Z"),
   ];
   const timedPlan = historyState(timedMessages).turns.at(-1)?.items.find((item) => item.type === "plan");
-  if (timedPlan?.steps?.[0]?.elapsedMs !== 6000 || timedPlan.steps[0].status !== "completed") {
-    throw new Error(`Claude plan step timing self-test failed: ${JSON.stringify(timedPlan)}`);
-  }
-  const timedLiveSession = {
-    id: "timed-live-plan",
-    turn: { id: "timed-live-turn" },
-    tasks: historyState(timedMessages).tasks,
-  };
-  const timedLiveEvents = [];
-  const timedLiveWrite = process.stdout.write;
-  process.stdout.write = (chunk) => { timedLiveEvents.push(JSON.parse(String(chunk))); return true; };
-  try {
-    updatePlanFromToolResult(timedLiveSession, { name: "TaskList" }, {
-      tool_use_result: { tasks: [{ id: "t1", subject: "1. 확인한 설정", status: "completed" }] },
-    });
-  } finally {
-    process.stdout.write = timedLiveWrite;
-  }
-  const liveMeasured = timedLiveEvents.at(-1)?.params?.plan?.[0];
-  if (liveMeasured?.elapsedMs !== 6000 || timedLiveSession.tasks.get("t1")?.elapsedMs !== 6000) {
-    throw new Error(`Claude live plan timing self-test failed: ${JSON.stringify(liveMeasured)}`);
-  }
-  const restartedTask = { status: "pending" };
-  markTaskStatus(restartedTask, "in_progress", 1000);
-  markTaskStatus(restartedTask, "completed", 7000);
-  markTaskStatus(restartedTask, "in_progress", 9000);
-  markTaskStatus(restartedTask, "completed", 10000);
-  if (restartedTask.elapsedMs !== 1000) throw new Error("Claude restarted task timing self-test failed");
-  const skippedTasks = new Map([
+  if (timedPlan?.steps?.[0]?.elapsedMs !== 6000 || timedPlan.steps[0].status !== "completed") {
+    throw new Error(`Claude plan step timing self-test failed: ${JSON.stringify(timedPlan)}`);
+  }
+  const timedLiveSession = {
+    id: "timed-live-plan",
+    turn: { id: "timed-live-turn" },
+    tasks: historyState(timedMessages).tasks,
+  };
+  const timedLiveEvents = [];
+  const timedLiveWrite = process.stdout.write;
+  process.stdout.write = (chunk) => { timedLiveEvents.push(JSON.parse(String(chunk))); return true; };
+  try {
+    updatePlanFromToolResult(timedLiveSession, { name: "TaskList" }, {
+      tool_use_result: { tasks: [{ id: "t1", subject: "1. 확인한 설정", status: "completed" }] },
+    });
+  } finally {
+    process.stdout.write = timedLiveWrite;
+  }
+  const liveMeasured = timedLiveEvents.at(-1)?.params?.plan?.[0];
+  if (liveMeasured?.elapsedMs !== 6000 || timedLiveSession.tasks.get("t1")?.elapsedMs !== 6000) {
+    throw new Error(`Claude live plan timing self-test failed: ${JSON.stringify(liveMeasured)}`);
+  }
+  const restartedTask = { status: "pending" };
+  markTaskStatus(restartedTask, "in_progress", 1000);
+  markTaskStatus(restartedTask, "completed", 7000);
+  markTaskStatus(restartedTask, "in_progress", 9000);
+  markTaskStatus(restartedTask, "completed", 10000);
+  if (restartedTask.elapsedMs !== 1000) throw new Error("Claude restarted task timing self-test failed");
+  const skippedTasks = new Map([
     ["1", { id: "1", subject: "1. 조사", status: "pending" }],
     ["2", { id: "2", subject: "2. 분석", status: "pending" }],
     ["3", { id: "3", subject: "3. 검증", status: "pending" }],
@@ -4869,6 +4934,64 @@ async function runSelfTest() {
     if (authTurn?.error?.codexErrorInfo !== "unauthorized" || !authTurn.error.message.includes("401")) {
       throw new Error(`Claude login failure lost its tag: ${JSON.stringify(authTurn)}`);
     }
+    // A steer answered in a run of its own stays in the turn it joined.
+    const steerNotices = [];
+    const steerWrite = process.stdout.write;
+    process.stdout.write = (chunk) => { steerNotices.push(JSON.parse(String(chunk))); return true; };
+    const steerSession = {
+      ...automaticTurnSession,
+      id: "steer-continuation-self-test",
+      turn: null,
+      streamBlocks: new Map(),
+      tools: new Map(),
+      tasks: new Map(),
+      subagents: new Map(),
+      pendingPrompts: [],
+      query: { ...automaticTurnSession.query, async interrupt() {} },
+    };
+    sessions.set(steerSession.id, steerSession);
+    const steerResult = (queued) => ({ type: "result", is_error: false, stop_reason: "end_turn", modelUsage: {}, queued_turn_count: queued });
+    const steerRun = { type: "stream_event", parent_tool_use_id: null, event: { type: "message_start", message: {} } };
+    const steerLifecycle = () => steerNotices
+      .filter((notice) => notice.method === "turn/started" || notice.method === "turn/completed")
+      .map((notice) => notice.method)
+      .join();
+    try {
+      const steerTurn = beginTurn(steerSession);
+      steerSession.steerPending = 1;
+      await consumeMessage(steerSession, steerResult(1));
+      await consumeMessage(steerSession, steerRun);
+      if (steerSession.turn?.id !== steerTurn || steerSession.steerPending !== 0) {
+        throw new Error("Claude steer run left the turn it joined");
+      }
+      await consumeMessage(steerSession, steerResult(0));
+      if (steerLifecycle() !== "turn/started,turn/completed") {
+        throw new Error(`Claude steer run reopened its turn: ${steerLifecycle()}`);
+      }
+      // A steer read only after the result still gets a turn from the debt.
+      steerNotices.length = 0;
+      beginTurn(steerSession);
+      steerSession.steerPending = 1;
+      await consumeMessage(steerSession, steerResult(0));
+      await consumeMessage(steerSession, steerRun);
+      if (steerLifecycle() !== "turn/started,turn/completed,turn/started") {
+        throw new Error(`Claude late steer lost its turn: ${steerLifecycle()}`);
+      }
+      // Esc before the steer's run begins closes the turn instead of stranding it.
+      finishTurn(steerSession, null);
+      beginTurn(steerSession);
+      steerSession.steerPending = 1;
+      await consumeMessage(steerSession, steerResult(1));
+      steerNotices.length = 0;
+      await dispatch("session/interrupt", { sessionId: steerSession.id });
+      const stopped = steerNotices.find((notice) => notice.method === "turn/completed")?.params?.turn;
+      if (steerSession.turn || stopped?.status !== "interrupted") {
+        throw new Error(`Claude steer wait survived Esc: ${JSON.stringify(stopped)}`);
+      }
+    } finally {
+      process.stdout.write = steerWrite;
+      sessions.delete(steerSession.id);
+    }
     beginTurn(limitSession);
     for (let attempt = 0; attempt < 4; attempt++) {
       await rejectLimit();
@@ -5163,6 +5286,68 @@ async function runSelfTest() {
       throw new Error("Claude background task snapshot did not remove a finished subagent");
     }
 
+    // parent_task_id puts what a subagent launched right under its row, one
+    // level in; a parent that is gone leaves the child at the top level.
+    const nestedSession = {
+      id: "nested-self-test",
+      turn: null,
+      subagents: new Map(),
+      knownSubagents: new Map(),
+      hiddenSubagentTasks: new Set(),
+      ambientSubagentTasks: new Set(),
+      subagentPulse: null,
+    };
+    processSubagentSystemMessage(nestedSession, {
+      type: "system",
+      subtype: "task_started",
+      task_id: "agent-outer",
+      tool_use_id: "toolu_outer",
+      task_type: "local_agent",
+      subagent_type: "Explore",
+    });
+    processSubagentSystemMessage(nestedSession, {
+      type: "system",
+      subtype: "background_tasks_changed",
+      tasks: [
+        { task_id: "shell-orphan", task_type: "local_bash", description: "npm run dev", parent_task_id: "agent-gone" },
+        { task_id: "shell-inner", task_type: "local_bash", description: "ping", parent_task_id: "agent-outer" },
+      ],
+    });
+    processSubagentSystemMessage(nestedSession, {
+      type: "system",
+      subtype: "task_started",
+      task_id: "agent-inner",
+      tool_use_id: "toolu_inner",
+      task_type: "local_agent",
+      subagent_type: "Plan",
+      parent_task_id: "agent-outer",
+    });
+    const nestedRows = () => captured.join("").trim().split("\n").filter(Boolean)
+      .map((line) => JSON.parse(line))
+      .filter((line) => line.method === "turn/subagents/updated" && line.params.threadId === "nested-self-test")
+      .at(-1)?.params.subagents.map((row) => `${row.depth}:${row.id}`);
+    const expectedNesting = ["0:toolu_outer", "1:task:shell-inner", "1:toolu_inner", "0:task:shell-orphan"];
+    if (JSON.stringify(nestedRows()) !== JSON.stringify(expectedNesting)) {
+      throw new Error(`Claude nested subagent self-test failed: ${JSON.stringify(nestedRows())}`);
+    }
+    // Rows naming each other as parent have no root; none may vanish or repeat.
+    nestedSession.subagents.get("toolu_outer").parentTaskId = "agent-inner";
+    emitSubagents(nestedSession);
+    const looped = nestedRows() || [];
+    if (looped.length !== 4 || new Set(looped.map((row) => row.split(":").slice(1).join(":"))).size !== 4) {
+      throw new Error(`Claude subagent parent loop self-test failed: ${JSON.stringify(looped)}`);
+    }
+    // A resumed subagent's messages find its row through agent_id.
+    recordSubagentMessage(nestedSession, {
+      parent_tool_use_id: "toolu_unknown",
+      agent_id: "agent-inner",
+      message: { content: [{ type: "tool_use", id: "toolu_read", name: "Read", input: { file_path: "a.rs" } }] },
+    });
+    if (nestedSession.subagents.get("toolu_inner")?.tool !== "Read(a.rs)") {
+      throw new Error("Claude subagent agent_id self-test failed");
+    }
+    clearSubagents(nestedSession);
+
     processSubagentSystemMessage(structuredSession, {
       type: "system",
       subtype: "background_tasks_changed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devez-vibe",
-  "version": "1.9.40",
+  "version": "1.9.42",
   "type": "module",
   "description": "Stable terminal UI for Codex and Claude Agent SDK",
   "keywords": [
@@ -45,6 +45,6 @@
     "postinstall": "node install-skills.mjs && node prepare-search-deps.mjs"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.283"
+    "@anthropic-ai/claude-agent-sdk": "0.3.292"
   }
 }