@vellumai/assistant 0.4.55 → 0.4.57

package/src/__tests__/subagent-tools.test.ts

@@ -7,7 +7,7 @@ let mockGetMessages: (
   conversationId: string,
 ) => Array<{ role: string; content: string }> | null = () => null;
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationThreadType: () => "default",
+  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
@@ -61,21 +61,25 @@ const findTool = (name: string) =>
 function injectSubagent(
   manager: SubagentManager,
   subagentId: string,
-  parentSessionId: string,
+  parentConversationId: string,
   status: SubagentState["status"] = "running",
   overrides: Partial<SubagentState> = {},
 ): SubagentState {
   const internals = manager as unknown as {
     subagents: Map<
       string,
-      { session: unknown; state: SubagentState; parentSendToClient: () => void }
+      {
+        conversation: unknown;
+        state: SubagentState;
+        parentSendToClient: () => void;
+      }
     >;
     parentToChildren: Map<string, Set<string>>;
   };
   const state: SubagentState = {
     config: {
       id: subagentId,
-      parentSessionId,
+      parentConversationId,
       label: "Test",
       objective: "test",
     },
@@ -85,7 +89,7 @@ function injectSubagent(
     usage: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
     ...overrides,
   };
-  const fakeSession = {
+  const fakeConversation = {
     abort: () => {},
     dispose: () => {},
     messages: [],
@@ -96,22 +100,24 @@ function injectSubagent(
     runAgentLoop: async () => {},
   };
   internals.subagents.set(subagentId, {
-    session: fakeSession,
+    conversation: fakeConversation,
     state,
     parentSendToClient: () => {},
   });
-  if (!internals.parentToChildren.has(parentSessionId)) {
-    internals.parentToChildren.set(parentSessionId, new Set());
+  if (!internals.parentToChildren.has(parentConversationId)) {
+    internals.parentToChildren.set(parentConversationId, new Set());
   }
-  internals.parentToChildren.get(parentSessionId)!.add(subagentId);
+  internals.parentToChildren.get(parentConversationId)!.add(subagentId);
   return state;
 }
 
-function makeContext(sessionId: string, extras: Record<string, unknown> = {}) {
+function makeContext(
+  conversationId: string,
+  extras: Record<string, unknown> = {},
+) {
   return {
     workingDir: "/tmp",
-    sessionId,
-    conversationId: "conv-1",
+    conversationId,
     trustClass: "guardian" as const,
     ...extras,
   } as import("../tools/types.js").ToolContext;
@@ -269,61 +275,61 @@ describe("Subagent tool execute validation", () => {
 // ── Ownership validation ────────────────────────────────────────────
 
 describe("Subagent tool ownership validation", () => {
-  const ownerSession = "owner-sess";
-  const otherSession = "other-sess";
+  const ownerConversation = "owner-sess";
+  const otherConversation = "other-sess";
   const subagentId = "owned-sub-1";
 
   const manager = getSubagentManager();
-  injectSubagent(manager, subagentId, ownerSession);
+  injectSubagent(manager, subagentId, ownerConversation);
 
-  test("status rejects non-owner session", async () => {
+  test("status rejects non-owner conversation", async () => {
     const result = await executeSubagentStatus(
       { subagent_id: subagentId },
-      makeContext(otherSession),
+      makeContext(otherConversation),
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain("No subagent found");
   });
 
-  test("status succeeds for owner session", async () => {
+  test("status succeeds for owner conversation", async () => {
     const result = await executeSubagentStatus(
       { subagent_id: subagentId },
-      makeContext(ownerSession),
+      makeContext(ownerConversation),
     );
     expect(result.isError).toBe(false);
   });
 
-  test("message rejects non-owner session", async () => {
+  test("message rejects non-owner conversation", async () => {
     const result = await executeSubagentMessage(
       { subagent_id: subagentId, content: "hello" },
-      makeContext(otherSession),
+      makeContext(otherConversation),
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Could not send");
   });
 
-  test("read rejects non-owner session", async () => {
+  test("read rejects non-owner conversation", async () => {
     const result = await executeSubagentRead(
       { subagent_id: subagentId },
-      makeContext(otherSession),
+      makeContext(otherConversation),
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain("No subagent found");
   });
 
-  test("abort rejects non-owner session", async () => {
+  test("abort rejects non-owner conversation", async () => {
     const result = await executeSubagentAbort(
       { subagent_id: subagentId },
-      makeContext(otherSession),
+      makeContext(otherConversation),
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Could not abort");
   });
 
-  test("abort succeeds for owner session", async () => {
+  test("abort succeeds for owner conversation", async () => {
     const result = await executeSubagentAbort(
       { subagent_id: subagentId },
-      makeContext(ownerSession),
+      makeContext(ownerConversation),
     );
     expect(result.isError).toBe(false);
   });
@@ -396,7 +402,7 @@ describe("Subagent spawn success and failure", () => {
       expect(capturedConfig!.label).toBe("Context test");
       expect(capturedConfig!.objective).toBe("Do it");
       expect(capturedConfig!.context).toBe("Extra info here");
-      expect(capturedConfig!.parentSessionId).toBe("sess-spawn-3");
+      expect(capturedConfig!.parentConversationId).toBe("sess-spawn-3");
     } finally {
       manager.spawn = originalSpawn;
     }
@@ -426,16 +432,16 @@ describe("Subagent spawn success and failure", () => {
 // ── Message success path ────────────────────────────────────────────
 
 describe("Subagent message success path", () => {
-  const ownerSession = "msg-owner-sess";
+  const ownerConversation = "msg-owner-sess";
   const subagentId = "msg-sub-1";
 
-  test("message succeeds for owner session with running subagent", async () => {
+  test("message succeeds for owner conversation with running subagent", async () => {
     const manager = getSubagentManager();
-    injectSubagent(manager, subagentId, ownerSession, "running");
+    injectSubagent(manager, subagentId, ownerConversation, "running");
 
     const result = await executeSubagentMessage(
       { subagent_id: subagentId, content: "Continue working on this" },
-      makeContext(ownerSession),
+      makeContext(ownerConversation),
     );
     expect(result.isError).toBe(false);
     const parsed = JSON.parse(result.content);
@@ -446,11 +452,11 @@ describe("Subagent message success path", () => {
   test("message fails for terminal-state subagent", async () => {
     const manager = getSubagentManager();
     const completedId = "msg-sub-completed";
-    injectSubagent(manager, completedId, ownerSession, "completed");
+    injectSubagent(manager, completedId, ownerConversation, "completed");
 
     const result = await executeSubagentMessage(
       { subagent_id: completedId, content: "Are you there?" },
-      makeContext(ownerSession),
+      makeContext(ownerConversation),
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Could not send");
@@ -460,16 +466,16 @@ describe("Subagent message success path", () => {
 // ── Status detail responses ─────────────────────────────────────────
 
 describe("Subagent status detail responses", () => {
-  const ownerSession = "status-owner-sess";
+  const ownerConversation = "status-owner-sess";
 
   test("individual status returns full detail fields", async () => {
     const manager = getSubagentManager();
     const subagentId = "status-detail-1";
     const now = Date.now();
-    injectSubagent(manager, subagentId, ownerSession, "running", {
+    injectSubagent(manager, subagentId, ownerConversation, "running", {
       config: {
         id: subagentId,
-        parentSessionId: ownerSession,
+        parentConversationId: ownerConversation,
         label: "Detail test",
         objective: "test obj",
       },
@@ -480,7 +486,7 @@ describe("Subagent status detail responses", () => {
 
     const result = await executeSubagentStatus(
       { subagent_id: subagentId },
-      makeContext(ownerSession),
+      makeContext(ownerConversation),
     );
     expect(result.isError).toBe(false);
     const parsed = JSON.parse(result.content);
@@ -495,11 +501,14 @@ describe("Subagent status detail responses", () => {
 
   test("list status returns summary of all children", async () => {
     const manager = getSubagentManager();
-    const listSession = "status-list-sess";
-    injectSubagent(manager, "list-sub-1", listSession, "running");
-    injectSubagent(manager, "list-sub-2", listSession, "completed");
+    const listConversation = "status-list-sess";
+    injectSubagent(manager, "list-sub-1", listConversation, "running");
+    injectSubagent(manager, "list-sub-2", listConversation, "completed");
 
-    const result = await executeSubagentStatus({}, makeContext(listSession));
+    const result = await executeSubagentStatus(
+      {},
+      makeContext(listConversation),
+    );
     expect(result.isError).toBe(false);
     const parsed = JSON.parse(result.content);
     expect(Array.isArray(parsed)).toBe(true);
@@ -512,13 +521,13 @@ describe("Subagent status detail responses", () => {
   test("individual status includes error field for failed subagent", async () => {
     const manager = getSubagentManager();
     const failedId = "status-failed-1";
-    injectSubagent(manager, failedId, ownerSession, "failed", {
+    injectSubagent(manager, failedId, ownerConversation, "failed", {
       error: "Rate limit exceeded",
     });
 
     const result = await executeSubagentStatus(
       { subagent_id: failedId },
-      makeContext(ownerSession),
+      makeContext(ownerConversation),
     );
     expect(result.isError).toBe(false);
     const parsed = JSON.parse(result.content);
@@ -530,16 +539,16 @@ describe("Subagent status detail responses", () => {
 // ── Read tool behavior ──────────────────────────────────────────────
 
 describe("Subagent read tool", () => {
-  const ownerSession = "read-owner-sess";
+  const ownerConversation = "read-owner-sess";
 
   test("read returns wait message for non-terminal subagent", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-running-1";
-    injectSubagent(manager, subagentId, ownerSession, "running");
+    injectSubagent(manager, subagentId, ownerConversation, "running");
 
     const result = await executeSubagentRead(
       { subagent_id: subagentId },
-      makeContext(ownerSession),
+      makeContext(ownerConversation),
     );
     expect(result.isError).toBe(false);
     expect(result.content).toContain("still running");
@@ -549,11 +558,11 @@ describe("Subagent read tool", () => {
   test("read returns wait message for pending subagent", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-pending-1";
-    injectSubagent(manager, subagentId, ownerSession, "pending");
+    injectSubagent(manager, subagentId, ownerConversation, "pending");
 
     const result = await executeSubagentRead(
       { subagent_id: subagentId },
-      makeContext(ownerSession),
+      makeContext(ownerConversation),
     );
     expect(result.isError).toBe(false);
     expect(result.content).toContain("still pending");
@@ -562,7 +571,7 @@ describe("Subagent read tool", () => {
   test("read extracts text from JSON array content blocks", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-json-array-1";
-    injectSubagent(manager, subagentId, ownerSession, "completed");
+    injectSubagent(manager, subagentId, ownerConversation, "completed");
 
     mockGetMessages = (convId: string) => {
       if (convId !== `conv-${subagentId}`) return null;
@@ -584,7 +593,7 @@ describe("Subagent read tool", () => {
     try {
       const result = await executeSubagentRead(
         { subagent_id: subagentId },
-        makeContext(ownerSession),
+        makeContext(ownerConversation),
       );
       expect(result.isError).toBe(false);
       expect(result.content).toContain("Here is the result");
@@ -597,7 +606,7 @@ describe("Subagent read tool", () => {
   test("read handles plain text content", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-plain-1";
-    injectSubagent(manager, subagentId, ownerSession, "completed");
+    injectSubagent(manager, subagentId, ownerConversation, "completed");
 
     mockGetMessages = (convId: string) => {
       if (convId !== `conv-${subagentId}`) return null;
@@ -607,7 +616,7 @@ describe("Subagent read tool", () => {
     try {
       const result = await executeSubagentRead(
         { subagent_id: subagentId },
-        makeContext(ownerSession),
+        makeContext(ownerConversation),
       );
       expect(result.isError).toBe(false);
       expect(result.content).toBe("Plain text response");
@@ -619,7 +628,7 @@ describe("Subagent read tool", () => {
   test("read handles string JSON content", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-str-json-1";
-    injectSubagent(manager, subagentId, ownerSession, "completed");
+    injectSubagent(manager, subagentId, ownerConversation, "completed");
 
     mockGetMessages = (convId: string) => {
       if (convId !== `conv-${subagentId}`) return null;
@@ -631,7 +640,7 @@ describe("Subagent read tool", () => {
     try {
       const result = await executeSubagentRead(
         { subagent_id: subagentId },
-        makeContext(ownerSession),
+        makeContext(ownerConversation),
       );
       expect(result.isError).toBe(false);
       expect(result.content).toBe("A JSON string value");
@@ -643,7 +652,7 @@ describe("Subagent read tool", () => {
   test("read skips non-text content blocks", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-skip-blocks-1";
-    injectSubagent(manager, subagentId, ownerSession, "completed");
+    injectSubagent(manager, subagentId, ownerConversation, "completed");
 
     mockGetMessages = (convId: string) => {
       if (convId !== `conv-${subagentId}`) return null;
@@ -661,7 +670,7 @@ describe("Subagent read tool", () => {
     try {
       const result = await executeSubagentRead(
         { subagent_id: subagentId },
-        makeContext(ownerSession),
+        makeContext(ownerConversation),
       );
       expect(result.isError).toBe(false);
       expect(result.content).toBe("Actual output");
@@ -674,7 +683,7 @@ describe("Subagent read tool", () => {
   test("read returns no-output message when only user/tool messages exist", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-no-output-1";
-    injectSubagent(manager, subagentId, ownerSession, "completed");
+    injectSubagent(manager, subagentId, ownerConversation, "completed");
 
     mockGetMessages = (convId: string) => {
       if (convId !== `conv-${subagentId}`) return null;
@@ -687,7 +696,7 @@ describe("Subagent read tool", () => {
     try {
       const result = await executeSubagentRead(
         { subagent_id: subagentId },
-        makeContext(ownerSession),
+        makeContext(ownerConversation),
       );
       expect(result.isError).toBe(false);
       expect(result.content).toContain("no text output");
@@ -699,14 +708,14 @@ describe("Subagent read tool", () => {
   test("read returns error when no messages in DB", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-empty-db-1";
-    injectSubagent(manager, subagentId, ownerSession, "completed");
+    injectSubagent(manager, subagentId, ownerConversation, "completed");
 
     mockGetMessages = () => [];
 
     try {
       const result = await executeSubagentRead(
         { subagent_id: subagentId },
-        makeContext(ownerSession),
+        makeContext(ownerConversation),
       );
       expect(result.isError).toBe(true);
       expect(result.content).toContain("No messages found");
@@ -718,13 +727,13 @@ describe("Subagent read tool", () => {
   test("read returns error when getMessages returns null", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-null-db-1";
-    injectSubagent(manager, subagentId, ownerSession, "completed");
+    injectSubagent(manager, subagentId, ownerConversation, "completed");
 
     mockGetMessages = () => null;
 
     const result = await executeSubagentRead(
       { subagent_id: subagentId },
-      makeContext(ownerSession),
+      makeContext(ownerConversation),
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain("No messages found");
@@ -733,7 +742,7 @@ describe("Subagent read tool", () => {
   test("read works for failed subagent (terminal state)", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-failed-1";
-    injectSubagent(manager, subagentId, ownerSession, "failed");
+    injectSubagent(manager, subagentId, ownerConversation, "failed");
 
     mockGetMessages = (convId: string) => {
       if (convId !== `conv-${subagentId}`) return null;
@@ -750,7 +759,7 @@ describe("Subagent read tool", () => {
     try {
       const result = await executeSubagentRead(
         { subagent_id: subagentId },
-        makeContext(ownerSession),
+        makeContext(ownerConversation),
       );
       expect(result.isError).toBe(false);
       expect(result.content).toContain("Partial output before failure");
@@ -762,7 +771,7 @@ describe("Subagent read tool", () => {
   test("read works for aborted subagent (terminal state)", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-aborted-1";
-    injectSubagent(manager, subagentId, ownerSession, "aborted");
+    injectSubagent(manager, subagentId, ownerConversation, "aborted");
 
     mockGetMessages = (convId: string) => {
       if (convId !== `conv-${subagentId}`) return null;
@@ -772,7 +781,7 @@ describe("Subagent read tool", () => {
     try {
       const result = await executeSubagentRead(
         { subagent_id: subagentId },
-        makeContext(ownerSession),
+        makeContext(ownerConversation),
       );
       expect(result.isError).toBe(false);
       expect(result.content).toBe("Output before abort");
@@ -784,7 +793,7 @@ describe("Subagent read tool", () => {
   test("read concatenates multiple assistant messages", async () => {
     const manager = getSubagentManager();
     const subagentId = "read-multi-1";
-    injectSubagent(manager, subagentId, ownerSession, "completed");
+    injectSubagent(manager, subagentId, ownerConversation, "completed");
 
     mockGetMessages = (convId: string) => {
       if (convId !== `conv-${subagentId}`) return null;
@@ -799,7 +808,7 @@ describe("Subagent read tool", () => {
     try {
       const result = await executeSubagentRead(
         { subagent_id: subagentId },
-        makeContext(ownerSession),
+        makeContext(ownerConversation),
       );
       expect(result.isError).toBe(false);
       expect(result.content).toContain("First response");

package/src/__tests__/subagent-types.test.ts

@@ -32,7 +32,7 @@ describe("SubagentConfig type shape", () => {
   test("can create a valid config object", () => {
     const config: SubagentConfig = {
       id: "test-id",
-      parentSessionId: "parent-id",
+      parentConversationId: "parent-id",
       label: "Test subagent",
       objective: "Do something",
     };
@@ -44,7 +44,7 @@ describe("SubagentConfig type shape", () => {
   test("supports optional fields", () => {
     const config: SubagentConfig = {
       id: "test-id",
-      parentSessionId: "parent-id",
+      parentConversationId: "parent-id",
       label: "Test subagent",
       objective: "Do something",
       context: "Extra context",
@@ -62,7 +62,7 @@ describe("SubagentState type shape", () => {
     const state: SubagentState = {
       config: {
         id: "test-id",
-        parentSessionId: "parent-id",
+        parentConversationId: "parent-id",
         label: "Test",
         objective: "Do something",
       },

package/src/__tests__/surface-mutex-cleanup.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { createSurfaceMutex } from "../daemon/session-surfaces.js";
+import { createSurfaceMutex } from "../daemon/conversation-surfaces.js";
 
 describe("createSurfaceMutex cleanup", () => {
   test("map entry is removed after the queue drains", async () => {

package/src/__tests__/{swarm-session-integration.test.ts → swarm-conversation-integration.test.ts}

@@ -35,6 +35,19 @@ mock.module("../config/loader.js", () => ({
       plannerModelIntent: "latency-optimized",
       synthesizerModelIntent: "quality-optimized",
     },
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
   }),
 }));
 
@@ -89,7 +102,6 @@ import type { ToolContext } from "../tools/types.js";
 
 function makeContext(overrides?: Partial<ToolContext>): ToolContext {
   return {
-    sessionId: "test-session",
     conversationId: "test-conv",
     workingDir: "/tmp/test",
     trustClass: "guardian",

package/src/__tests__/swarm-recursion.test.ts

@@ -47,6 +47,19 @@ mock.module("../config/loader.js", () => ({
       plannerModelIntent: "latency-optimized",
       synthesizerModelIntent: "quality-optimized",
     },
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
   }),
 }));
 
@@ -99,7 +112,6 @@ import type { ToolContext } from "../tools/types.js";
 
 function makeContext(overrides?: Partial<ToolContext>): ToolContext {
   return {
-    sessionId: "test-session",
     conversationId: "test-conv",
     workingDir: "/tmp/test",
     trustClass: "guardian",
@@ -120,7 +132,7 @@ describe("swarm recursion guard (concurrent)", () => {
     // Start first swarm — it will pause at the SDK mock
     const first = swarmDelegateTool.execute(
       { objective: "First task" },
-      makeContext({ sessionId: "session-A" }),
+      makeContext({ conversationId: "session-A" }),
     );
 
     // Yield to let first reach the SDK gate (executeSwarm path)
@@ -129,7 +141,7 @@ describe("swarm recursion guard (concurrent)", () => {
     // Second invocation on the same session should be rejected
     const second = await swarmDelegateTool.execute(
       { objective: "Second task" },
-      makeContext({ sessionId: "session-A" }),
+      makeContext({ conversationId: "session-A" }),
     );
     expect(second.isError).toBe(true);
     expect(second.content).toContain("already executing");
@@ -145,8 +157,8 @@ describe("swarm recursion guard (concurrent)", () => {
 
     // Start first swarm on session A
     const first = swarmDelegateTool.execute(
-      { objective: "Session A task" },
-      makeContext({ sessionId: "session-A" }),
+      { objective: "Conversation A task" },
+      makeContext({ conversationId: "session-A" }),
     );
 
     // Yield to let first reach the gate
@@ -157,8 +169,8 @@ describe("swarm recursion guard (concurrent)", () => {
 
     // Second swarm on a different session should succeed
     const second = await swarmDelegateTool.execute(
-      { objective: "Session B task" },
-      makeContext({ sessionId: "session-B" }),
+      { objective: "Conversation B task" },
+      makeContext({ conversationId: "session-B" }),
     );
     expect(second.isError).toBeFalsy();
 
@@ -170,14 +182,14 @@ describe("swarm recursion guard (concurrent)", () => {
     // Run and complete first swarm (no gate)
     const first = await swarmDelegateTool.execute(
       { objective: "First task" },
-      makeContext({ sessionId: "session-A" }),
+      makeContext({ conversationId: "session-A" }),
     );
     expect(first.isError).toBeFalsy();
 
     // Same session should now be allowed again
     const second = await swarmDelegateTool.execute(
       { objective: "Second task" },
-      makeContext({ sessionId: "session-A" }),
+      makeContext({ conversationId: "session-A" }),
     );
     expect(second.isError).toBeFalsy();
   });

package/src/__tests__/swarm-tool.test.ts

@@ -27,6 +27,19 @@ mock.module("../config/loader.js", () => ({
       plannerModelIntent: "latency-optimized",
       synthesizerModelIntent: "quality-optimized",
     },
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
   }),
   getSwarmDisabledConfig: () => ({
     provider: "anthropic",
@@ -93,7 +106,7 @@ import type { ToolContext } from "../tools/types.js";
 
 function makeContext(overrides?: Partial<ToolContext>): ToolContext {
   return {
-    sessionId: "test-session",
+    conversationId: "test-session",
     workingDir: "/tmp/test",
     trustClass: "guardian",
     onOutput: () => {},