retell-sync-cli 1.1.0 → 2.0.0

package/test/getLocalState.test.ts

@@ -1,382 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import fs from "node:fs/promises"
-import os from "node:os"
-import path from "node:path"
-import { getLocalState } from "../src/lib/agents"
-
-describe("getLocalState", () => {
-  let tmpDir: string
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "retell-sync-test-"))
-  })
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true })
-  })
-
-  test("hydrates retell-llm agent with file placeholders resolved", async () => {
-    const agentsDir = path.join(tmpDir, "agents")
-    const agentDir = path.join(agentsDir, "test_llm_agent_abc123")
-
-    await fs.mkdir(agentDir, { recursive: true })
-
-    await Bun.write(
-      path.join(agentDir, ".agent.json"),
-      JSON.stringify({
-        id: "agent_abc123456789",
-        version: 1,
-        responseEngineVersion: 1,
-      }),
-    )
-
-    await Bun.write(
-      path.join(agentDir, "config.json"),
-      JSON.stringify(
-        {
-          channel: "voice",
-          agent_name: "Test LLM Agent",
-          response_engine: {
-            type: "retell-llm",
-            llm_id: "llm_test123",
-            version: 1,
-          },
-          voice_id: "11labs-Chloe",
-        },
-        null,
-        2,
-      ),
-    )
-
-    await Bun.write(
-      path.join(agentDir, "llm.json"),
-      JSON.stringify(
-        {
-          model: "gpt-4.1",
-          general_prompt: "file://./general_prompt.md",
-          begin_message: "Hello!",
-        },
-        null,
-        2,
-      ),
-    )
-
-    await Bun.write(
-      path.join(agentDir, "general_prompt.md"),
-      `---
-some_meta: value
----
-
-You are a helpful assistant.
-
-Be friendly and professional.
-`,
-    )
-
-    const result = await getLocalState({ agentsDir })
-
-    expect(result.voiceAgents).toHaveLength(1)
-    expect(result.llms).toHaveLength(1)
-    expect(result.conversationFlows).toHaveLength(0)
-
-    const agent = result.voiceAgents[0]!
-    expect(agent.agent_name).toBe("Test LLM Agent")
-    expect(agent.response_engine.type).toBe("retell-llm")
-    expect(agent.voice_id).toBe("11labs-Chloe")
-
-    const llm = result.llms[0]!
-    expect(llm.model).toBe("gpt-4.1")
-    expect(llm.begin_message).toBe("Hello!")
-    // Verify file placeholder was resolved
-    expect(llm.general_prompt).toContain("You are a helpful assistant.")
-    expect(llm.general_prompt).toContain("Be friendly and professional.")
-    // Frontmatter should be stripped
-    expect(llm.general_prompt).not.toContain("some_meta")
-  })
-
-  test("hydrates conversation-flow agent with nested file placeholders", async () => {
-    const agentsDir = path.join(tmpDir, "agents")
-    const agentDir = path.join(agentsDir, "test_flow_agent_def456")
-    const nodesDir = path.join(agentDir, "nodes")
-
-    await fs.mkdir(nodesDir, { recursive: true })
-
-    await Bun.write(
-      path.join(agentDir, ".agent.json"),
-      JSON.stringify({
-        id: "agent_def456789012",
-        version: 2,
-        responseEngineVersion: 2,
-      }),
-    )
-
-    await Bun.write(
-      path.join(agentDir, "config.json"),
-      JSON.stringify(
-        {
-          channel: "voice",
-          agent_name: "Test Flow Agent",
-          response_engine: {
-            type: "conversation-flow",
-            conversation_flow_id: "flow_test456",
-            version: 2,
-          },
-          voice_id: "openai-Alloy",
-        },
-        null,
-        2,
-      ),
-    )
-
-    await Bun.write(
-      path.join(agentDir, "conversation-flow.json"),
-      JSON.stringify(
-        {
-          global_prompt: "file://./global_prompt.md",
-          nodes: [
-            {
-              id: "start-node",
-              name: "Welcome",
-              type: "conversation",
-              instruction: {
-                type: "static_text",
-                text: "Hello, welcome!",
-              },
-              edges: [],
-            },
-            {
-              id: "node-inquiry",
-              name: "Handle Inquiry",
-              type: "conversation",
-              instruction: {
-                type: "prompt",
-                text: "file://./nodes/inquiry_abc123.md",
-              },
-              edges: [],
-            },
-          ],
-        },
-        null,
-        2,
-      ),
-    )
-
-    await Bun.write(
-      path.join(agentDir, "global_prompt.md"),
-      `---
-version: 1
----
-
-You are a professional receptionist.
-
-Always be polite and helpful.
-`,
-    )
-
-    await Bun.write(
-      path.join(nodesDir, "inquiry_abc123.md"),
-      `---
-nodeId: "node-inquiry"
-name: "Handle Inquiry"
----
-
-Answer the caller's question to the best of your ability.
-
-If you don't know, offer to transfer them.
-`,
-    )
-
-    const result = await getLocalState({ agentsDir })
-
-    expect(result.voiceAgents).toHaveLength(1)
-    expect(result.llms).toHaveLength(0)
-    expect(result.conversationFlows).toHaveLength(1)
-
-    const agent = result.voiceAgents[0]!
-    expect(agent.agent_name).toBe("Test Flow Agent")
-    expect(agent.response_engine.type).toBe("conversation-flow")
-
-    const flow = result.conversationFlows[0]!
-    // Global prompt placeholder should be resolved
-    expect(flow.global_prompt).toContain("You are a professional receptionist.")
-    expect(flow.global_prompt).toContain("Always be polite and helpful.")
-    expect(flow.global_prompt).not.toContain("version: 1")
-
-    // Node instruction placeholder should be resolved
-    const inquiryNode = flow.nodes?.find((n) => n.id === "node-inquiry")
-    expect(inquiryNode).toBeDefined()
-    expect(
-      inquiryNode?.type === "conversation" && inquiryNode.instruction.text,
-    ).toContain("Answer the caller's question")
-    expect(
-      inquiryNode?.type === "conversation" && inquiryNode.instruction.text,
-    ).toContain("offer to transfer them")
-    // Frontmatter should be stripped from node
-    expect(
-      inquiryNode?.type === "conversation" && inquiryNode.instruction.text,
-    ).not.toContain("nodeId")
-  })
-
-  test("handles multiple agents of different types", async () => {
-    const agentsDir = path.join(tmpDir, "agents")
-
-    // Create LLM agent
-    const llmAgentDir = path.join(agentsDir, "llm_agent_111111")
-    await fs.mkdir(llmAgentDir, { recursive: true })
-    await Bun.write(
-      path.join(llmAgentDir, ".agent.json"),
-      JSON.stringify({
-        id: "agent_llm_1",
-        version: 1,
-        responseEngineVersion: 1,
-      }),
-    )
-    await Bun.write(
-      path.join(llmAgentDir, "config.json"),
-      JSON.stringify({
-        agent_name: "LLM Agent",
-        response_engine: { type: "retell-llm", llm_id: "llm_1", version: 1 },
-      }),
-    )
-    await Bun.write(
-      path.join(llmAgentDir, "llm.json"),
-      JSON.stringify({ model: "gpt-4" }),
-    )
-
-    // Create Flow agent
-    const flowAgentDir = path.join(agentsDir, "flow_agent_222222")
-    await fs.mkdir(flowAgentDir, { recursive: true })
-    await Bun.write(
-      path.join(flowAgentDir, ".agent.json"),
-      JSON.stringify({
-        id: "agent_flow_1",
-        version: 1,
-        responseEngineVersion: 1,
-      }),
-    )
-    await Bun.write(
-      path.join(flowAgentDir, "config.json"),
-      JSON.stringify({
-        agent_name: "Flow Agent",
-        response_engine: {
-          type: "conversation-flow",
-          conversation_flow_id: "flow_1",
-          version: 1,
-        },
-      }),
-    )
-    await Bun.write(
-      path.join(flowAgentDir, "conversation-flow.json"),
-      JSON.stringify({ nodes: [] }),
-    )
-
-    const result = await getLocalState({ agentsDir })
-
-    expect(result.voiceAgents).toHaveLength(2)
-    expect(result.llms).toHaveLength(1)
-    expect(result.conversationFlows).toHaveLength(1)
-
-    const agentNames = result.voiceAgents.map((a) => a.agent_name).sort()
-    expect(agentNames).toEqual(["Flow Agent", "LLM Agent"])
-  })
-
-  test("skips directories without .agent.json file", async () => {
-    const agentsDir = path.join(tmpDir, "agents")
-
-    // Create valid agent
-    const validDir = path.join(agentsDir, "valid_agent_aaa111")
-    await fs.mkdir(validDir, { recursive: true })
-    await Bun.write(
-      path.join(validDir, ".agent.json"),
-      JSON.stringify({
-        id: "agent_valid",
-        version: 1,
-        responseEngineVersion: 1,
-      }),
-    )
-    await Bun.write(
-      path.join(validDir, "config.json"),
-      JSON.stringify({
-        agent_name: "Valid Agent",
-        response_engine: { type: "retell-llm", llm_id: "llm_v", version: 1 },
-      }),
-    )
-    await Bun.write(
-      path.join(validDir, "llm.json"),
-      JSON.stringify({ model: "gpt-4" }),
-    )
-
-    // Create directory without .agent.json (should be skipped)
-    const invalidDir = path.join(agentsDir, "not_an_agent")
-    await fs.mkdir(invalidDir, { recursive: true })
-    await Bun.write(
-      path.join(invalidDir, "config.json"),
-      JSON.stringify({ agent_name: "Invalid" }),
-    )
-
-    const result = await getLocalState({ agentsDir })
-
-    expect(result.voiceAgents).toHaveLength(1)
-    expect(result.voiceAgents[0]!.agent_name).toBe("Valid Agent")
-  })
-
-  test("returns empty arrays when agentsDir is empty", async () => {
-    const agentsDir = path.join(tmpDir, "agents")
-    await fs.mkdir(agentsDir, { recursive: true })
-
-    const result = await getLocalState({ agentsDir })
-
-    expect(result.voiceAgents).toHaveLength(0)
-    expect(result.llms).toHaveLength(0)
-    expect(result.conversationFlows).toHaveLength(0)
-  })
-
-  test("reads current filesystem state", async () => {
-    const agentsDir = path.join(tmpDir, "agents")
-    const agentDir = path.join(agentsDir, "dynamic_agent_xyz789")
-
-    await fs.mkdir(agentDir, { recursive: true })
-    await Bun.write(
-      path.join(agentDir, ".agent.json"),
-      JSON.stringify({
-        id: "agent_dynamic",
-        version: 1,
-        responseEngineVersion: 1,
-      }),
-    )
-    await Bun.write(
-      path.join(agentDir, "config.json"),
-      JSON.stringify({
-        agent_name: "Initial Name",
-        response_engine: { type: "retell-llm", llm_id: "llm_d", version: 1 },
-      }),
-    )
-    await Bun.write(
-      path.join(agentDir, "llm.json"),
-      JSON.stringify({ model: "gpt-3.5" }),
-    )
-
-    // First read
-    const result1 = await getLocalState({ agentsDir })
-    expect(result1.voiceAgents[0]!.agent_name).toBe("Initial Name")
-    expect(result1.llms[0]!.model as string).toBe("gpt-3.5")
-
-    // Modify files
-    await Bun.write(
-      path.join(agentDir, "config.json"),
-      JSON.stringify({
-        agent_name: "Updated Name",
-        response_engine: { type: "retell-llm", llm_id: "llm_d", version: 1 },
-      }),
-    )
-    await Bun.write(
-      path.join(agentDir, "llm.json"),
-      JSON.stringify({ model: "gpt-4" }),
-    )
-
-    // Second read should reflect changes
-    const result2 = await getLocalState({ agentsDir })
-    expect(result2.voiceAgents[0]!.agent_name).toBe("Updated Name")
-    expect(result2.llms[0]!.model as string).toBe("gpt-4")
-  })
-})

package/test/getRemoteState.test.ts

@@ -1,196 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test"
-import type Retell from "retell-sdk"
-import { getRemoteState, retell } from "../src/lib/agents"
-import rawAgents from "./raw-agents-list-response.json"
-import rawConversationFlows from "./raw-conversation-flow-list-response.json"
-import rawLlms from "./raw-llms-list-response.json"
-
-describe("getRemoteState", () => {
-  beforeEach(() => {
-    // Mock the retell API methods - using Object.assign to avoid type issues with mocking
-    Object.assign(retell.agent, {
-      list: mock(() =>
-        Promise.resolve(rawAgents as Retell.Agent.AgentResponse[]),
-      ),
-    })
-    Object.assign(retell.llm, {
-      list: mock(() => Promise.resolve(rawLlms as Retell.Llm.LlmResponse[])),
-    })
-    Object.assign(retell.conversationFlow, {
-      list: mock(() =>
-        Promise.resolve(
-          rawConversationFlows as Retell.ConversationFlow.ConversationFlowResponse[],
-        ),
-      ),
-    })
-  })
-
-  test("returns all agents (including unpublished)", async () => {
-    const result = await getRemoteState()
-
-    // All unique agent_ids should be represented
-    const uniqueAgentIds = new Set(rawAgents.map((a) => a.agent_id))
-    const returnedIds = new Set(result.voiceAgents.map((a) => a._id))
-
-    expect(returnedIds.size).toBe(uniqueAgentIds.size)
-    for (const id of uniqueAgentIds) {
-      expect(returnedIds).toContain(id)
-    }
-  })
-
-  test("returns latest version of each unique agent", async () => {
-    const result = await getRemoteState()
-
-    // Group raw agents by agent_id and find expected latest versions
-    const agentGroups = new Map<string, (typeof rawAgents)[number][]>()
-    for (const agent of rawAgents) {
-      const existing = agentGroups.get(agent.agent_id) ?? []
-      existing.push(agent)
-      agentGroups.set(agent.agent_id, existing)
-    }
-
-    // For each agent_id, we should have exactly one result (the latest version)
-    const uniqueAgentIds = new Set(result.voiceAgents.map((a) => a._id))
-    expect(uniqueAgentIds.size).toBe(result.voiceAgents.length)
-
-    // Verify each returned agent is the highest version for its agent_id
-    for (const agent of result.voiceAgents) {
-      const allVersions = agentGroups.get(agent._id)
-      if (allVersions && allVersions.length > 1) {
-        const maxVersion = Math.max(...allVersions.map((a) => a.version ?? 0))
-        // The response_engine.version should match the max
-        const engineVersion =
-          "version" in agent.response_engine
-            ? agent.response_engine.version
-            : undefined
-        expect(engineVersion).toBe(maxVersion)
-      }
-    }
-  })
-
-  test("strips readonly fields from agents", async () => {
-    const result = await getRemoteState()
-
-    for (const agent of result.voiceAgents) {
-      // These fields should be stripped
-      expect(agent).not.toHaveProperty("last_modification_timestamp")
-      expect(agent).not.toHaveProperty("version")
-      expect(agent).not.toHaveProperty("is_published")
-      expect(agent).not.toHaveProperty("agent_id")
-
-      // _id should exist (renamed from agent_id)
-      expect(agent).toHaveProperty("_id")
-    }
-  })
-
-  test("returns only conversation flows referenced by agents", async () => {
-    const result = await getRemoteState()
-
-    // Get all conversation flow IDs referenced by returned agents
-    const referencedFlowIds = new Set<string>()
-    for (const agent of result.voiceAgents) {
-      if (agent.response_engine.type === "conversation-flow") {
-        referencedFlowIds.add(agent.response_engine.conversation_flow_id)
-      }
-    }
-
-    // Every returned flow should be referenced by an agent
-    for (const flow of result.conversationFlows) {
-      expect(referencedFlowIds).toContain(flow._id)
-    }
-
-    // The number of flows should match or be less than references (some agents may share flows)
-    expect(result.conversationFlows.length).toBeLessThanOrEqual(
-      referencedFlowIds.size,
-    )
-  })
-
-  test("returns only LLMs referenced by agents", async () => {
-    const result = await getRemoteState()
-
-    // Get all LLM IDs referenced by returned agents
-    const referencedLlmIds = new Set<string>()
-    for (const agent of result.voiceAgents) {
-      if (agent.response_engine.type === "retell-llm") {
-        referencedLlmIds.add(agent.response_engine.llm_id)
-      }
-    }
-
-    // Every returned LLM should be referenced by an agent
-    for (const llm of result.llms) {
-      expect(referencedLlmIds).toContain(llm._id)
-    }
-  })
-
-  test("strips readonly fields from conversation flows", async () => {
-    const result = await getRemoteState()
-
-    for (const flow of result.conversationFlows) {
-      expect(flow).not.toHaveProperty("version")
-      expect(flow).not.toHaveProperty("is_published")
-      expect(flow).not.toHaveProperty("conversation_flow_id")
-      expect(flow).toHaveProperty("_id")
-    }
-  })
-
-  test("strips readonly fields from LLMs", async () => {
-    const result = await getRemoteState()
-
-    for (const llm of result.llms) {
-      expect(llm).not.toHaveProperty("version")
-      expect(llm).not.toHaveProperty("is_published")
-      expect(llm).not.toHaveProperty("last_modification_timestamp")
-      expect(llm).not.toHaveProperty("llm_id")
-      expect(llm).toHaveProperty("_id")
-    }
-  })
-
-  test("matches conversation flow versions to agent references", async () => {
-    const result = await getRemoteState()
-
-    // Build a map of what flow version each agent expects
-    const expectedFlowVersions = new Map<string, number | null | undefined>()
-    for (const agent of result.voiceAgents) {
-      if (agent.response_engine.type === "conversation-flow") {
-        expectedFlowVersions.set(
-          agent.response_engine.conversation_flow_id,
-          agent.response_engine.version,
-        )
-      }
-    }
-
-    // Each returned flow should have the version that matches what the agent references
-    for (const flow of result.conversationFlows) {
-      const expectedVersion = expectedFlowVersions.get(flow._id)
-      const rawFlow = rawConversationFlows.find(
-        (f) =>
-          f.conversation_flow_id === flow._id && f.version === expectedVersion,
-      )
-      expect(rawFlow).toBeDefined()
-    }
-  })
-
-  test("matches LLM versions to agent references", async () => {
-    const result = await getRemoteState()
-
-    // Build a map of what LLM version each agent expects
-    const expectedLlmVersions = new Map<string, number | null | undefined>()
-    for (const agent of result.voiceAgents) {
-      if (agent.response_engine.type === "retell-llm") {
-        expectedLlmVersions.set(
-          agent.response_engine.llm_id,
-          agent.response_engine.version,
-        )
-      }
-    }
-
-    // Each returned LLM should have the version that matches what the agent references
-    for (const llm of result.llms) {
-      const expectedVersion = expectedLlmVersions.get(llm._id)
-      const rawLlm = rawLlms.find(
-        (l) => l.llm_id === llm._id && l.version === expectedVersion,
-      )
-      expect(rawLlm).toBeDefined()
-    }
-  })
-})